Merge pull request #1295 from Tria-plc/freight/nati-2

Freight/nati 2

apps/edr-freight-api/.env.example

@@ -1,4 +1,10 @@
 # Copy to .env for local/docker compose (not committed).
+
+# Set to "dev" or "staging" to bypass OTP (fixed code 000000 also accepted),
+# payment (invoice auto-marked paid on initiate, no gateway call) and Fayda
+# (canned verified profile, no eSignet call). Leave unset in production.
+ENV=
+
 PORT=3001
 # @tria-plc/auditlog's client interceptor stamps every AuditLog row's
 # `application` from this env var directly, bypassing MezgebModule.forRoot's

apps/edr-freight-api/src/common/dev-bypass.util.ts

@@ -0,0 +1,13 @@
+/**
+ * Dev/staging bypass gate for OTP, payment and Fayda verification.
+ *
+ * Gated purely on `ENV` (dev|staging) — never on NODE_ENV, so it can't be
+ * mistaken for a prod-vs-non-prod switch. `ENV` is simply left unset in
+ * production, so this is always false there.
+ */
+export function isBypassEnv(): boolean {
+  return ["dev", "staging"].includes(process.env.ENV ?? "");
+}
+
+/** Fixed code accepted in addition to the real one when isBypassEnv(). */
+export const DEV_BYPASS_OTP = "000000";

apps/edr-freight-api/src/common/dto/pagination-query.dto.ts

@@ -41,4 +41,16 @@ export class PaginationQueryDto {
   @Transform(({ value }) => String(value).toUpperCase())
   @IsIn(['ASC', 'DESC'])
   sortOrder?: 'ASC' | 'DESC';
+
+  /**
+   * Column to sort by, as a public field name (not a raw SQL column). The
+   * actual whitelist lives in `applySort`'s `sortable` map at each call site,
+   * not here — a per-DTO `@IsIn` is opt-in and has been forgotten before.
+   * An unrecognized value falls back silently rather than 400ing, so a stale
+   * bookmark or shared link never breaks.
+   */
+  @ApiPropertyOptional({ description: 'Public field name; unknown values fall back to the endpoint default.' })
+  @IsOptional()
+  @Transform(({ value }) => (typeof value === 'string' && value.trim() ? value.trim() : undefined))
+  sortBy?: string;
 }

apps/edr-freight-api/src/common/utils/facets.util.ts

@@ -0,0 +1,48 @@
+import { ObjectLiteral, SelectQueryBuilder } from 'typeorm';
+
+export interface FacetBucket {
+  value: string;
+  count: number;
+}
+
+/**
+ * One `GROUP BY` query per faceted column, each with every OTHER active
+ * filter applied but its OWN predicate omitted. That omission is the point:
+ * with `status=SUBMITTED` selected, the status facet still reports
+ * `APPROVED: 8` so the user can switch, while the freightType facet reflects
+ * only the SUBMITTED-scoped set. Omit `search` from nothing — it's a scope,
+ * not a pill, and stays applied in every facet.
+ *
+ * Capped at 50 buckets per column — FK-id facets (warehouseId, yardId) can
+ * have real cardinality; beyond 50 the frontend should fall back to a
+ * typeahead instead of a checkbox list. Never facet a column whose popover
+ * would need its own search box (references, plate numbers, free text).
+ *
+ * @param base          builds a FRESH query builder (soft-delete guard only,
+ *                       no filters) — called once per facet column.
+ * @param applyFilters  applies every filter to `qb`, using `omit` to skip
+ *                       one column's own predicate.
+ * @param columns       facet key -> "alias.column" SQL reference.
+ */
+export async function computeFacets<T extends ObjectLiteral>(
+  base: () => SelectQueryBuilder<T>,
+  applyFilters: (qb: SelectQueryBuilder<T>, omit?: string) => void,
+  columns: Record<string, string>,
+): Promise<Record<string, FacetBucket[]>> {
+  const entries = await Promise.all(
+    Object.entries(columns).map(async ([key, column]) => {
+      const qb = base();
+      applyFilters(qb, key);
+      const rows = await qb
+        .select(column, 'value')
+        .addSelect('COUNT(*)::int', 'count')
+        .andWhere(`${column} IS NOT NULL`)
+        .groupBy(column)
+        .orderBy('count', 'DESC')
+        .limit(50)
+        .getRawMany<{ value: string; count: number }>();
+      return [key, rows.map((r) => ({ value: String(r.value), count: Number(r.count) }))] as const;
+    }),
+  );
+  return Object.fromEntries(entries);
+}

apps/edr-freight-api/src/common/utils/pagination.util.spec.ts

@@ -0,0 +1,76 @@
+import { SelectQueryBuilder } from 'typeorm';
+import { applySort, buildPaginationMeta, normalizePagination } from './pagination.util';
+
+/** Minimal fake — just enough of the SelectQueryBuilder chain applySort touches. */
+function fakeQb() {
+  const calls: Array<{ method: string; args: unknown[] }> = [];
+  const qb = {
+    alias: 'contract',
+    orderBy(...args: unknown[]) {
+      calls.push({ method: 'orderBy', args });
+      return qb;
+    },
+    addOrderBy(...args: unknown[]) {
+      calls.push({ method: 'addOrderBy', args });
+      return qb;
+    },
+  };
+  return { qb: qb as unknown as SelectQueryBuilder<any>, calls };
+}
+
+const SORTABLE = {
+  createdAt: 'contract.createdAt',
+  contractValidUntil: 'contract.contractValidUntil',
+};
+
+describe('applySort', () => {
+  it('resolves a whitelisted sortBy to its column', () => {
+    const { qb, calls } = fakeQb();
+    applySort(qb, { sortBy: 'contractValidUntil', sortOrder: 'ASC' }, SORTABLE, 'createdAt');
+    expect(calls[0]).toEqual({
+      method: 'orderBy',
+      args: ['contract.contractValidUntil', 'ASC'],
+    });
+  });
+
+  it('falls back to the default column for an unknown sortBy instead of throwing', () => {
+    const { qb, calls } = fakeQb();
+    // A stale bookmark or shared link naming a removed/renamed column must
+    // never 400 — it should silently behave as if sortBy were absent.
+    expect(() =>
+      applySort(qb, { sortBy: "id; DROP TABLE contracts; --" }, SORTABLE, 'createdAt'),
+    ).not.toThrow();
+    expect(calls[0]).toEqual({ method: 'orderBy', args: ['contract.createdAt', 'DESC'] });
+  });
+
+  it('defaults sortOrder to DESC when absent or not ASC', () => {
+    const { qb, calls } = fakeQb();
+    applySort(qb, {}, SORTABLE, 'createdAt');
+    expect(calls[0]).toEqual({ method: 'orderBy', args: ['contract.createdAt', 'DESC'] });
+  });
+
+  it('always appends an id ASC tiebreaker', () => {
+    const { qb, calls } = fakeQb();
+    applySort(qb, { sortBy: 'createdAt' }, SORTABLE, 'createdAt');
+    expect(calls[1]).toEqual({ method: 'addOrderBy', args: ['contract.id', 'ASC'] });
+  });
+});
+
+describe('normalizePagination / buildPaginationMeta', () => {
+  it('clamps page to >= 1 and pageSize to the configured max', () => {
+    const p = normalizePagination({ page: 0, pageSize: 999 }, { maxPageSize: 100 });
+    expect(p).toEqual({ page: 1, pageSize: 100, skip: 0, take: 100 });
+  });
+
+  it('computes hasNextPage/hasPreviousPage from total', () => {
+    const meta = buildPaginationMeta(45, 2, 20);
+    expect(meta).toEqual({
+      page: 2,
+      pageSize: 20,
+      total: 45,
+      totalPages: 3,
+      hasNextPage: true,
+      hasPreviousPage: true,
+    });
+  });
+});

apps/edr-freight-api/src/common/utils/pagination.util.ts

@@ -83,3 +83,32 @@ export function paginateArray<T>(
     meta: buildPaginationMeta(rows.length, page, pageSize),
   };
 }
+
+/**
+ * Apply `ORDER BY` from a query DTO's `sortBy`/`sortOrder`, resolved against a
+ * whitelist — never interpolate `sortBy` into a query builder directly, it is
+ * unvalidated user input and an unwhitelisted `orderBy(\`alias.${sortBy}\`)`
+ * is a SQL-injection primitive (see the deleted `findAllWithFilters` methods
+ * on drivers/vehicles repositories, which had exactly that bug).
+ *
+ * An unknown `sortBy` falls back to `fallback` instead of throwing — a stale
+ * bookmark or shared link should never 400.
+ *
+ * Always appends `id ASC` as a tiebreaker: sorting by a non-unique column
+ * (status, createdAt on bulk-imported rows) without one can drop or
+ * duplicate rows across pages once LIMIT/OFFSET is involved.
+ *
+ * @param sortable  public sort key -> "alias.column" SQL reference. Also
+ *   doubles as the Swagger enum / frontend's sortable-column list.
+ * @param fallback  a key that must exist in `sortable`.
+ */
+export function applySort<T extends ObjectLiteral>(
+  qb: SelectQueryBuilder<T>,
+  query: { sortBy?: string; sortOrder?: 'ASC' | 'DESC' },
+  sortable: Record<string, string>,
+  fallback: string,
+): SelectQueryBuilder<T> {
+  const column = (query.sortBy && sortable[query.sortBy]) || sortable[fallback];
+  qb.orderBy(column, query.sortOrder === 'ASC' ? 'ASC' : 'DESC');
+  return qb.addOrderBy(`${qb.alias}.id`, 'ASC');
+}

apps/edr-freight-api/src/migrations/3540000000000-FilterableListIndexes.ts

@@ -0,0 +1,56 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Supports the Stripe-style pill filter bar: every list it lands on filters
+ * and sorts server-side now. `@Index` decorators alone do nothing —
+ * `synchronize: false` means an index exists only if a migration created it
+ * (see the `RepairSynchronizeDrift`-style gaps this closes).
+ *
+ * `idx_warehouse_inventory_status` already exists (FreightBaseline). Bookings
+ * and wagons have no plain `status` index — `idx_bookings_route_day` and
+ * `idx_wagons_readiness` only cover `status` as a trailing/partial column,
+ * not a standalone `WHERE status = $1`, and `status` is the single
+ * most-filtered column on both lists (bookings: 37 values).
+ *
+ * `(created_at DESC, id ASC)` partials match the default sort + id
+ * tiebreaker `applySort` now appends everywhere, and none of these tables
+ * had a created_at index at all.
+ */
+export class FilterableListIndexes3540000000000 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_bookings_status
+        ON freight.bookings USING btree (status)
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_wagons_status
+        ON freight.wagons USING btree (status)
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_contracts_created_at_id
+        ON freight.contracts (created_at DESC, id ASC) WHERE deleted_at IS NULL
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_bookings_created_at_id
+        ON freight.bookings (created_at DESC, id ASC) WHERE deleted_at IS NULL
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_warehouse_inventory_created_at_id
+        ON freight.warehouse_inventory (created_at DESC, id ASC) WHERE deleted_at IS NULL
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_wagons_created_at_id
+        ON freight.wagons (created_at DESC, id ASC) WHERE deleted_at IS NULL
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX IF EXISTS freight.idx_wagons_created_at_id`);
+    await queryRunner.query(`DROP INDEX IF EXISTS freight.idx_warehouse_inventory_created_at_id`);
+    await queryRunner.query(`DROP INDEX IF EXISTS freight.idx_bookings_created_at_id`);
+    await queryRunner.query(`DROP INDEX IF EXISTS freight.idx_contracts_created_at_id`);
+    await queryRunner.query(`DROP INDEX IF EXISTS freight.idx_wagons_status`);
+    await queryRunner.query(`DROP INDEX IF EXISTS freight.idx_bookings_status`);
+  }
+}

apps/edr-freight-api/src/modules/bookings/bookings.repository.ts

@@ -12,6 +12,7 @@ import {
   SelectQueryBuilder,
 } from 'typeorm';
 
+import { computeFacets, FacetBucket } from '../../common/utils/facets.util';
 import { wagonsPerUnitForSize } from '../rule-engine/container-type.util';
 import { ContainerType } from '../rule-engine/entities/container-type.entity';
 import { Contract } from '../contracts/entities/contract.entity';
@@ -857,6 +858,29 @@ export class BookingsRepository extends BaseRepository<Booking> {
     };
   }
 
+  /**
+   * Facet counts for the filter bar's enum popovers: one `GROUP BY` per
+   * column, each with every OTHER active filter applied but its own
+   * predicate omitted (see `applyListFilters`'s `omit` param). `bookingType`
+   * is derived from `contract_kind` (see the comment in `applyListFilters`),
+   * not a plain column, so it facets on the same CASE expression the filter
+   * itself applies.
+   */
+  async getFacets(options: BookingListFilterOptions): Promise<Record<string, FacetBucket[]>> {
+    return computeFacets(
+      () => this.repository.createQueryBuilder('booking').where('booking.deleted_at IS NULL'),
+      (qb, omit) => this.applyListFilters(qb, options, omit as keyof BookingListFilterOptions),
+      {
+        status: 'booking.status',
+        freightType: 'booking.freight_type',
+        tradeDirection: 'booking.trade_direction',
+        paymentStatus: 'booking.payment_status',
+        bookingType:
+          "CASE WHEN booking.contract_kind = 'GENERAL' THEN 'GENERAL_CONTRACT' ELSE 'ONE_TIME' END",
+      },
+    );
+  }
+
   async getStatusCounts(): Promise<Record<string, number>> {
     const rows = await this.repository
       .createQueryBuilder('booking')
@@ -915,16 +939,24 @@ export class BookingsRepository extends BaseRepository<Booking> {
     return { inQueue, onThisPage, needsAction, urgent };
   }
 
+  /**
+   * @param omit  skip this one predicate — used by `getFacets` so a facet's
+   *   own filter doesn't hide its own sibling values. Every other caller
+   *   (list, summary metrics) passes nothing.
+   */
   private applyListFilters(
     qb: SelectQueryBuilder<Booking>,
     options: BookingListFilterOptions,
+    omit?: keyof BookingListFilterOptions | 'status',
   ): void {
-    if (options.statuses?.length) {
-      qb.andWhere('booking.status IN (:...statuses)', {
-        statuses: options.statuses,
-      });
-    } else if (options.status) {
-      qb.andWhere('booking.status = :status', { status: options.status });
+    if (omit !== 'status') {
+      if (options.statuses?.length) {
+        qb.andWhere('booking.status IN (:...statuses)', {
+          statuses: options.statuses,
+        });
+      } else if (options.status) {
+        qb.andWhere('booking.status = :status', { status: options.status });
+      }
     }
 
     if (options.companyId) {
@@ -957,12 +989,12 @@ export class BookingsRepository extends BaseRepository<Booking> {
         cargoTypeId: options.cargoTypeId,
       });
     }
-    if (options.freightType) {
+    if (omit !== 'freightType' && options.freightType) {
       qb.andWhere('booking.freight_type = :freightType', {
         freightType: options.freightType,
       });
     }
-    if (options.bookingType) {
+    if (omit !== 'bookingType' && options.bookingType) {
       // The stored booking_type column is 'ONE_TIME' for every row (contract
       // drawdowns included — see contract-booking.service create), so the
       // one-time vs general split keys on the denormalized contract_kind:
@@ -1011,12 +1043,12 @@ export class BookingsRepository extends BaseRepository<Booking> {
     } else if (options.isGovernment === 'false') {
       qb.andWhere('booking.is_government = FALSE');
     }
-    if (options.tradeDirection) {
+    if (omit !== 'tradeDirection' && options.tradeDirection) {
       qb.andWhere('booking.trade_direction = :tradeDirection', {
         tradeDirection: options.tradeDirection,
       });
     }
-    if (options.tradeDirections) {
+    if (omit !== 'tradeDirection' && options.tradeDirections) {
       applyDirectionScope(qb, 'booking.trade_direction', options.tradeDirections);
     }
     if (options.paymentCurrency) {
@@ -1024,7 +1056,7 @@ export class BookingsRepository extends BaseRepository<Booking> {
         paymentCurrency: options.paymentCurrency,
       });
     }
-    if (options.paymentStatus) {
+    if (omit !== 'paymentStatus' && options.paymentStatus) {
       qb.andWhere('booking.payment_status = :paymentStatus', {
         paymentStatus: options.paymentStatus,
       });

apps/edr-freight-api/src/modules/bookings/bookings.service.ts

@@ -2051,8 +2051,9 @@ export class BookingsService {
       consolidationPaired: filter.consolidationPaired,
     };
 
-    const [statusCounts, metrics] = await Promise.all([
+    const [statusCounts, facets, metrics] = await Promise.all([
       this.bookingsRepository.getStatusCounts(),
+      this.bookingsRepository.getFacets(listFilter),
       this.bookingsRepository.getListSummaryMetrics({
         ...listFilter,
         page,
@@ -2064,7 +2065,9 @@ export class BookingsService {
 
     return {
       metrics,
+      // Tabs stay unfiltered (whole-set) on purpose — see the DTO comment.
       tabs: mapStatusCountsToTabs(statusCounts),
+      facets,
     };
   }
 

apps/edr-freight-api/src/modules/bookings/dto/booking-list-summary.dto.ts

@@ -1,4 +1,5 @@
 import { ApiProperty } from '@nestjs/swagger';
+import { FacetBucket } from '../../../common/utils/facets.util';
 
 export class BookingListSummaryMetricsDto {
   @ApiProperty({ example: 42 })
@@ -31,4 +32,18 @@ export class BookingListSummaryDto {
 
   @ApiProperty({ type: BookingListSummaryTabsDto })
   tabs!: BookingListSummaryTabsDto;
+
+  /**
+   * Per-column value counts for the filter bar's enum popovers, scoped to
+   * every OTHER currently-active filter (own predicate omitted per column —
+   * see `BookingsRepository.getFacets`). Unlike `tabs`, which is
+   * deliberately unfiltered so tab counts stay stable while you filter
+   * within a tab, these move with the filter set.
+   */
+  @ApiProperty({
+    description: 'Facet counts keyed by filter field, for the pill filter bar',
+    type: 'object',
+    additionalProperties: { type: 'array', items: { type: 'object' } },
+  })
+  facets!: Record<string, FacetBucket[]>;
 }

apps/edr-freight-api/src/modules/contracts/contracts.repository.ts

@@ -3,6 +3,7 @@ import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { DataSource, In, IsNull, Repository, SelectQueryBuilder } from 'typeorm';
 
+import { computeFacets, FacetBucket } from '../../common/utils/facets.util';
 import { Booking } from '../bookings/entities/booking.entity';
 import { FileRecord } from '../files/entities/file.entity';
 import { applyDirectionScope } from '../user-trade-access/trade-scope.util';
@@ -47,6 +48,8 @@ export interface ContractListFilterOptions {
   hasClearanceDocuments?: boolean;
   createdFrom?: string;
   createdTo?: string;
+  originYardId?: string;
+  destinationYardId?: string;
 }
 
 @Injectable()
@@ -416,14 +419,22 @@ export class ContractsRepository extends BaseRepository<Contract> {
     return { inQueue, onThisPage, needsAction };
   }
 
+  /**
+   * @param omit  skip this one predicate — used by `getFacets` so a facet's
+   *   own filter doesn't hide its own sibling values (see class doc on
+   *   `getFacets`). Every other list/summary/count caller passes nothing.
+   */
   private applyListFilters(
     qb: SelectQueryBuilder<Contract>,
     options: ContractListFilterOptions,
+    omit?: keyof ContractListFilterOptions | 'status',
   ): void {
-    if (options.statuses?.length) {
-      qb.andWhere('contract.status IN (:...statuses)', { statuses: options.statuses });
-    } else if (options.status) {
-      qb.andWhere('contract.status = :status', { status: options.status });
+    if (omit !== 'status') {
+      if (options.statuses?.length) {
+        qb.andWhere('contract.status IN (:...statuses)', { statuses: options.statuses });
+      } else if (options.status) {
+        qb.andWhere('contract.status = :status', { status: options.status });
+      }
     }
     if (options.companyId) {
       qb.andWhere('contract.company_id = :companyId', { companyId: options.companyId });
@@ -433,7 +444,7 @@ export class ContractsRepository extends BaseRepository<Contract> {
         companyProfileId: options.companyProfileId,
       });
     }
-    if (options.contractKind) {
+    if (omit !== 'contractKind' && options.contractKind) {
       qb.andWhere('contract.contract_kind = :contractKind', {
         contractKind: options.contractKind,
       });
@@ -454,20 +465,20 @@ export class ContractsRepository extends BaseRepository<Contract> {
         serviceTypeId: options.serviceTypeId,
       });
     }
-    if (options.freightType) {
+    if (omit !== 'freightType' && options.freightType) {
       qb.andWhere('contract.freight_type = :freightType', {
         freightType: options.freightType,
       });
     }
-    if (options.tradeDirection) {
+    if (omit !== 'tradeDirection' && options.tradeDirection) {
       qb.andWhere('contract.trade_direction = :tradeDirection', {
         tradeDirection: options.tradeDirection,
       });
     }
-    if (options.tradeDirections) {
+    if (omit !== 'tradeDirection' && options.tradeDirections) {
       applyDirectionScope(qb, 'contract.trade_direction', options.tradeDirections);
     }
-    if (options.paymentCurrency) {
+    if (omit !== 'paymentCurrency' && options.paymentCurrency) {
       qb.andWhere('contract.payment_currency = :paymentCurrency', {
         paymentCurrency: options.paymentCurrency,
       });
@@ -480,6 +491,47 @@ export class ContractsRepository extends BaseRepository<Contract> {
     if (options.createdTo) {
       qb.andWhere('contract.created_at <= :createdTo', { createdTo: options.createdTo });
     }
+    // Routes are one-to-many (a contract can list several lanes), so origin
+    // and destination each need their own EXISTS — a plain join would
+    // duplicate the contract row per matching route.
+    if (omit !== 'originYardId' && options.originYardId) {
+      qb.andWhere(
+        'EXISTS (SELECT 1 FROM freight.contract_routes cr_o ' +
+          'WHERE cr_o.contract_id = contract.id AND cr_o.deleted_at IS NULL ' +
+          'AND cr_o.origin_yard_id = :originYardId)',
+        { originYardId: options.originYardId },
+      );
+    }
+    if (omit !== 'destinationYardId' && options.destinationYardId) {
+      qb.andWhere(
+        'EXISTS (SELECT 1 FROM freight.contract_routes cr_d ' +
+          'WHERE cr_d.contract_id = contract.id AND cr_d.deleted_at IS NULL ' +
+          'AND cr_d.destination_yard_id = :destinationYardId)',
+        { destinationYardId: options.destinationYardId },
+      );
+    }
+  }
+
+  /**
+   * Facet counts for the filter bar's enum popovers: one `GROUP BY` per
+   * column, each with every OTHER active filter applied but its own
+   * predicate omitted — so selecting `status=SUBMITTED` still shows
+   * `APPROVED: 8` in the status popover (to switch), while the freightType
+   * popover reflects only the SUBMITTED-scoped set. Supersedes
+   * `getStatusCounts`, which ignores the active filter entirely.
+   */
+  async getFacets(options: ContractListFilterOptions): Promise<Record<string, FacetBucket[]>> {
+    return computeFacets(
+      () => this.repository.createQueryBuilder('contract').where('contract.deleted_at IS NULL'),
+      (qb, omit) => this.applyListFilters(qb, options, omit as keyof ContractListFilterOptions),
+      {
+        status: 'contract.status',
+        contractKind: 'contract.contract_kind',
+        freightType: 'contract.freight_type',
+        tradeDirection: 'contract.trade_direction',
+        paymentCurrency: 'contract.payment_currency',
+      },
+    );
   }
 
   // ── Approval steps ─────────────────────────────────────────────────────────

apps/edr-freight-api/src/modules/contracts/contracts.service.ts

@@ -768,6 +768,8 @@ export class ContractsService {
       paymentCurrency: filter.paymentCurrency,
       createdFrom: filter.createdFrom,
       createdTo: filter.createdTo,
+      originYardId: filter.originYardId,
+      destinationYardId: filter.destinationYardId,
       search: filter.search,
       sortBy: filter.sortBy,
       sortOrder: filter.sortOrder,
@@ -789,10 +791,12 @@ export class ContractsService {
       paymentCurrency: filter.paymentCurrency,
       createdFrom: filter.createdFrom,
       createdTo: filter.createdTo,
+      originYardId: filter.originYardId,
+      destinationYardId: filter.destinationYardId,
     };
 
-    const [statusCounts, metrics] = await Promise.all([
-      this.contractsRepository.getStatusCounts(),
+    const [facets, metrics] = await Promise.all([
+      this.contractsRepository.getFacets(listFilter),
       this.contractsRepository.getListSummaryMetrics({
         ...listFilter,
         page,
@@ -801,7 +805,13 @@ export class ContractsService {
       }),
     ]);
 
-    return { metrics, statusCounts };
+    // statusCounts kept for existing callers; now filter-scoped like every
+    // other facet instead of the unfiltered global count `getStatusCounts` gave.
+    const statusCounts = Object.fromEntries(
+      (facets.status ?? []).map((b) => [b.value, b.count]),
+    );
+
+    return { metrics, statusCounts, facets };
   }
 
   /** Get a single contract by ID with relations and signed file URLs. */

apps/edr-freight-api/src/modules/contracts/dto/contract-list-summary.dto.ts

@@ -1,4 +1,5 @@
 import { ApiProperty } from '@nestjs/swagger';
+import { FacetBucket } from '../../../common/utils/facets.util';
 
 export class ContractListSummaryMetricsDto {
   @ApiProperty({ example: 42 })
@@ -15,6 +16,23 @@ export class ContractListSummaryDto {
   @ApiProperty({ type: ContractListSummaryMetricsDto })
   metrics!: ContractListSummaryMetricsDto;
 
+  /** @deprecated use `facets.status` — kept for existing callers, computed
+   * from the same filter-scoped query now instead of `getStatusCounts`'s
+   * unfiltered global count. */
   @ApiProperty({ description: 'Count per contract status', type: 'object', additionalProperties: { type: 'number' } })
   statusCounts!: Record<string, number>;
+
+  /**
+   * Per-column value counts for the filter bar's enum popovers, scoped to
+   * every OTHER currently-active filter (each column's own predicate is
+   * omitted from its own count — see `ContractsRepository.getFacets`).
+   * Absent/omitted keys mean the frontend falls back to its static option
+   * list with no counts, never an error.
+   */
+  @ApiProperty({
+    description: 'Facet counts keyed by filter field, for the pill filter bar',
+    type: 'object',
+    additionalProperties: { type: 'array', items: { type: 'object' } },
+  })
+  facets!: Record<string, FacetBucket[]>;
 }

apps/edr-freight-api/src/modules/contracts/dto/filter-contract.dto.ts

@@ -61,6 +61,22 @@ export class FilterContractDto {
   @IsIn([...PAYMENT_CURRENCIES])
   paymentCurrency?: string;
 
+  @ApiPropertyOptional({
+    format: 'uuid',
+    description: 'Only contracts with a route starting at this yard.',
+  })
+  @IsOptional()
+  @IsUUID()
+  originYardId?: string;
+
+  @ApiPropertyOptional({
+    format: 'uuid',
+    description: 'Only contracts with a route ending at this yard.',
+  })
+  @IsOptional()
+  @IsUUID()
+  destinationYardId?: string;
+
   @ApiPropertyOptional({ description: 'Filter contracts created on/after this date (ISO)' })
   @IsOptional()
   @IsDateString()

apps/edr-freight-api/src/modules/drivers/drivers.repository.ts

@@ -29,52 +29,6 @@ export class DriversRepository extends BaseRepository<Driver> {
     return this.repository.findOne({ where: { id } });
   }
 
-  async findAllWithFilters(query: {
-    page?: number;
-    pageSize?: number;
-    search?: string;
-    status?: string;
-    sortBy?: string;
-    sortOrder?: 'ASC' | 'DESC';
-  }) {
-    const page = query.page || 1;
-    const pageSize = query.pageSize || 10;
-    const skip = (page - 1) * pageSize;
-
-    let queryBuilder = this.repository.createQueryBuilder('driver');
-
-    if (query.search) {
-      queryBuilder = queryBuilder.where(
-        '(driver.firstName ILIKE :search OR driver.lastName ILIKE :search OR driver.email ILIKE :search OR driver.phoneNumber ILIKE :search OR driver.licenseNumber ILIKE :search)',
-        { search: `%${query.search}%` },
-      );
-    }
-
-    if (query.status) {
-      queryBuilder = queryBuilder.andWhere('driver.status = :status', {
-        status: query.status,
-      });
-    }
-
-    const sortBy = query.sortBy || 'createdAt';
-    const sortOrder = query.sortOrder || 'DESC';
-
-    queryBuilder = queryBuilder
-      .orderBy(`driver.${sortBy}`, sortOrder)
-      .skip(skip)
-      .take(pageSize);
-
-    const [data, total] = await queryBuilder.getManyAndCount();
-
-    return {
-      data,
-      total,
-      page,
-      pageSize,
-      totalPages: Math.ceil(total / pageSize),
-    };
-  }
-
   async createDriver(driverData: any): Promise<Driver> {
     const driver = this.repository.create(driverData);
     const result = await this.repository.save(driver);

apps/edr-freight-api/src/modules/otp/otp.service.ts

@@ -8,6 +8,7 @@ import { OtpRepository } from "./otp.repository";
 
 import { NotificationsService } from "../notifications/notifications.service";
 import { EmailClientService } from "../notifications/email-client.service";
+import { isBypassEnv, DEV_BYPASS_OTP } from "../../common/dev-bypass.util";
 
 /**
  * Where a code goes. At least one of phone/email must be set — enforced by the
@@ -146,6 +147,21 @@ export class OtpService {
         `otp.issue channels=${channels.join("+")} target=${label} action=${rotated ? "rotate" : "create"}`,
       );
 
+      // Dev/staging only: the row above still exists (so a real code would
+      // still verify), but skip the real SMS/email send — no carrier cost, no
+      // dependency on RabbitMQ/the mail relay being up. Verify with the fixed
+      // DEV_BYPASS_OTP code instead of whatever landed in the row.
+      if (isBypassEnv()) {
+        this.logger.warn(
+          `otp.dispatch.bypassed target=${label} — dev/staging, no real SMS/email sent (verify with ${DEV_BYPASS_OTP})`,
+        );
+        return {
+          success: true,
+          delivered: true,
+          message: "OTP sent successfully",
+        };
+      }
+
       // NOTE: do NOT reset the brute-force attempt counter on send. Clearing it
       // here let an attacker wipe the per-target guess budget just by calling
       // /otp/send between guesses. The counter is cleared only when the code is
@@ -394,7 +410,10 @@ export class OtpService {
 
     // invalid otp — per-target attempt cap so a 6-digit code can't be
     // brute-forced within its TTL; the code is burned once the budget is spent.
-    if (otpData.otp !== otp) {
+    // Dev/staging only: a fixed code verifies any pending OTP row without
+    // knowing the real one — the row still has to exist (sendOtp still runs).
+    const bypassed = isBypassEnv() && otp === DEV_BYPASS_OTP;
+    if (otpData.otp !== otp && !bypassed) {
       const attempts = (this.actionAttempts.get(key) ?? 0) + 1;
       if (attempts >= this.MAX_ACTION_ATTEMPTS) {
         await this.otpRepository.deleteOtp(otpData);
@@ -482,7 +501,10 @@ export class OtpService {
       );
     }
 
-    if (otpData.otp !== otp) {
+    // Dev/staging only: a fixed code verifies any pending OTP row without
+    // knowing the real one — the row still has to exist (sendOtp still runs).
+    const bypassed = isBypassEnv() && otp === DEV_BYPASS_OTP;
+    if (otpData.otp !== otp && !bypassed) {
       const attempts = (this.actionAttempts.get(key) ?? 0) + 1;
 
       if (attempts >= this.MAX_ACTION_ATTEMPTS) {

apps/edr-freight-api/src/modules/payment/payment.service.ts

@@ -31,6 +31,7 @@ import {
   IntentStatusDto,
   PaymentPlatformDto,
 } from "./payments.dto";
+import { isBypassEnv } from "../../common/dev-bypass.util";
 
 /** Everything the gateway needs to open an intent. Amount/currency are supplied by
  *  the caller (billing) — this service never derives them from a domain record. */
@@ -256,34 +257,52 @@ export class PaymentService {
         );
       }
 
-      const snapshot = await this.paymentClient.initiate({
-        service: PaymentServiceEnum.FREIGHT,
-        referenceType: PaymentReferenceType.SHIPMENT,
-        referenceId: input.referenceId,
-        orderRef: input.orderRef,
-        // CBE_BILL must carry the REAL amount: /cbe/payment verifies what the customer was
-        // debited against the intent amount, so the dev shortcut would break it.
-        // CAC bank rejects amounts below 10 (DJF bounds 10–100,000), so its dev
-        // shortcut floor is 10, not 1.
-        // amountMinor: isCbeBill
-        //   ? input.amountMinor
-        //   : input.method === ProviderMethod.CAC_BANK
-        //     ? 10
-        //     : 1,
-        amountMinor: input.amountMinor,
-        currency: input.currency,
-        provider: input.method as ProviderMethod,
-        platform: input.platform,
-        payerAccount: input.payerAccount,
-        payerName: input.payerName,
-        expiresAt: input.expiresAt,
-        // bookingId lets the success page ack the redirect (→ PAYMENT_PROCESSING).
-        returnUrl:
-          input.returnUrl ??
-          `https://edrfreight.triaplc.com/payment/success?bookingId=${encodeURIComponent(input.referenceId)}`,
-        failureUrl:
-          input.failureUrl ?? "https://edrfreight.triaplc.com/payment/failure",
-      });
+      // Dev/staging only: skip the real gateway call entirely and report an
+      // immediate SUCCEEDED snapshot — everything below (upsert, settle,
+      // billing notify) runs exactly as it would for a real synchronous
+      // provider success.
+      const snapshot: PaymentIntentSnapshot = isBypassEnv()
+        ? {
+            intentId: `bypass-${input.referenceId}`,
+            service: PaymentServiceEnum.FREIGHT,
+            referenceType: PaymentReferenceType.SHIPMENT,
+            referenceId: input.referenceId,
+            merchantOrderId: input.orderRef,
+            provider: input.method as ProviderMethod,
+            status: ProviderPaymentStatus.SUCCEEDED,
+            amountMinor: input.amountMinor,
+            currency: input.currency,
+            providerTxnId: `bypass-${input.referenceId}`,
+            paidAt: new Date().toISOString(),
+          }
+        : await this.paymentClient.initiate({
+            service: PaymentServiceEnum.FREIGHT,
+            referenceType: PaymentReferenceType.SHIPMENT,
+            referenceId: input.referenceId,
+            orderRef: input.orderRef,
+            // CBE_BILL must carry the REAL amount: /cbe/payment verifies what the customer was
+            // debited against the intent amount, so the dev shortcut would break it.
+            // CAC bank rejects amounts below 10 (DJF bounds 10–100,000), so its dev
+            // shortcut floor is 10, not 1.
+            // amountMinor: isCbeBill
+            //   ? input.amountMinor
+            //   : input.method === ProviderMethod.CAC_BANK
+            //     ? 10
+            //     : 1,
+            amountMinor: input.amountMinor,
+            currency: input.currency,
+            provider: input.method as ProviderMethod,
+            platform: input.platform,
+            payerAccount: input.payerAccount,
+            payerName: input.payerName,
+            expiresAt: input.expiresAt,
+            // bookingId lets the success page ack the redirect (→ PAYMENT_PROCESSING).
+            returnUrl:
+              input.returnUrl ??
+              `https://edrfreight.triaplc.com/payment/success?bookingId=${encodeURIComponent(input.referenceId)}`,
+            failureUrl:
+              input.failureUrl ?? "https://edrfreight.triaplc.com/payment/failure",
+          });
 
       const immediateSuccess =
         snapshot.status === ProviderPaymentStatus.SUCCEEDED;

apps/edr-freight-api/src/modules/vehicles/vehicles.repository.ts

@@ -21,52 +21,6 @@ export class VehiclesRepository extends BaseRepository<Vehicle> {
     return this.repository.findOne({ where: { id } });
   }
 
-  async findAllWithFilters(query: {
-    page?: number;
-    pageSize?: number;
-    search?: string;
-    status?: string;
-    sortBy?: string;
-    sortOrder?: 'ASC' | 'DESC';
-  }) {
-    const page = query.page || 1;
-    const pageSize = query.pageSize || 10;
-    const skip = (page - 1) * pageSize;
-
-    let queryBuilder = this.repository.createQueryBuilder('vehicle');
-
-    if (query.search) {
-      queryBuilder = queryBuilder.where(
-        '(vehicle.plateNumber ILIKE :search OR vehicle.manufacturer ILIKE :search OR vehicle.model ILIKE :search)',
-        { search: `%${query.search}%` },
-      );
-    }
-
-    if (query.status) {
-      queryBuilder = queryBuilder.andWhere('vehicle.status = :status', {
-        status: query.status,
-      });
-    }
-
-    const sortBy = query.sortBy || 'createdAt';
-    const sortOrder = query.sortOrder || 'DESC';
-
-    queryBuilder = queryBuilder
-      .orderBy(`vehicle.${sortBy}`, sortOrder)
-      .skip(skip)
-      .take(pageSize);
-
-    const [data, total] = await queryBuilder.getManyAndCount();
-
-    return {
-      data,
-      total,
-      page,
-      pageSize,
-      totalPages: Math.ceil(total / pageSize),
-    };
-  }
-
   async createVehicle(vehicleData: Partial<Vehicle>): Promise<Vehicle> {
     const vehicle = this.repository.create(vehicleData);
     return this.repository.save(vehicle);

apps/edr-freight-api/src/modules/verifayda/verifayda.service.ts

@@ -28,6 +28,11 @@ import {
   NormalizedFaydaUserInfo,
   VerifaydaPurpose,
 } from './verifayda.types';
+import { randomUUID } from 'node:crypto';
+import { isBypassEnv } from '../../common/dev-bypass.util';
+
+/** Sentinel `code` that skips the real eSignet exchange in dev/staging. */
+export const DEV_BYPASS_FAYDA_CODE = 'DEV_BYPASS';
 
 export interface StartVerificationInput {
   purpose: VerifaydaPurpose;
@@ -143,6 +148,26 @@ export class VerifaydaService {
   async completeVerification(
     query: VerifaydaCallbackDto,
   ): Promise<CompleteVerificationResult> {
+    // Dev/staging only: caller sends the sentinel code instead of a real
+    // eSignet redirect — skip the token exchange/session entirely and hand
+    // back a canned VERIFY result. `sub` is unique per call so binding both
+    // owner and PoA in the same bypass session doesn't collide.
+    if (isBypassEnv() && query.code === DEV_BYPASS_FAYDA_CODE) {
+      this.logger.warn('Fayda verification BYPASSED (dev/staging)');
+      return {
+        purpose: 'VERIFY',
+        verified: true,
+        sub: `dev-bypass-${randomUUID()}`,
+        fullName: 'Dev Bypass User',
+        email: 'dev-bypass@example.com',
+        phoneNumber: '+251900000000',
+        birthdate: '1990-01-01',
+        gender: 'M',
+        address: 'Dev Bypass Address',
+        userDataSaved: false,
+      };
+    }
+
     if (query.error) {
       this.logger.warn(`Fayda callback returned error: ${query.error}`);
       if (query.state) {

apps/edr-freight-web/backoffice/src/components/filters/FilterBar.tsx

@@ -0,0 +1,160 @@
+import { useState, type ReactNode } from "react";
+import { Anchor, Divider, Group, TextInput } from "@mantine/core";
+import { Search, Trash2 } from "lucide-react";
+
+import type { FilterDef, SortOption } from "./types";
+import type { UseFilters } from "./useFilters";
+import { FilterPill } from "./FilterPill";
+import { MoreFiltersMenu } from "./MoreFiltersMenu";
+import { SaveViewButton } from "./SaveViewButton";
+import { SavedViewCards } from "./SavedViewCards";
+import { SortControl } from "./SortControl";
+import { useSavedViews } from "./useSavedViews";
+
+export interface FilterBarProps {
+  defs: FilterDef[];
+  controls: UseFilters;
+  searchPlaceholder?: string;
+  showSearch?: boolean;
+  /** value already "field:DIR" — the page's existing SORT_OPTIONS, moved not rewritten. */
+  sortOptions?: SortOption[];
+  /** localStorage namespace for saved views. Omit to hide the control. */
+  viewId?: string;
+  /** Escape hatch: tabs, row count, a "New" button — rendered at the far right. */
+  children?: ReactNode;
+}
+
+export function FilterBar({
+  defs,
+  controls,
+  searchPlaceholder = "Search…",
+  showSearch = true,
+  sortOptions,
+  viewId,
+  children,
+}: FilterBarProps) {
+  // Filters just picked from "More filters" render as an already-open pill
+  // until the popover closes, then fall back to the ordinary pinned/active split.
+  const [justPicked, setJustPicked] = useState<string[]>([]);
+
+  const pinned = defs.filter((d) => !d.secondary || controls.values[d.key] || justPicked.includes(d.key));
+  const secondary = defs.filter((d) => !pinned.includes(d));
+  // Applied filters read first, left to right — a stable partition keeps
+  // each group in its original def order rather than resorting on every apply.
+  const orderedPinned = [
+    ...pinned.filter((d) => controls.values[d.key]),
+    ...pinned.filter((d) => !controls.values[d.key]),
+  ];
+
+  // Unconditional call (rules of hooks) — viewId is a per-page constant, and
+  // the hook is a no-op storage key when saved views aren't wired up.
+  const savedViews = useSavedViews(viewId ?? "__unset__");
+  const activeQuery = controls.currentQueryString();
+  const hasMatchingView = savedViews.views.some((v) => v.query === activeQuery);
+  const canSaveView = Boolean(viewId) && activeQuery.length > 0 && !hasMatchingView;
+
+  return (
+    <div>
+      {viewId && (
+        <SavedViewCards
+          defs={defs}
+          views={savedViews.views}
+          activeQuery={activeQuery}
+          applyQueryString={controls.applyQueryString}
+          onRemove={savedViews.remove}
+        />
+      )}
+
+      {/*
+        Two independent zones on wide screens — left (search + pills + more
+        filters + clear) wraps to as many lines as it needs, right (sort +
+        save) stays pinned on the first line via `sm:flex-nowrap` +
+        `sm:shrink-0`. `nowrap` unconditionally (the old inline style) forced
+        that same two-column layout on a phone too: neither zone had room and
+        both got squeezed/clipped. Below the `sm` breakpoint this stacks to a
+        single column instead — full-width left row, full-width right row.
+      */}
+      <div className="flex flex-col sm:flex-row sm:flex-nowrap items-start gap-2">
+      <Group gap="xs" wrap="wrap" align="center" className="flex-1 min-w-0 w-full">
+        {showSearch && (
+          <TextInput
+            placeholder={searchPlaceholder}
+            leftSection={<Search size={14} />}
+            value={controls.searchText}
+            onChange={(e) => controls.setSearchText(e.currentTarget.value)}
+            size="xs"
+            radius="lg"
+            // Regular weight (not the Button-driven 600 the rest of the bar
+            // uses) and a solid, fully-opaque border/text — same "opaque, not
+            // faint" fix the inactive pill trigger got.
+            styles={{
+              input: {
+                fontWeight: 400,
+                borderColor: "var(--mantine-color-gray-6)",
+                color: "var(--mantine-color-gray-9)",
+              },
+            }}
+            style={{ minWidth: 160, flex: "1 1 160px" }}
+          />
+        )}
+
+        {orderedPinned.map((def) => (
+          <FilterPill
+            key={def.key}
+            def={def}
+            value={controls.values[def.key]}
+            onChange={(v) => controls.setFilter(def.key, v)}
+            autoOpen={justPicked.includes(def.key)}
+          />
+        ))}
+
+        <MoreFiltersMenu
+          defs={secondary}
+          onPick={(key) => setJustPicked((prev) => [...prev, key])}
+        />
+
+        {controls.activeCount > 0 && (
+          <Anchor
+            size="sm"
+            c="red.6"
+            underline="never"
+            onClick={() => {
+              controls.clearFilters();
+              setJustPicked([]);
+            }}
+            style={{ display: "inline-flex", alignItems: "center", gap: 4 }}
+          >
+            <Trash2 size={14} />
+            Clear
+          </Anchor>
+        )}
+      </Group>
+
+      {/* Sorting is a different kind of control (view order, not scope) —
+          cut off from the filter pills by a vertical divider and pinned to
+          the right, independent of how the left side wraps. */}
+      {/*
+        Plain div, not <Group>: Group's `wrap` prop sets an inline
+        flex-wrap style, which always beats a Tailwind class regardless of
+        breakpoint — `sm:flex-nowrap` would never win against `wrap="wrap"`.
+        Wrap on mobile (own row, room is tight), pinned nowrap from `sm` up.
+      */}
+      <div className="flex flex-wrap sm:flex-nowrap items-center gap-2 shrink-0">
+        {children}
+        {sortOptions && sortOptions.length > 0 && (
+          <>
+            <Divider orientation="vertical" />
+            <SortControl options={sortOptions} value={controls.sort} onChange={controls.setSort} />
+          </>
+        )}
+        {canSaveView && (
+          <>
+            <Divider orientation="vertical" />
+            <SaveViewButton defs={defs} query={activeQuery} onSave={savedViews.save} />
+          </>
+        )}
+      </div>
+      </div>
+    </div>
+  );
+}

apps/edr-freight-web/backoffice/src/components/filters/FilterPill.tsx

@@ -0,0 +1,89 @@
+import { useState } from "react";
+import { ActionIcon, Button, Popover } from "@mantine/core";
+import { ChevronDown, X } from "lucide-react";
+
+import type { FilterDef, FilterValue } from "./types";
+import { formatFilterValue } from "./format";
+import { BooleanBody } from "./bodies/BooleanBody";
+import { DateBody } from "./bodies/DateBody";
+import { EnumBody } from "./bodies/EnumBody";
+import { NumberBody } from "./bodies/NumberBody";
+import { RouteBody } from "./bodies/RouteBody";
+import { TextBody } from "./bodies/TextBody";
+
+const BODIES: Record<FilterDef["type"], React.ComponentType<any>> = {
+  text: TextBody,
+  enum: EnumBody,
+  date: DateBody,
+  number: NumberBody,
+  boolean: BooleanBody,
+  route: RouteBody,
+};
+
+// Most bodies fit a narrow popover; a date range needs room for the presets
+// sidebar next to the calendar, so it gets a wider minimum.
+const DROPDOWN_WIDTH: Partial<Record<FilterDef["type"], number>> = { date: 340 };
+
+export interface FilterPillProps {
+  def: FilterDef;
+  value: FilterValue | undefined;
+  onChange: (v: FilterValue | undefined) => void;
+  /** Opened immediately (used when picked from "More filters"). */
+  autoOpen?: boolean;
+}
+
+export function FilterPill({ def, value, onChange, autoOpen }: FilterPillProps) {
+  const [opened, setOpened] = useState(Boolean(autoOpen));
+  const Body = BODIES[def.type];
+  const active = Boolean(value);
+
+  return (
+    <Popover position="bottom-start" withinPortal shadow="md" opened={opened} onChange={setOpened}>
+      <Popover.Target>
+        <Button
+          size="xs"
+          radius="xl"
+          // Inactive: styled like a closed Mantine Select trigger — solid
+          // (opaque, not dashed) border, label + trailing chevron, no leading
+          // "+" — just a smaller/pill-shaped version of that same control.
+          // Active: "light" (soft tinted fill), not "filled" — a whole row of
+          // solid green buttons was the "too loud" complaint; light keeps the
+          // active/inactive contrast without shouting. Popover side/position
+          // is untouched either way.
+          variant={active ? "light" : "default"}
+          color={active ? "edr-green" : undefined}
+          styles={
+            active
+              ? undefined
+              : { root: { borderColor: "var(--mantine-color-gray-6)", color: "var(--mantine-color-gray-9)" } }
+          }
+          rightSection={
+            active ? (
+              <ActionIcon
+                component="span"
+                size={22}
+                radius="xl"
+                variant="subtle"
+                color="edr-green"
+                onClick={(e) => {
+                  e.stopPropagation();
+                  onChange(undefined);
+                }}
+              >
+                <X size={16} />
+              </ActionIcon>
+            ) : (
+              <ChevronDown size={14} />
+            )
+          }
+          onClick={() => setOpened((o) => !o)}
+        >
+          {active ? `${def.label} | ${formatFilterValue(def, value!)}` : def.label}
+        </Button>
+      </Popover.Target>
+      <Popover.Dropdown miw={DROPDOWN_WIDTH[def.type] ?? 260} p="xs">
+        <Body def={def} value={value} onChange={onChange} onClose={() => setOpened(false)} />
+      </Popover.Dropdown>
+    </Popover>
+  );
+}

apps/edr-freight-web/backoffice/src/components/filters/MoreFiltersMenu.tsx

@@ -0,0 +1,83 @@
+import { useMemo, useState } from "react";
+import { Button, Popover, ScrollArea, Stack, Text, TextInput, UnstyledButton } from "@mantine/core";
+import { Plus, Search } from "lucide-react";
+
+import type { FilterDef } from "./types";
+
+export interface MoreFiltersMenuProps {
+  defs: FilterDef[];
+  /** Called with the picked def's key — the caller pins it and opens its popover. */
+  onPick: (key: string) => void;
+}
+
+/** Searchable list over the page's secondary/inactive filters. Plain filter + list,
+ * not cmdk — a handful of static strings doesn't need a Combobox store. */
+export function MoreFiltersMenu({ defs, onPick }: MoreFiltersMenuProps) {
+  const [opened, setOpened] = useState(false);
+  const [query, setQuery] = useState("");
+
+  const visible = useMemo(
+    () => defs.filter((d) => d.label.toLowerCase().includes(query.toLowerCase())),
+    [defs, query],
+  );
+
+  if (defs.length === 0) return null;
+
+  return (
+    <Popover position="bottom-start" withinPortal shadow="md" opened={opened} onChange={setOpened}>
+      <Popover.Target>
+        <Button
+          size="xs"
+          radius="xl"
+          // "default" (opaque border + solid text), not "outline" (faint
+          // color-tinted border/text) — same fix as the inactive filter pill.
+          variant="default"
+          leftSection={<Plus size={16} />}
+          onClick={() => setOpened((o) => !o)}
+        >
+          More filters
+        </Button>
+      </Popover.Target>
+      <Popover.Dropdown miw={220} p="xs">
+        <Stack gap="xs">
+          <TextInput
+            placeholder="Search filters…"
+            leftSection={<Search size={14} />}
+            value={query}
+            onChange={(e) => setQuery(e.currentTarget.value)}
+            size="sm"
+            autoFocus
+          />
+          <ScrollArea.Autosize mah={280}>
+            <Stack gap={2}>
+              {visible.map((d) => (
+                <UnstyledButton
+                  key={d.key}
+                  px="xs"
+                  py={6}
+                  className="hover:bg-gray-100 transition-colors"
+                  style={{ borderRadius: 6, display: "flex", alignItems: "center", gap: 8 }}
+                  onClick={() => {
+                    setOpened(false);
+                    setQuery("");
+                    onPick(d.key);
+                  }}
+                >
+                  <Plus size={14} className="text-[var(--mantine-color-edr-green-6)]" />
+                  <Text size="sm" c="edr-green.7">
+                    {d.label}
+                  </Text>
+                </UnstyledButton>
+              ))}
+              {visible.length === 0 && (
+                <Text size="xs" c="dimmed" px="xs" py={6}>
+                  No matching filters
+                </Text>
+              )}
+            </Stack>
+          </ScrollArea.Autosize>
+        </Stack>
+      </Popover.Dropdown>
+    </Popover>
+  );
+}

apps/edr-freight-web/backoffice/src/components/filters/OperatorSelect.tsx

@@ -0,0 +1,25 @@
+import { SegmentedControl } from "@mantine/core";
+import { DEFAULT_OP, OPERATOR_LABELS, type FilterDef, type Operator } from "./types";
+
+export interface OperatorSelectProps {
+  def: FilterDef;
+  value: Operator;
+  onChange: (op: Operator) => void;
+}
+
+/** Renders nothing when a def has <= 1 operator — most defs, by design: type-aware
+ * operators are a capability, not a dropdown forced into every popover. */
+export function OperatorSelect({ def, value, onChange }: OperatorSelectProps) {
+  const operators = def.operators ?? [DEFAULT_OP[def.type]];
+  if (operators.length <= 1) return null;
+  return (
+    <SegmentedControl
+      size="sm"
+      fullWidth
+      value={value}
+      onChange={(v) => onChange(v as Operator)}
+      data={operators.map((op) => ({ value: op, label: OPERATOR_LABELS[op] }))}
+      mb="xs"
+    />
+  );
+}

apps/edr-freight-web/backoffice/src/components/filters/SaveViewButton.tsx

@@ -0,0 +1,46 @@
+import { useState } from "react";
+import { Button } from "@mantine/core";
+import { Check, Save } from "lucide-react";
+
+import { useToast } from "@/hooks/use-toast";
+import type { FilterDef } from "./types";
+import { describeQuery } from "./format";
+import type { SavedView } from "./useSavedViews";
+
+export interface SaveViewButtonProps {
+  defs: FilterDef[];
+  query: string;
+  onSave: (query: string) => SavedView;
+}
+
+/** Filled, not outline — this is the one action-y button in the bar (every
+ * other control here is a filter), so it needs to actually look like a
+ * button. One click, no name prompt: the card grid's label is generated
+ * from the active filters (see `describeQuery`). */
+export function SaveViewButton({ defs, query, onSave }: SaveViewButtonProps) {
+  const { toast } = useToast();
+  const [justSaved, setJustSaved] = useState(false);
+
+  const handleSave = () => {
+    onSave(query);
+    toast({ title: "View saved", description: describeQuery(defs, query), duration: 4000 });
+    // The toast is in the corner; this flash is right where the eye already
+    // is — the actual confirmation that "the saving" registered.
+    setJustSaved(true);
+    setTimeout(() => setJustSaved(false), 1500);
+  };
+
+  return (
+    <Button
+      size="sm"
+      radius="xl"
+      variant="filled"
+      color={justSaved ? "teal" : "edr-green"}
+      leftSection={justSaved ? <Check size={15} /> : <Save size={15} />}
+      onClick={handleSave}
+      disabled={justSaved}
+    >
+      {justSaved ? "Saved" : "Save"}
+    </Button>
+  );
+}

apps/edr-freight-web/backoffice/src/components/filters/SavedViewCards.tsx

@@ -0,0 +1,70 @@
+import { ActionIcon, Card, SimpleGrid, Text } from "@mantine/core";
+import { Trash2 } from "lucide-react";
+
+import { useToast } from "@/hooks/use-toast";
+import type { FilterDef } from "./types";
+import { describeQuery } from "./format";
+import type { SavedView } from "./useSavedViews";
+
+export interface SavedViewCardsProps {
+  defs: FilterDef[];
+  views: SavedView[];
+  activeQuery: string;
+  applyQueryString: (query: string) => void;
+  onRemove: (id: string) => void;
+}
+
+/** Saved views up front as a grid of cards — not one more item buried in a
+ * dropdown nobody opens. Renders nothing until there's at least one saved. */
+export function SavedViewCards({ defs, views, activeQuery, applyQueryString, onRemove }: SavedViewCardsProps) {
+  const { toast } = useToast();
+  if (views.length === 0) return null;
+
+  return (
+    // base: 1 — a phone-width viewport forcing 2 columns is what clipped
+    // card text and overflowed the row; one full-width card per row until
+    // there's actually room for more.
+    <SimpleGrid cols={{ base: 1, xs: 2, sm: 3, md: 4, lg: 5 }} spacing="xs" mb="sm">
+      {views.map((v) => {
+        const active = v.query === activeQuery;
+        const label = describeQuery(defs, v.query);
+        return (
+          <Card
+            key={v.id}
+            withBorder
+            padding="xs"
+            radius="md"
+            onClick={() => {
+              applyQueryString(v.query);
+              toast({ title: `Switched to "${label}"` });
+            }}
+            style={{
+              cursor: "pointer",
+              borderColor: active ? "var(--mantine-color-edr-green-6)" : undefined,
+              borderWidth: active ? 2 : 1,
+              backgroundColor: active ? "var(--mantine-color-edr-green-0)" : undefined,
+            }}
+          >
+            <div style={{ display: "flex", alignItems: "flex-start", justifyContent: "space-between", gap: 6 }}>
+              <Text size="xs" fw={500} lineClamp={2} style={{ flex: 1 }}>
+                {label}
+              </Text>
+              <ActionIcon
+                size="xs"
+                color="red"
+                variant="subtle"
+                onClick={(e) => {
+                  e.stopPropagation();
+                  onRemove(v.id);
+                  toast({ title: "View deleted", description: label, variant: "destructive" });
+                }}
+              >
+                <Trash2 size={12} />
+              </ActionIcon>
+            </div>
+          </Card>
+        );
+      })}
+    </SimpleGrid>
+  );
+}

apps/edr-freight-web/backoffice/src/components/filters/SortControl.tsx

@@ -0,0 +1,40 @@
+import { Button, Menu } from "@mantine/core";
+import { ArrowUpDown, Check } from "lucide-react";
+
+import type { SortOption } from "./types";
+
+export interface SortControlProps {
+  options: SortOption[];
+  value: string;
+  onChange: (value: string) => void;
+}
+
+/** A control, not a form field — Menu (not Select) gives the check-mark +
+ * trigger-label read Stripe's sort control has. Rendered only when a page
+ * passes sortOptions; inventing options for an endpoint without sortBy
+ * support would ship a control that silently does nothing. */
+export function SortControl({ options, value, onChange }: SortControlProps) {
+  if (options.length === 0) return null;
+  const current = options.find((o) => o.value === value);
+
+  return (
+    <Menu position="bottom-end" withinPortal shadow="md">
+      <Menu.Target>
+        <Button size="xs" variant="outline" color="gray" leftSection={<ArrowUpDown size={14} />}>
+          {current?.label ?? "Sort"}
+        </Button>
+      </Menu.Target>
+      <Menu.Dropdown>
+        {options.map((o) => (
+          <Menu.Item
+            key={o.value}
+            leftSection={o.value === value ? <Check size={14} /> : <span style={{ width: 14 }} />}
+            onClick={() => onChange(o.value)}
+          >
+            {o.label}
+          </Menu.Item>
+        ))}
+      </Menu.Dropdown>
+    </Menu>
+  );
+}

apps/edr-freight-web/backoffice/src/components/filters/bodies/BooleanBody.tsx

@@ -0,0 +1,32 @@
+import { useState } from "react";
+import { Radio, Stack } from "@mantine/core";
+
+import { DEFAULT_OP } from "../types";
+import type { BooleanFilterDef, Operator } from "../types";
+import { OperatorSelect } from "../OperatorSelect";
+import type { FilterBodyProps } from "./TextBody";
+
+export function BooleanBody({ def, value, onChange, onClose }: FilterBodyProps<BooleanFilterDef>) {
+  const [op, setOp] = useState<Operator>(value?.op ?? DEFAULT_OP.boolean);
+  const [v, setV] = useState(value?.v[0] ?? "");
+
+  // Two mutually-exclusive options — apply the moment one is picked, same as
+  // EnumBody's single-select radio. No Apply button needed.
+  const pick = (next: string) => {
+    setV(next);
+    onChange({ op, v: [next] });
+    onClose();
+  };
+
+  return (
+    <Stack gap="xs">
+      <OperatorSelect def={def} value={op} onChange={setOp} />
+      <Radio.Group value={v} onChange={pick}>
+        <Stack gap={6}>
+          <Radio value="true" label={def.trueLabel ?? "Yes"} size="sm" />
+          <Radio value="false" label={def.falseLabel ?? "No"} size="sm" />
+        </Stack>
+      </Radio.Group>
+    </Stack>
+  );
+}

apps/edr-freight-web/backoffice/src/components/filters/bodies/DateBody.tsx

@@ -0,0 +1,92 @@
+import { useState } from "react";
+import { Button, Stack } from "@mantine/core";
+import { DatePickerInput } from "@mantine/dates";
+import { CalendarDays } from "lucide-react";
+
+import { getDateRangePresets } from "@/components/common/dateRangePresets";
+import { startOfDayIso, endOfDayIso, parseDateStr } from "../dates";
+import { DEFAULT_OP } from "../types";
+import type { DateFilterDef, Operator } from "../types";
+import { OperatorSelect } from "../OperatorSelect";
+import type { FilterBodyProps } from "./TextBody";
+
+// ponytail: Gregorian only. Record-management pages need the Ethiopian
+// calendar (see shared/common/form/fields/AmharicDatePicker.tsx) — add an
+// i18n.language !== "en" branch here when this body is first wired into a
+// record-management page (Phase 4 of the filter-bar rollout).
+export function DateBody({ def, value, onChange, onClose }: FilterBodyProps<DateFilterDef>) {
+  const [op, setOp] = useState<Operator>(value?.op ?? DEFAULT_OP.date);
+  // Mantine 9's date inputs speak `YYYY-MM-DD` strings, not Date objects.
+  const [from, setFrom] = useState<string | null>(value?.v[0]?.slice(0, 10) ?? null);
+  const [to, setTo] = useState<string | null>(value?.v[1]?.slice(0, 10) ?? null);
+
+  const apply = () => {
+    if (op === "between") {
+      onChange(
+        from && to
+          ? { op, v: [startOfDayIso(parseDateStr(from)), endOfDayIso(parseDateStr(to))] }
+          : undefined,
+      );
+    } else {
+      onChange(
+        from
+          ? {
+              op,
+              v: [
+                op === "before"
+                  ? startOfDayIso(parseDateStr(from))
+                  : endOfDayIso(parseDateStr(from)),
+              ],
+            }
+          : undefined,
+      );
+    }
+    onClose();
+  };
+
+  // This popover already lives inside FilterPill's own Popover. Mantine's
+  // DatePickerInput opens ITS calendar in a separate portal by default, so a
+  // click on a day registers as "outside" the outer Popover and closes the
+  // whole filter before the range can be picked (or Apply reached) — the
+  // reported "date picker doesn't work". Keeping the calendar un-portalled
+  // renders it inside the outer popover's own DOM subtree instead, so
+  // outside-click detection sees it as inside.
+  const nestedPopoverProps = { withinPortal: false } as const;
+
+  return (
+    <Stack gap="xs">
+      <OperatorSelect def={def} value={op} onChange={setOp} />
+      {op === "between" ? (
+        <DatePickerInput
+          type="range"
+          size="sm"
+          leftSection={<CalendarDays size={14} />}
+          placeholder="Any"
+          value={[from, to]}
+          onChange={([f, t]) => {
+            setFrom(f);
+            setTo(t);
+          }}
+          presets={getDateRangePresets()}
+          popoverProps={nestedPopoverProps}
+          clearable
+          autoFocus
+        />
+      ) : (
+        <DatePickerInput
+          size="sm"
+          leftSection={<CalendarDays size={14} />}
+          placeholder="Any"
+          value={from}
+          onChange={setFrom}
+          popoverProps={nestedPopoverProps}
+          clearable
+          autoFocus
+        />
+      )}
+      <Button size="sm" onClick={apply} disabled={op === "between" ? !(from && to) : !from}>
+        Apply
+      </Button>
+    </Stack>
+  );
+}

apps/edr-freight-web/backoffice/src/components/filters/bodies/EnumBody.tsx

@@ -0,0 +1,139 @@
+import { useMemo, useState } from "react";
+import { Button, Checkbox, Group, Radio, Stack, Text, TextInput, UnstyledButton } from "@mantine/core";
+import { Search } from "lucide-react";
+
+import { DEFAULT_OP } from "../types";
+import type { EnumFilterDef, Operator } from "../types";
+import { OperatorSelect } from "../OperatorSelect";
+import type { FilterBodyProps } from "./TextBody";
+
+/** How many options before a search box appears above the list. */
+const SEARCH_THRESHOLD = 8;
+
+/**
+ * Stretches the Checkbox/Radio's native <label> across the full popover
+ * width and pads it, so the clickable/tappable area is the whole row —
+ * not just the ~14px input square — plus a hover cue. `body`/`labelWrapper`
+ * are Mantine's part names for this; `cursor: pointer` on the row (not just
+ * the input) makes the affordance visible before you even click.
+ */
+const ROW_STYLES = {
+  root: { padding: "10px 10px", borderRadius: 6 },
+  body: { alignItems: "center" as const },
+  labelWrapper: { flex: 1 },
+  label: { cursor: "pointer", paddingLeft: 8 },
+};
+
+function OptionLabel({ label, count }: { label: string; count?: number }) {
+  return (
+    <Group justify="space-between" wrap="nowrap" gap="sm">
+      <Text size="sm">{label}</Text>
+      {count !== undefined && (
+        <Text size="sm" c="dimmed">
+          {count}
+        </Text>
+      )}
+    </Group>
+  );
+}
+
+export function EnumBody({ def, value, onChange, onClose }: FilterBodyProps<EnumFilterDef>) {
+  const [op, setOp] = useState<Operator>(value?.op ?? DEFAULT_OP.enum);
+  const [selected, setSelected] = useState<string[]>(value?.v ?? []);
+  const [query, setQuery] = useState("");
+  const [showAll, setShowAll] = useState(false);
+  const multiple = def.multiple ?? true;
+
+  const visible = useMemo(() => {
+    const byQuery = query
+      ? def.options.filter((o) => o.label.toLowerCase().includes(query.toLowerCase()))
+      : def.options;
+    if (!def.counts || showAll) return byQuery;
+    // Hide zero-count options, but never hide one the user already picked —
+    // otherwise a filter that narrows to zero rows becomes impossible to un-select.
+    return byQuery.filter((o) => (def.counts![o.value] ?? 0) > 0 || selected.includes(o.value));
+  }, [def.options, def.counts, query, showAll, selected]);
+
+  const hiddenCount = def.options.length - visible.length;
+
+  const apply = (v: string[] = selected) => {
+    onChange(v.length ? { op, v } : undefined);
+    onClose();
+  };
+
+  // Single-select is a radio pick, not a build-up-a-set gesture — apply the
+  // instant one is chosen, same as picking an option in a plain Select.
+  // Checkbox (multiple) still needs the explicit Apply: picking several
+  // options is a multi-step gesture the popover shouldn't close mid-way through.
+  const applyRadio = (v: string) => {
+    setSelected([v]);
+    apply([v]);
+  };
+
+  return (
+    <Stack gap="xs">
+      <OperatorSelect def={def} value={op} onChange={setOp} />
+      {def.options.length > SEARCH_THRESHOLD && (
+        <TextInput
+          placeholder="Search options…"
+          leftSection={<Search size={14} />}
+          value={query}
+          onChange={(e) => setQuery(e.currentTarget.value)}
+          size="sm"
+        />
+      )}
+      <Stack gap={0} mah={260} style={{ overflowY: "auto" }}>
+        {multiple ? (
+          <Checkbox.Group value={selected} onChange={setSelected} aria-label={`Filter by ${def.label}`}>
+            <Stack gap={0}>
+              {visible.map((o) => (
+                <Checkbox
+                  key={o.value}
+                  value={o.value}
+                  size="sm"
+                  // The count sits INSIDE the label, so it's part of the
+                  // native <label> the input is bound to — clicking it (not
+                  // just the tiny checkbox square) toggles the option too.
+                  label={<OptionLabel label={o.label} count={def.counts?.[o.value]} />}
+                  styles={ROW_STYLES}
+                  classNames={{ root: "hover:bg-gray-100 transition-colors" }}
+                />
+              ))}
+            </Stack>
+          </Checkbox.Group>
+        ) : (
+          <Radio.Group
+            value={selected[0] ?? ""}
+            onChange={(v) => v && applyRadio(v)}
+            aria-label={`Filter by ${def.label}`}
+          >
+            <Stack gap={0}>
+              {visible.map((o) => (
+                <Radio
+                  key={o.value}
+                  value={o.value}
+                  size="sm"
+                  label={<OptionLabel label={o.label} count={def.counts?.[o.value]} />}
+                  styles={ROW_STYLES}
+                  classNames={{ root: "hover:bg-gray-100 transition-colors" }}
+                />
+              ))}
+            </Stack>
+          </Radio.Group>
+        )}
+        {!showAll && hiddenCount > 0 && (
+          <UnstyledButton onClick={() => setShowAll(true)}>
+            <Text size="sm" c="edr-green.6">
+              Show all {def.options.length} options
+            </Text>
+          </UnstyledButton>
+        )}
+      </Stack>
+      {multiple && (
+        <Button size="sm" onClick={() => apply()}>
+          Apply
+        </Button>
+      )}
+    </Stack>
+  );
+}

apps/edr-freight-web/backoffice/src/components/filters/bodies/NumberBody.tsx

@@ -0,0 +1,39 @@
+import { useState } from "react";
+import { Button, Group, NumberInput, Stack } from "@mantine/core";
+
+import { DEFAULT_OP } from "../types";
+import type { NumberFilterDef, Operator } from "../types";
+import { OperatorSelect } from "../OperatorSelect";
+import type { FilterBodyProps } from "./TextBody";
+
+export function NumberBody({ def, value, onChange, onClose }: FilterBodyProps<NumberFilterDef>) {
+  const [op, setOp] = useState<Operator>(value?.op ?? DEFAULT_OP.number);
+  const [from, setFrom] = useState<number | "">(value?.v[0] ? Number(value.v[0]) : "");
+  const [to, setTo] = useState<number | "">(op === "between" ? (Number(value?.v[1]) || "") : "");
+
+  const apply = () => {
+    if (op === "between") {
+      onChange(from !== "" && to !== "" ? { op, v: [String(from), String(to)] } : undefined);
+    } else {
+      onChange(from !== "" ? { op, v: [String(from)] } : undefined);
+    }
+    onClose();
+  };
+
+  return (
+    <Stack gap="xs">
+      <OperatorSelect def={def} value={op} onChange={setOp} />
+      {op === "between" ? (
+        <Group gap="xs" wrap="nowrap">
+          <NumberInput placeholder="Min" value={from} onChange={(v) => setFrom(v as number | "")} rightSection={def.unit} autoFocus />
+          <NumberInput placeholder="Max" value={to} onChange={(v) => setTo(v as number | "")} rightSection={def.unit} />
+        </Group>
+      ) : (
+        <NumberInput placeholder="Value" value={from} onChange={(v) => setFrom(v as number | "")} rightSection={def.unit} autoFocus />
+      )}
+      <Button size="sm" onClick={apply}>
+        Apply
+      </Button>
+    </Stack>
+  );
+}

apps/edr-freight-web/backoffice/src/components/filters/bodies/RouteBody.tsx

@@ -0,0 +1,59 @@
+import { useState } from "react";
+import { Button, Select, Stack } from "@mantine/core";
+import { ArrowRight } from "lucide-react";
+
+import type { RouteFilterDef } from "../types";
+import type { FilterBodyProps } from "./TextBody";
+
+/**
+ * Origin + destination picked together, each a searchable `Select` over the
+ * page's yard list — typing filters by yard name, same as any Mantine
+ * Select. No `OperatorSelect`: a route pair has exactly one operator ("is"),
+ * which is why DEFAULT_OP.route is the only entry the generic bar needs.
+ */
+export function RouteBody({ def, value, onChange, onClose }: FilterBodyProps<RouteFilterDef>) {
+  const [origin, setOrigin] = useState<string | null>(value?.v[0] ?? null);
+  const [destination, setDestination] = useState<string | null>(value?.v[1] ?? null);
+
+  const apply = () => {
+    onChange(origin && destination ? { op: "is", v: [origin, destination] } : undefined);
+    onClose();
+  };
+
+  // This popover already lives inside FilterPill's own Popover. A Select's
+  // dropdown portals separately by default, so a click on an option registers
+  // as "outside" the outer Popover and closes the whole filter before a pick
+  // lands — same nested-portal bug DateBody had. Un-portalling keeps it
+  // inside the outer popover's DOM subtree instead.
+  const comboboxProps = { withinPortal: false } as const;
+
+  return (
+    <Stack gap="xs" w={240}>
+      <Select
+        label="Origin"
+        placeholder="Any"
+        data={def.options}
+        value={origin}
+        onChange={setOrigin}
+        comboboxProps={comboboxProps}
+        searchable
+        clearable
+        autoFocus
+      />
+      <ArrowRight size={14} className="text-gray-400" style={{ alignSelf: "center" }} />
+      <Select
+        label="Destination"
+        placeholder="Any"
+        data={def.options}
+        value={destination}
+        onChange={setDestination}
+        comboboxProps={comboboxProps}
+        searchable
+        clearable
+      />
+      <Button size="sm" onClick={apply} disabled={!(origin && destination)}>
+        Apply
+      </Button>
+    </Stack>
+  );
+}

apps/edr-freight-web/backoffice/src/components/filters/bodies/TextBody.tsx

@@ -0,0 +1,39 @@
+import { useState } from "react";
+import { Button, Stack, TextInput } from "@mantine/core";
+
+import { DEFAULT_OP } from "../types";
+import type { TextFilterDef, FilterValue, Operator } from "../types";
+import { OperatorSelect } from "../OperatorSelect";
+
+export interface FilterBodyProps<Def> {
+  def: Def;
+  value: FilterValue | undefined;
+  onChange: (v: FilterValue | undefined) => void;
+  onClose: () => void;
+}
+
+export function TextBody({ def, value, onChange, onClose }: FilterBodyProps<TextFilterDef>) {
+  const [op, setOp] = useState<Operator>(value?.op ?? DEFAULT_OP.text);
+  const [text, setText] = useState(value?.v[0] ?? "");
+
+  const apply = () => {
+    onChange(text.trim() ? { op, v: [text.trim()] } : undefined);
+    onClose();
+  };
+
+  return (
+    <Stack gap="xs">
+      <OperatorSelect def={def} value={op} onChange={setOp} />
+      <TextInput
+        placeholder={def.placeholder ?? `Filter by ${def.label.toLowerCase()}…`}
+        value={text}
+        onChange={(e) => setText(e.currentTarget.value)}
+        onKeyDown={(e) => e.key === "Enter" && apply()}
+        autoFocus
+      />
+      <Button size="sm" onClick={apply}>
+        Apply
+      </Button>
+    </Stack>
+  );
+}

apps/edr-freight-web/backoffice/src/components/filters/clientFilter.ts

@@ -0,0 +1,93 @@
+import { matchesDayRange, toDayString } from "@/hooks/useListControls";
+import type { FilterDef, FilterValue } from "./types";
+
+export { matchesDayRange, toDayString };
+
+const readField = (row: unknown, key: string): unknown =>
+  row && typeof row === "object" ? (row as Record<string, unknown>)[key] : undefined;
+
+export interface ClientFilterOptions<T> {
+  /** Row fields matched against the free-text search box. */
+  searchKeys?: (keyof T)[];
+  /** Custom search extractor when the value isn't a top-level field. */
+  searchValue?: (row: T) => string;
+}
+
+/**
+ * Client-side bridge for pages whose endpoint doesn't (yet) accept
+ * filter/sort/pagination params — the Family-B pages this app inherited from
+ * `ListControls`/`useListControls`. Same idea, generalized: instead of one
+ * hardcoded search box + one date range, every `FilterDef` is matched
+ * against `row[def.key]` (override the def's `key` to line up with the row
+ * shape, or filter/map the rows before calling this).
+ *
+ * Flip a page to server mode later by deleting the `applyClientFilters` call
+ * and passing `controls.params` straight to the API — `useFilters`'s output
+ * shape doesn't change either way.
+ *
+ * ponytail: linear scan per keystroke, no debounce — matches
+ * `useListControls`'s existing behavior at this data size (~1k rows,
+ * `useListControls.ts:4-18`). Move to server-side filtering if a list
+ * outgrows that.
+ */
+export function applyClientFilters<T>(
+  rows: T[],
+  defs: FilterDef[],
+  values: Record<string, FilterValue>,
+  searchText: string,
+  options: ClientFilterOptions<T> = {},
+): T[] {
+  const term = searchText.trim().toLowerCase();
+  const { searchKeys = [], searchValue } = options;
+
+  return rows.filter((row) => {
+    if (term) {
+      const haystack = searchValue
+        ? searchValue(row)
+        : searchKeys.map((k) => String(readField(row, String(k)) ?? "")).join(" ");
+      if (!haystack.toLowerCase().includes(term)) return false;
+    }
+    for (const def of defs) {
+      const value = values[def.key];
+      if (!value) continue;
+      if (!matchesFilter(def, value, readField(row, def.key))) return false;
+    }
+    return true;
+  });
+}
+
+function matchesFilter(def: FilterDef, value: FilterValue, raw: unknown): boolean {
+  switch (def.type) {
+    case "enum": {
+      const inSet = value.v.includes(String(raw ?? ""));
+      return value.op === "isNot" ? !inSet : inSet;
+    }
+    case "date": {
+      if (value.op === "between") {
+        return matchesDayRange(raw, value.v[0]?.slice(0, 10) ?? null, value.v[1]?.slice(0, 10) ?? null);
+      }
+      const day = toDayString(raw);
+      const target = value.v[0]?.slice(0, 10);
+      if (!day || !target) return false;
+      return value.op === "before" ? day <= target : day >= target;
+    }
+    case "number": {
+      const num = Number(raw);
+      if (Number.isNaN(num)) return false;
+      if (value.op === "between") {
+        const [min, max] = value.v.map(Number);
+        return num >= min && num <= max;
+      }
+      return value.op === "isNot" ? num !== Number(value.v[0]) : num === Number(value.v[0]);
+    }
+    case "boolean":
+      return Boolean(raw) === (value.v[0] === "true");
+    case "text": {
+      const rawStr = String(raw ?? "").toLowerCase();
+      const target = (value.v[0] ?? "").toLowerCase();
+      return value.op === "isNot" ? !rawStr.includes(target) : rawStr.includes(target);
+    }
+    default:
+      return true;
+  }
+}

apps/edr-freight-web/backoffice/src/components/filters/dates.ts

@@ -0,0 +1,51 @@
+import type { FilterValue } from "./types";
+
+/** Local start-of-day -> ISO, for inclusive "from" date filters. Lifted out of
+ * ContractRequestsPage (where it was duplicated into BookingRequestsPage) so
+ * every date filter shares one definition. */
+export function startOfDayIso(d: Date): string {
+  const x = new Date(d);
+  x.setHours(0, 0, 0, 0);
+  return x.toISOString();
+}
+
+/** Local end-of-day -> ISO, for inclusive "to" date filters. */
+export function endOfDayIso(d: Date): string {
+  const x = new Date(d);
+  x.setHours(23, 59, 59, 999);
+  return x.toISOString();
+}
+
+/**
+ * Parse a `YYYY-MM-DD` date-picker string into a LOCAL-midnight Date.
+ *
+ * `new Date("2026-01-01")` is a date-ONLY ISO string, which the spec parses
+ * as UTC midnight, not local midnight. For anyone east of UTC (Ethiopia is
+ * UTC+3) that instant already falls on the PREVIOUS local day, so
+ * `startOfDayIso`/`endOfDayIso` built from it silently shift the picked date
+ * back by one — the picker looks fine, the filtered results are wrong. This
+ * constructor form (`new Date(y, m, d)`) is local by definition; use it for
+ * every date-only string instead of `new Date(dateString)`.
+ */
+export function parseDateStr(dateStr: string): Date {
+  const [y, m, d] = dateStr.split("-").map(Number);
+  return new Date(y, (m || 1) - 1, d || 1);
+}
+
+/**
+ * `toParams` for a date `FilterDef` widened to `["between", "before", "after"]`
+ * operators. `DateBody` always emits a single-element `v` for before/after —
+ * a plain positional `{[fromKey]: v[0], [toKey]: v[1]}` mapping (the
+ * between-only default) would wrongly land a "before" pick in `fromKey`
+ * instead of `toKey`. This routes each operator to the right bound.
+ */
+export function dateRangeParams(
+  fromKey: string,
+  toKey: string,
+): (v: FilterValue) => Record<string, string | undefined> {
+  return (value) => {
+    if (value.op === "before") return { [toKey]: value.v[0] };
+    if (value.op === "after") return { [fromKey]: value.v[0] };
+    return { [fromKey]: value.v[0], [toKey]: value.v[1] };
+  };
+}

apps/edr-freight-web/backoffice/src/components/filters/format.ts

@@ -0,0 +1,40 @@
+import { parseFilters } from "./url";
+import type { FilterDef, FilterValue } from "./types";
+
+/** Human-readable text for one filter's current value — same text a
+ * FilterPill shows, and what a saved view's auto-generated label is built
+ * from, so both read identically with zero duplicated logic. */
+export function formatFilterValue(def: FilterDef, value: FilterValue): string {
+  if (def.format) return def.format(value, def);
+  if (def.type === "enum") {
+    const labels = value.v.map((v) => def.options.find((o) => o.value === v)?.label ?? v);
+    return labels.join(", ");
+  }
+  if (def.type === "date" && value.v.length === 2) {
+    return `${value.v[0].slice(0, 10)} → ${value.v[1].slice(0, 10)}`;
+  }
+  if (def.type === "route" && value.v.length === 2) {
+    const label = (id: string) => def.options.find((o) => o.value === id)?.label ?? id;
+    return `${label(value.v[0])} → ${label(value.v[1])}`;
+  }
+  return value.v.join(", ");
+}
+
+/**
+ * Auto-generated label for a saved view — "Status: Active, Draft · Direction:
+ * Import" — built straight from the filters it holds, instead of asking the
+ * user to type a name (which drifts out of sync with what the view actually
+ * filters the moment they edit it). Falls back to "All" when nothing decodes,
+ * though a view is only ever offered for saving with at least one active filter.
+ *
+ * Namespace-aware pages (`useFilters({ ns })`, for a second table on the same
+ * page) aren't decoded here — every current saved-view page is single-table.
+ * Thread `ns` through if/when that changes.
+ */
+export function describeQuery(defs: FilterDef[], query: string): string {
+  const values = parseFilters(defs, new URLSearchParams(query));
+  const parts = defs
+    .filter((d) => values[d.key])
+    .map((d) => `${d.label}: ${formatFilterValue(d, values[d.key])}`);
+  return parts.length ? parts.join(" · ") : "All";
+}

apps/edr-freight-web/backoffice/src/components/filters/index.ts

@@ -0,0 +1,15 @@
+export * from "./types";
+export * from "./url";
+export * from "./dates";
+export * from "./format";
+export * from "./clientFilter";
+export * from "./ruleEngineFooterProps";
+export * from "./useFilters";
+export * from "./useSavedViews";
+export { FilterBar } from "./FilterBar";
+export type { FilterBarProps } from "./FilterBar";
+export { FilterPill } from "./FilterPill";
+export { SortControl } from "./SortControl";
+export { SaveViewButton } from "./SaveViewButton";
+export { SavedViewCards } from "./SavedViewCards";
+export { MoreFiltersMenu } from "./MoreFiltersMenu";

apps/edr-freight-web/backoffice/src/components/filters/ruleEngineFooterProps.ts

@@ -0,0 +1,32 @@
+import type { OnChangeFn, PaginationState } from "@edr/ui-common";
+import type { UseFilters } from "./useFilters";
+
+/**
+ * Adapts `useFilters`'s URL-backed page/pageSize to `RuleEngineListFooter`'s
+ * prop shape, for the client-bridge pages that render a plain `<Table>` +
+ * that footer instead of `<DataTable>` (which has `tableProps()` for this).
+ * Routes page-index vs page-size changes to the right setter — the same
+ * pageSize-gets-silently-dropped bug `tableProps()` had before it was fixed.
+ */
+export function toRuleEngineFooterProps(
+  controls: Pick<UseFilters, "page" | "pageSize" | "setPage" | "setPageSize">,
+  totalCount: number,
+): {
+  pagination: PaginationState;
+  pageCount: number;
+  totalCount: number;
+  onPaginationChange: OnChangeFn<PaginationState>;
+} {
+  const { page, pageSize, setPage, setPageSize } = controls;
+  return {
+    pagination: { pageIndex: page - 1, pageSize },
+    pageCount: Math.max(1, Math.ceil(totalCount / pageSize)),
+    totalCount,
+    onPaginationChange: (updater) => {
+      const current = { pageIndex: page - 1, pageSize };
+      const next = typeof updater === "function" ? updater(current) : updater;
+      if (next.pageSize !== pageSize) setPageSize(next.pageSize);
+      else if (next.pageIndex !== current.pageIndex) setPage(next.pageIndex + 1);
+    },
+  };
+}

apps/edr-freight-web/backoffice/src/components/filters/types.ts

@@ -0,0 +1,115 @@
+export type FilterType = "text" | "enum" | "date" | "number" | "boolean" | "route";
+
+export type Operator = "is" | "isNot" | "contains" | "between" | "before" | "after";
+
+/** Operator implied by a filter's type when the def doesn't say otherwise. */
+export const DEFAULT_OP: Record<FilterType, Operator> = {
+  text: "contains",
+  enum: "is",
+  date: "between",
+  number: "is",
+  boolean: "is",
+  route: "is",
+};
+
+export const OPERATOR_LABELS: Record<Operator, string> = {
+  is: "is",
+  isNot: "is not",
+  contains: "contains",
+  between: "is between",
+  before: "is before",
+  after: "is after",
+};
+
+/**
+ * A filter's current value. `v` holds:
+ * - 1 entry for is / isNot / contains / before / after
+ * - 2 entries for between (range)
+ * - n entries for a multi-select enum (isAnyOf is expressed as op "is" + n values)
+ */
+export interface FilterValue {
+  op: Operator;
+  v: string[];
+}
+
+export interface FilterOption {
+  value: string;
+  label: string;
+}
+
+export interface FacetBucket {
+  value: string;
+  count: number;
+}
+
+interface FilterDefBase {
+  /** URL key and, by default, the API param name. */
+  key: string;
+  /** Plain string — the caller applies i18n's t() before passing it in. */
+  label: string;
+  type: FilterType;
+  /** Defaults to `[DEFAULT_OP[type]]`. Widen only where the endpoint implements it. */
+  operators?: Operator[];
+  /** Pill text override. Default: "Label | value(s)". */
+  format?: (v: FilterValue, def: FilterDef) => string;
+  /** Map to API query params. Default `{ [key]: v.join(",") }`. */
+  toParams?: (v: FilterValue) => Record<string, string | undefined>;
+  /** Lives behind "More filters" until it has a value. Default false. */
+  secondary?: boolean;
+}
+
+export interface TextFilterDef extends FilterDefBase {
+  type: "text";
+  placeholder?: string;
+}
+
+export interface EnumFilterDef extends FilterDefBase {
+  type: "enum";
+  options: FilterOption[];
+  /** Default true — checkbox list. false renders a single-select radio list. */
+  multiple?: boolean;
+  /** value -> count in the current (filtered) result set. Absent = no counts, hide nothing. */
+  counts?: Record<string, number>;
+}
+
+export interface DateFilterDef extends FilterDefBase {
+  type: "date";
+  calendar?: "gregorian" | "ethiopian";
+}
+
+export interface NumberFilterDef extends FilterDefBase {
+  type: "number";
+  unit?: string;
+}
+
+export interface BooleanFilterDef extends FilterDefBase {
+  type: "boolean";
+  trueLabel?: string;
+  falseLabel?: string;
+}
+
+/**
+ * Origin + destination picked together as one pill — `v` is always the
+ * 2-slot pair `[originYardId, destinationYardId]`, never partial (the body's
+ * Apply button stays disabled until both sides are chosen, same rule
+ * `DateBody` uses for a `between` range). One shared `options` list drives
+ * both selects.
+ */
+export interface RouteFilterDef extends FilterDefBase {
+  type: "route";
+  options: FilterOption[];
+}
+
+export type FilterDef =
+  | TextFilterDef
+  | EnumFilterDef
+  | DateFilterDef
+  | NumberFilterDef
+  | BooleanFilterDef
+  | RouteFilterDef;
+
+/** A page's sort options — value is already `"field:DIR"`, the codebase's existing convention. */
+export interface SortOption {
+  value: string;
+  label: string;
+}

apps/edr-freight-web/backoffice/src/components/filters/url.test.ts

@@ -0,0 +1,170 @@
+import { describe, expect, it } from "vitest";
+
+import type { FilterDef, FilterValue } from "./types";
+import {
+  decodeFilterValue,
+  encodeFilterValue,
+  parseFilters,
+  parseSort,
+  toApiParams,
+  writeFilter,
+} from "./url";
+
+const STATUS: FilterDef = {
+  key: "statuses",
+  label: "Status",
+  type: "enum",
+  options: [
+    { value: "ACTIVE", label: "Active" },
+    { value: "DRAFT", label: "Draft" },
+  ],
+};
+
+const DIRECTION: FilterDef = {
+  key: "tradeDirection",
+  label: "Direction",
+  type: "enum",
+  multiple: false,
+  options: [{ value: "IMPORT", label: "Import" }],
+};
+
+const SEARCH: FilterDef = { key: "q", label: "Search", type: "text" };
+
+const CREATED: FilterDef = {
+  key: "created",
+  label: "Created",
+  type: "date",
+  toParams: ({ v }) => ({ createdFrom: v[0], createdTo: v[1] }),
+};
+
+describe("encodeFilterValue / decodeFilterValue round-trip", () => {
+  const cases: Array<{ name: string; type: FilterDef["type"]; value: FilterValue }> = [
+    { name: "text contains (default op omitted)", type: "text", value: { op: "contains", v: ["maersk"] } },
+    { name: "enum is (default op omitted, multi value)", type: "enum", value: { op: "is", v: ["ACTIVE", "DRAFT"] } },
+    { name: "enum isNot (non-default op prefixed)", type: "enum", value: { op: "isNot", v: ["GOV"] } },
+    { name: "date between (default op omitted)", type: "date", value: { op: "between", v: ["2026-01-01", "2026-03-01"] } },
+    { name: "date before (non-default op prefixed)", type: "date", value: { op: "before", v: ["2026-01-01"] } },
+    { name: "number is", type: "number", value: { op: "is", v: ["42"] } },
+    { name: "boolean is", type: "boolean", value: { op: "is", v: ["true"] } },
+  ];
+
+  for (const { name, type, value } of cases) {
+    it(`round-trips: ${name}`, () => {
+      const encoded = encodeFilterValue(type, value);
+      const decoded = decodeFilterValue(type, encoded);
+      expect(decoded).toEqual(value);
+    });
+  }
+
+  it("omits the operator prefix only when it is the type default", () => {
+    expect(encodeFilterValue("enum", { op: "is", v: ["ACTIVE"] })).toBe("ACTIVE");
+    expect(encodeFilterValue("enum", { op: "isNot", v: ["ACTIVE"] })).toBe("isNot:ACTIVE");
+  });
+
+  it("never comma-splits a text value, so a literal comma survives", () => {
+    const encoded = encodeFilterValue("text", { op: "contains", v: ["Addis, Ethiopia"] });
+    expect(decodeFilterValue("text", encoded)).toEqual({ op: "contains", v: ["Addis, Ethiopia"] });
+  });
+});
+
+describe("decodeFilterValue malformed-input tolerance", () => {
+  it("returns null for an empty string", () => {
+    expect(decodeFilterValue("text", "")).toBeNull();
+  });
+
+  it("does not treat an unknown prefix as an operator", () => {
+    // "foo" isn't a known Operator, so "foo:bar" is a literal text value, not op:value.
+    expect(decodeFilterValue("text", "foo:bar")).toEqual({ op: "contains", v: ["foo:bar"] });
+  });
+
+  it("degrades a one-sided 'between' to null (not applied) instead of guessing a half-open range", () => {
+    expect(decodeFilterValue("date", "between:2026-01-01")).toBeNull();
+  });
+
+  it("never throws on garbage input", () => {
+    expect(() => decodeFilterValue("enum", "isNot:")).not.toThrow();
+    expect(() => decodeFilterValue("date", "between:")).not.toThrow();
+    expect(() => decodeFilterValue("number", ":::")).not.toThrow();
+  });
+});
+
+describe("parseFilters / writeFilter", () => {
+  it("parses only the defs present, ignoring unrelated params", () => {
+    const params = new URLSearchParams("statuses=ACTIVE,DRAFT&unrelated=x&q=addis");
+    const values = parseFilters([STATUS, SEARCH], params);
+    expect(values).toEqual({
+      statuses: { op: "is", v: ["ACTIVE", "DRAFT"] },
+      q: { op: "contains", v: ["addis"] },
+    });
+  });
+
+  it("writeFilter deletes the param when value is undefined", () => {
+    const params = new URLSearchParams("statuses=ACTIVE");
+    const next = writeFilter(params, STATUS, undefined);
+    expect(next.has("statuses")).toBe(false);
+  });
+
+  it("writeFilter round-trips through parseFilters", () => {
+    const value: FilterValue = { op: "is", v: ["IMPORT"] };
+    const next = writeFilter(new URLSearchParams(), DIRECTION, value);
+    expect(parseFilters([DIRECTION], next)).toEqual({ tradeDirection: value });
+  });
+
+  it("namespaces keys when ns is given, so two tables on one page don't collide", () => {
+    const next = writeFilter(new URLSearchParams(), STATUS, { op: "is", v: ["ACTIVE"] }, "a");
+    expect(next.get("a.statuses")).toBe("ACTIVE");
+    expect(parseFilters([STATUS], new URLSearchParams(), "b")).toEqual({});
+  });
+});
+
+describe("existing deep-link backward compatibility", () => {
+  it("parses the BookingRequestsPage-style ?statuses=A,B&tradeDirection=IMPORT link unchanged", () => {
+    const params = new URLSearchParams("statuses=SUBMITTED,APPROVED&tradeDirection=IMPORT");
+    expect(parseFilters([STATUS, DIRECTION], params)).toEqual({
+      statuses: { op: "is", v: ["SUBMITTED", "APPROVED"] },
+      tradeDirection: { op: "is", v: ["IMPORT"] },
+    });
+  });
+});
+
+describe("parseSort", () => {
+  const options = [
+    { value: "createdAt:DESC", label: "Newest first" },
+    { value: "createdAt:ASC", label: "Oldest first" },
+  ];
+
+  it("returns the fallback when sort is absent", () => {
+    expect(parseSort(new URLSearchParams(), options, "createdAt:DESC")).toBe("createdAt:DESC");
+  });
+
+  it("returns the fallback for an unrecognized sort value", () => {
+    expect(parseSort(new URLSearchParams("sort=bogus:DESC"), options, "createdAt:DESC")).toBe(
+      "createdAt:DESC",
+    );
+  });
+
+  it("returns the URL value when it is a known option", () => {
+    expect(parseSort(new URLSearchParams("sort=createdAt:ASC"), options, "createdAt:DESC")).toBe(
+      "createdAt:ASC",
+    );
+  });
+});
+
+describe("toApiParams", () => {
+  it("uses the default mapping (key: joined csv) when toParams is absent", () => {
+    const values = { statuses: { op: "is" as const, v: ["ACTIVE", "DRAFT"] } };
+    expect(toApiParams([STATUS], values)).toEqual({ statuses: "ACTIVE,DRAFT" });
+  });
+
+  it("uses a custom toParams to reproduce an existing API's exact param names", () => {
+    const values = { created: { op: "between" as const, v: ["2026-01-01", "2026-03-01"] } };
+    expect(toApiParams([CREATED], values)).toEqual({
+      createdFrom: "2026-01-01",
+      createdTo: "2026-03-01",
+    });
+  });
+
+  it("omits defs with no value", () => {
+    expect(toApiParams([STATUS, SEARCH], {})).toEqual({});
+  });
+});

apps/edr-freight-web/backoffice/src/components/filters/url.ts

@@ -0,0 +1,117 @@
+import { DEFAULT_OP, type FilterDef, type FilterValue, type Operator } from "./types";
+
+const OPERATORS: readonly Operator[] = ["is", "isNot", "contains", "between", "before", "after"];
+
+/**
+ * Encode one filter value as `[op:]csv`, omitting the operator prefix when it
+ * matches the type's default — that keeps the common case short and, more
+ * importantly, keeps the existing `?statuses=A,B` deep links this app already
+ * generates (e.g. the header document-review alarm) parsing identically.
+ *
+ * `,` and `:` are structural inside an encoded value. A `text` filter is
+ * never comma-split (its `v` always has exactly one entry), which is what
+ * lets a free-text search contain a literal comma safely.
+ * ponytail: if a value ever legitimately needs a literal "op:" prefix or a
+ * comma inside a multi-value filter, switch that filter to a JSON-in-one-param
+ * encoding rather than trying to escape these two characters.
+ */
+export function encodeFilterValue(type: FilterDef["type"], value: FilterValue): string {
+  const csv = value.v.map(encodeURIComponent).join(",");
+  return value.op === DEFAULT_OP[type] ? csv : `${value.op}:${csv}`;
+}
+
+/** Inverse of `encodeFilterValue`. Returns null for anything malformed — a bad
+ * URL is user input and must degrade to "filter not applied", never throw. */
+export function decodeFilterValue(type: FilterDef["type"], raw: string): FilterValue | null {
+  if (!raw) return null;
+  const firstColon = raw.indexOf(":");
+  let op: Operator = DEFAULT_OP[type];
+  let rest = raw;
+  if (firstColon > 0) {
+    const prefix = raw.slice(0, firstColon);
+    if ((OPERATORS as string[]).includes(prefix)) {
+      op = prefix as Operator;
+      rest = raw.slice(firstColon + 1);
+    }
+  }
+  // Text filters are single-value and never comma-split, so a literal comma
+  // in a search term round-trips unchanged.
+  const v =
+    type === "text"
+      ? [decodeURIComponent(rest)]
+      : rest.split(",").filter(Boolean).map(decodeURIComponent);
+  if (v.length === 0) return null;
+  // A malformed range (wrong arity) has no safe single-sided interpretation —
+  // "between:2026-01-01" doesn't say whether that's the from or the to — so
+  // it degrades to "filter not applied" rather than guessing a half-open range.
+  if (op === "between" && v.length !== 2) return null;
+  return { op, v };
+}
+
+/** Every FilterDef's current value, parsed from the URL. Unknown/malformed entries are dropped. */
+export function parseFilters(
+  defs: FilterDef[],
+  params: URLSearchParams,
+  ns?: string,
+): Record<string, FilterValue> {
+  const out: Record<string, FilterValue> = {};
+  for (const def of defs) {
+    const raw = params.get(nsKey(def.key, ns));
+    if (!raw) continue;
+    const value = decodeFilterValue(def.type, raw);
+    if (value) out[def.key] = value;
+  }
+  return out;
+}
+
+/** Write (or delete) one filter's value into a URLSearchParams, returning a new instance. */
+export function writeFilter(
+  params: URLSearchParams,
+  def: FilterDef,
+  value: FilterValue | undefined,
+  ns?: string,
+): URLSearchParams {
+  const next = new URLSearchParams(params);
+  const key = nsKey(def.key, ns);
+  if (!value || value.v.length === 0) next.delete(key);
+  else next.set(key, encodeFilterValue(def.type, value));
+  return next;
+}
+
+function nsKey(key: string, ns?: string): string {
+  return ns ? `${ns}.${key}` : key;
+}
+
+/** `?sort=field:DIR` -> `"field:DIR"`, defaulting when absent/unrecognized. */
+export function parseSort(params: URLSearchParams, options: { value: string }[], fallback: string): string {
+  const raw = params.get("sort");
+  if (raw && options.some((o) => o.value === raw)) return raw;
+  return fallback;
+}
+
+/**
+ * Flatten every def's parsed value into the flat param object a page's
+ * react-query filter object / axios params already expect. `toParams`
+ * defaults to `{ [key]: v.join(",") }`, which reproduces exactly what
+ * `?statuses=A,B` meant before this bar existed.
+ */
+export function toApiParams(
+  defs: FilterDef[],
+  values: Record<string, FilterValue>,
+): Record<string, string | undefined> {
+  const out: Record<string, string | undefined> = {};
+  for (const def of defs) {
+    const value = values[def.key];
+    if (!value) continue;
+    const mapped = def.toParams ? def.toParams(value) : { [def.key]: value.v.join(",") };
+    Object.assign(out, mapped);
+  }
+  return out;
+}
+
+/** Delete emptystring/undefined/null entries — never send them, never write them to the URL. */
+export function cleanParams<T extends Record<string, unknown>>(params: T): Partial<T> {
+  return Object.fromEntries(
+    Object.entries(params).filter(([, v]) => v !== undefined && v !== null && v !== ""),
+  ) as Partial<T>;
+}

apps/edr-freight-web/backoffice/src/components/filters/useFilters.ts

@@ -0,0 +1,236 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useSearchParams } from "react-router-dom";
+import { useDebouncedValue } from "@mantine/hooks";
+
+import type { DataTablePagination, DataTableProps } from "@edr/ui-common";
+import type { FilterDef, FilterValue } from "./types";
+import { cleanParams, parseFilters, toApiParams, writeFilter } from "./url";
+
+export interface UseFiltersOptions {
+  /** value = "field:DIR", matching the codebase's existing sort convention. */
+  defaultSort?: string;
+  pageSize?: number;
+  /** "page" (freight: {page,pageSize}) or "skip" (record-management: {skip,take}). */
+  paginationStyle?: "page" | "skip";
+  /** Namespaces URL keys ("<ns>.<key>") for pages with two independent tables. */
+  ns?: string;
+  /** Search box debounce, ms. */
+  searchDebounceMs?: number;
+}
+
+export interface UseFilters {
+  values: Record<string, FilterValue>;
+  /** Flat params ready for the react-query key + axios `params` — IS the query key input. */
+  params: Record<string, string | number>;
+  sort: string;
+  page: number;
+  pageSize: number;
+  searchText: string;
+  setSearchText: (s: string) => void;
+  setFilter: (key: string, value: FilterValue | undefined) => void;
+  removeFilter: (key: string) => void;
+  clearFilters: () => void;
+  setSort: (s: string) => void;
+  setPage: (p: number) => void;
+  setPageSize: (size: number) => void;
+  activeCount: number;
+  /** Spread onto <DataTable/>. Same shape useListControls.tableProps returns today. */
+  tableProps: (total: number) => Pick<DataTableProps<any, any>, "pagination" | "tableOptions">;
+  /** Replace the whole URL (saved-view restore). Pushes, so Back undoes it. */
+  applyQueryString: (query: string) => void;
+  /** Current filter state as a raw query string, for saving as a view (page stripped). */
+  currentQueryString: () => string;
+}
+
+const DEFAULT_PAGE_SIZE = 10;
+
+export function useFilters(defs: FilterDef[], options: UseFiltersOptions = {}): UseFilters {
+  const {
+    defaultSort = "",
+    pageSize: defaultPageSize = DEFAULT_PAGE_SIZE,
+    paginationStyle = "page",
+    ns,
+    searchDebounceMs = 300,
+  } = options;
+
+  const [sp, setSp] = useSearchParams();
+  const searchKey = ns ? `${ns}.q` : "q";
+  const pageKey = ns ? `${ns}.page` : "page";
+  const sizeKey = ns ? `${ns}.size` : "size";
+
+  const values = useMemo(() => parseFilters(defs, sp, ns), [defs, sp, ns]);
+  const sort = sp.get(ns ? `${ns}.sort` : "sort") ?? defaultSort;
+  const page = Math.max(1, Number(sp.get(pageKey)) || 1);
+  const pageSize = Math.max(1, Number(sp.get(sizeKey)) || defaultPageSize);
+
+  // Free text: local draft debounced into the URL with `replace`, so typing
+  // leaves exactly one history entry instead of one per keystroke.
+  const [searchText, setSearchTextState] = useState(() => sp.get(searchKey) ?? "");
+  const [debouncedSearch] = useDebouncedValue(searchText, searchDebounceMs);
+
+  useEffect(() => {
+    const urlValue = sp.get(searchKey) ?? "";
+    if (urlValue === debouncedSearch) return;
+    setSp(
+      (prev) => {
+        const next = new URLSearchParams(prev);
+        if (debouncedSearch) next.set(searchKey, debouncedSearch);
+        else next.delete(searchKey);
+        next.delete(pageKey);
+        return next;
+      },
+      { replace: true },
+    );
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [debouncedSearch]);
+
+  useEffect(() => {
+    // External navigation (back/forward, saved-view restore, deep link) —
+    // sync the local draft from the URL. Comparing against the debounced
+    // value (not `searchText`) is what stops this from clobbering an
+    // in-flight keystroke: mid-type, urlValue !== debouncedSearch is expected.
+    const urlValue = sp.get(searchKey) ?? "";
+    if (urlValue !== debouncedSearch) setSearchTextState(urlValue);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [sp]);
+
+  const setFilter = useCallback(
+    (key: string, value: FilterValue | undefined) => {
+      const def = defs.find((d) => d.key === key);
+      if (!def) return;
+      setSp((prev) => {
+        const next = writeFilter(prev, def, value, ns);
+        next.delete(pageKey);
+        return next;
+      });
+    },
+    [defs, ns, pageKey, setSp],
+  );
+
+  const removeFilter = useCallback((key: string) => setFilter(key, undefined), [setFilter]);
+
+  const clearFilters = useCallback(() => {
+    setSp((prev) => {
+      const next = new URLSearchParams(prev);
+      for (const def of defs) next.delete(ns ? `${ns}.${def.key}` : def.key);
+      next.delete(searchKey);
+      next.delete(pageKey);
+      return next;
+    });
+    setSearchTextState("");
+  }, [defs, ns, pageKey, searchKey, setSp]);
+
+  const setSort = useCallback(
+    (value: string) => {
+      setSp((prev) => {
+        const next = new URLSearchParams(prev);
+        const key = ns ? `${ns}.sort` : "sort";
+        if (value === defaultSort) next.delete(key);
+        else next.set(key, value);
+        next.delete(pageKey);
+        return next;
+      });
+    },
+    [defaultSort, ns, pageKey, setSp],
+  );
+
+  const setPage = useCallback(
+    (p: number) => {
+      setSp((prev) => {
+        const next = new URLSearchParams(prev);
+        if (p <= 1) next.delete(pageKey);
+        else next.set(pageKey, String(p));
+        return next;
+      });
+    },
+    [pageKey, setSp],
+  );
+
+  const setPageSize = useCallback(
+    (size: number) => {
+      setSp((prev) => {
+        const next = new URLSearchParams(prev);
+        if (size === defaultPageSize) next.delete(sizeKey);
+        else next.set(sizeKey, String(size));
+        next.delete(pageKey); // a different page size invalidates the current page index
+        return next;
+      });
+    },
+    [defaultPageSize, sizeKey, pageKey, setSp],
+  );
+
+  const params = useMemo(() => {
+    const filterParams = toApiParams(defs, values);
+    const base: Record<string, string | number | undefined> =
+      paginationStyle === "skip"
+        ? { skip: (page - 1) * pageSize, take: pageSize }
+        : { page, pageSize };
+    if (debouncedSearch) base.search = debouncedSearch;
+    if (sort) {
+      if (paginationStyle === "skip") base.orderBy = sort;
+      else {
+        const [sortBy, sortOrder] = sort.split(":");
+        base.sortBy = sortBy;
+        base.sortOrder = sortOrder;
+      }
+    }
+    return cleanParams({ ...filterParams, ...base }) as Record<string, string | number>;
+  }, [defs, values, paginationStyle, page, pageSize, debouncedSearch, sort]);
+
+  const activeCount = Object.keys(values).length + (debouncedSearch ? 1 : 0);
+
+  const tableProps = useCallback(
+    (total: number): Pick<DataTableProps<any, any>, "pagination" | "tableOptions"> => {
+      const pageCount = Math.max(1, Math.ceil(total / pageSize));
+      const pagination: DataTablePagination = { pageIndex: page - 1, pageSize, pageCount, totalCount: total };
+      return {
+        pagination,
+        tableOptions: {
+          manualPagination: true,
+          pageCount,
+          state: { pagination: { pageIndex: page - 1, pageSize } },
+          onPaginationChange: (updater) => {
+            const current = { pageIndex: page - 1, pageSize };
+            const next = typeof updater === "function" ? updater(current) : updater;
+            if (next.pageSize !== pageSize) setPageSize(next.pageSize);
+            else if (next.pageIndex !== current.pageIndex) setPage(next.pageIndex + 1);
+          },
+        },
+      };
+    },
+    [page, pageSize, setPage, setPageSize],
+  );
+
+  const applyQueryString = useCallback(
+    (query: string) => setSp(new URLSearchParams(query)),
+    [setSp],
+  );
+
+  const currentQueryString = useCallback(() => {
+    const next = new URLSearchParams(sp);
+    next.delete(pageKey);
+    return next.toString();
+  }, [sp, pageKey]);
+
+  return {
+    values,
+    params,
+    sort,
+    page,
+    pageSize,
+    searchText,
+    setSearchText: setSearchTextState,
+    setFilter,
+    removeFilter,
+    clearFilters,
+    setSort,
+    setPage,
+    setPageSize,
+    activeCount,
+    tableProps,
+    applyQueryString,
+    currentQueryString,
+  };
+}
+
+export { toApiParams } from "./url";

apps/edr-freight-web/backoffice/src/components/filters/useSavedViews.ts

@@ -0,0 +1,32 @@
+import { useLocalStorage } from "@mantine/hooks";
+
+export interface SavedView {
+  id: string;
+  /** Raw query string ("statuses=ACTIVE&sort=createdAt:DESC") — the label is
+   * derived from this at render time (see format.ts's describeQuery), so
+   * there's nothing else to keep in sync. */
+  query: string;
+  savedAt: number;
+}
+
+/**
+ * localStorage namespace is per PAGE (viewId), not per user — this is a
+ * backoffice, one staff login per browser profile.
+ * ponytail: add ":<userId>" if shared-terminal login appears.
+ */
+export function useSavedViews(viewId: string) {
+  const [views, setViews] = useLocalStorage<SavedView[]>({
+    key: `edr:saved-views:${viewId}`,
+    defaultValue: [],
+  });
+
+  const save = (query: string): SavedView => {
+    const view: SavedView = { id: crypto.randomUUID(), query, savedAt: Date.now() };
+    setViews((prev) => [...prev, view]);
+    return view;
+  };
+
+  const remove = (id: string) => setViews((prev) => prev.filter((v) => v.id !== id));
+
+  return { views, save, remove };
+}

apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx

@@ -1,44 +1,32 @@
 import { useMyTradeAccess } from "@/hooks/useMyTradeAccess";
 import {
-  ActionIcon,
   Box,
   Button,
   Card,
-  Checkbox,
-  Collapse,
   Group,
   Modal,
-  MultiSelect,
-  Select,
   Stack,
   Text,
-  TextInput,
 } from "@mantine/core";
-import { DatePickerInput } from "@mantine/dates";
-import { getDateRangePresets } from "@/components/common/dateRangePresets";
-import { useDebouncedValue } from "@mantine/hooks";
 import {
   AlertTriangle,
   ArrowRight,
   Calendar,
   CheckCircle2,
   Clock,
-  FilterX,
   LayoutList,
   Package,
   Plus,
   RefreshCw,
-  Search,
   User,
-  X,
 } from "lucide-react";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { useNavigate, useSearchParams } from "react-router-dom";
+import { useCallback, useMemo, useRef, useState } from "react";
+import { useNavigate } from "react-router-dom";
 import { useQuery } from "@tanstack/react-query";
 
 import { BookingActionsMenu } from "@/components/bookings/BookingActionsMenu";
-import { FilterToggle } from "@/components/common/FilterToggle";
 import { formatDate, humanize } from "@/lib/format";
+import { FilterBar, dateRangeParams, useFilters, type FilterDef } from "@/components/filters";
 import { BookingPriorityBadge } from "@/components/bookings/BookingPriorityBadge";
 import { BookingStatusBadge } from "@/components/bookings/BookingStatusBadge";
 // BookingStatusTabs / Operations* queues removed — replaced by booking-kind tabs.
@@ -63,7 +51,6 @@ import {
   Badge,
   DataTable,
   DataTableFooter,
-  usePagination,
   type ColumnDef,
 } from "@edr/ui-common";
 
@@ -104,61 +91,11 @@ const OWNERSHIP_OPTIONS = [
   { value: "false", label: "Private" },
 ];
 
-/** Local start-of-day → ISO, for inclusive "from" date filters. */
-function startOfDayIso(d: Date): string {
-  const x = new Date(d);
-  x.setHours(0, 0, 0, 0);
-  return x.toISOString();
-}
-
-/** Local end-of-day → ISO, for inclusive "to" date filters. */
-function endOfDayIso(d: Date): string {
-  const x = new Date(d);
-  x.setHours(23, 59, 59, 999);
-  return x.toISOString();
-}
-
 export default function BookingRequestsPage() {
   const navigate = useNavigate();
-  // Deep links land here pre-filtered (?statuses=A,B&tradeDirection=IMPORT) —
-  // the header's document-review alarm opens exactly the undecided requests it
-  // is counting down for. Read once as the initial state so staff can then
-  // change the filters like any other visit.
-  const [searchParams] = useSearchParams();
-  const { pagination, setPagination } = usePagination({ pageSize: 10 });
-  const [query, setQuery] = useState("");
-  const [debouncedQuery] = useDebouncedValue(query, 300);
-  // Booking kind is a filter now — one list holds both kinds (null = "all").
-  const [kindFilter, setKindFilter] = useState<BookingKind | null>(null);
-  // Filter controls (empty/null = "all").
-  const paramStatuses = searchParams.get("statuses") ?? "";
-  const paramDirection = searchParams.get("tradeDirection");
-  const [statusFilter, setStatusFilter] = useState<string[]>(() =>
-    paramStatuses.split(",").filter(Boolean),
-  );
   const { filterOptions } = useMyTradeAccess();
-  const [directionFilter, setDirectionFilter] = useState<string | null>(
-    paramDirection,
-  );
-  const [freightTypeFilter, setFreightTypeFilter] = useState<string | null>(null);
-  const [paymentStatusFilter, setPaymentStatusFilter] = useState<string | null>(null);
-  const [ownershipFilter, setOwnershipFilter] = useState<string | null>(null);
-  const [originYardFilter, setOriginYardFilter] = useState<string | null>(null);
-  const [destinationYardFilter, setDestinationYardFilter] = useState<string | null>(null);
-  const [createdFrom, setCreatedFrom] = useState<Date | null>(null);
-  const [createdTo, setCreatedTo] = useState<Date | null>(null);
-  const [scheduledFrom, setScheduledFrom] = useState<Date | null>(null);
-  const [scheduledTo, setScheduledTo] = useState<Date | null>(null);
-  // Direction is the only deep-linkable advanced filter — open the panel so a
-  // deep link never hides its own filter.
-  const [showAdvanced, setShowAdvanced] = useState(() =>
-    Boolean(paramDirection),
-  );
   const [allocateOpen, setAllocateOpen] = useState(false);
   const [allocateIds, setAllocateIds] = useState<string[]>([]);
-  // Paid bookings with no train attached (staff removed them or a sweep
-  // detached them) — the queue the per-row Allocate action works through.
-  const [paidUnallocated, setPaidUnallocated] = useState(false);
   const [allocatingId, setAllocatingId] = useState<string | null>(null);
   const [otherDayModal, setOtherDayModal] = useState<{
     booking: BookingListRow;
@@ -173,77 +110,6 @@ export default function BookingRequestsPage() {
     }, 400);
   }, []);
 
-  // Follow the URL when a deep link arrives while the page is already open
-  // (clicking the header alarm from this very list). Same-value writes are
-  // dropped so a manual filter change is never undone.
-  useEffect(() => {
-    const next = paramStatuses.split(",").filter(Boolean);
-    setStatusFilter((prev) => (prev.join(",") === next.join(",") ? prev : next));
-    setDirectionFilter(paramDirection);
-    if (paramDirection) setShowAdvanced(true);
-  }, [paramStatuses, paramDirection]);
-
-  const filter: BookingListFilter = useMemo(() => {
-    return {
-      page: pagination.pageIndex + 1,
-      pageSize: pagination.pageSize,
-      sortBy: "createdAt",
-      sortOrder: "DESC",
-      // React Query cache key per kind selection ("ALL" when unfiltered).
-      tab: kindFilter ?? "ALL",
-      ...(kindFilter ? { bookingType: kindFilter } : {}),
-      // Server-side free-text search (booking ref, customer, contract ref).
-      ...(debouncedQuery.trim() ? { search: debouncedQuery.trim() } : {}),
-      ...(statusFilter.length ? { statuses: statusFilter.join(",") } : {}),
-      ...(directionFilter ? { tradeDirection: directionFilter } : {}),
-      ...(freightTypeFilter ? { freightType: freightTypeFilter } : {}),
-      ...(paymentStatusFilter ? { paymentStatus: paymentStatusFilter } : {}),
-      // Wins over the payment-status select — the queue is by definition PAID.
-      ...(paidUnallocated
-        ? { paymentStatus: "PAID", assignedToSchedule: "false" as const }
-        : {}),
-      ...(ownershipFilter
-        ? { isGovernment: ownershipFilter as "true" | "false" }
-        : {}),
-      ...(originYardFilter ? { originYardId: originYardFilter } : {}),
-      ...(destinationYardFilter
-        ? { destinationYardId: destinationYardFilter }
-        : {}),
-      ...(createdFrom ? { createdFrom: startOfDayIso(createdFrom) } : {}),
-      ...(createdTo ? { createdTo: endOfDayIso(createdTo) } : {}),
-      ...(scheduledFrom ? { scheduledFrom: startOfDayIso(scheduledFrom) } : {}),
-      ...(scheduledTo ? { scheduledTo: endOfDayIso(scheduledTo) } : {}),
-    };
-  }, [
-    pagination.pageIndex,
-    pagination.pageSize,
-    kindFilter,
-    debouncedQuery,
-    statusFilter,
-    directionFilter,
-    freightTypeFilter,
-    paymentStatusFilter,
-    paidUnallocated,
-    ownershipFilter,
-    originYardFilter,
-    destinationYardFilter,
-    createdFrom,
-    createdTo,
-    scheduledFrom,
-    scheduledTo,
-  ]);
-
-  const { data, isLoading, isError, refetch, isFetching } = useBookingList(filter);
-  const primaryAllocateId = allocateIds[0];
-  const { data: allocateBooking } = useBookingDetail(
-    allocateOpen ? primaryAllocateId : undefined,
-  );
-  const {
-    data: summary,
-    isLoading: summaryLoading,
-    refetch: refetchSummary,
-  } = useBookingListSummary(filter);
-
   // Yard options for the origin/destination filters (shared routes reference list).
   const { data: yardRefs } = useQuery(
     api.routes.yards.queryOptions({ staleTime: 5 * 60_000 }),
@@ -257,43 +123,72 @@ export default function BookingRequestsPage() {
     [yardRefs],
   );
 
-  const resetPage = useCallback(() => {
-    setPagination({ pageIndex: 0, pageSize: pagination.pageSize });
-  }, [setPagination, pagination.pageSize]);
+  // Deep links land here pre-filtered (?statuses=A,B&tradeDirection=IMPORT) —
+  // the header's document-review alarm opens exactly the undecided requests
+  // it is counting down for. No sync effect needed any more: controls.values
+  // reads live off the URL every render, so a link opened while this page is
+  // already mounted just works, and every filter — direction included —
+  // auto-pins its own pill the moment it has a value (FilterBar's `secondary`
+  // split), so a deep link can never land behind "More filters" unseen.
+  const bookingFilterDefs: FilterDef[] = useMemo(
+    () => [
+      { key: "bookingType", label: "Kind", type: "enum", multiple: false, options: BOOKING_KIND_OPTIONS },
+      { key: "statuses", label: "Status", type: "enum", options: STATUS_OPTIONS },
+      {
+        key: "tradeDirection", label: "Direction", type: "enum", multiple: false,
+        options: filterOptions(TRADE_DIRECTION_OPTIONS),
+      },
+      { key: "freightType", label: "Freight", type: "enum", multiple: false, options: FREIGHT_TYPE_OPTIONS },
+      { key: "paymentStatus", label: "Payment", type: "enum", multiple: false, options: PAYMENT_STATUS_OPTIONS, secondary: true },
+      {
+        // Wins over the `paymentStatus` filter above — the queue is by
+        // definition PAID — because it's later in this array: toApiParams
+        // merges defs in order, so a later toParams overwrites an earlier one.
+        key: "paidUnallocated", label: "Allocation", type: "boolean", secondary: true,
+        trueLabel: "Paid, not allocated",
+        toParams: (v) => (v.v[0] === "true" ? { paymentStatus: "PAID", assignedToSchedule: "false" } : {}),
+      },
+      { key: "isGovernment", label: "Ownership", type: "enum", multiple: false, options: OWNERSHIP_OPTIONS, secondary: true },
+      {
+        key: "route", label: "Route", type: "route", options: yardOptions,
+        toParams: ({ v }) => ({ originYardId: v[0], destinationYardId: v[1] }),
+      },
+      {
+        key: "created", label: "Created", type: "date", secondary: true,
+        operators: ["between", "before", "after"],
+        toParams: dateRangeParams("createdFrom", "createdTo"),
+      },
+      {
+        key: "scheduled", label: "Scheduled", type: "date", secondary: true,
+        operators: ["between", "before", "after"],
+        toParams: dateRangeParams("scheduledFrom", "scheduledTo"),
+      },
+    ],
+    [filterOptions, yardOptions],
+  );
 
-  const activeFilterCount =
-    (kindFilter ? 1 : 0) +
-    (statusFilter.length ? 1 : 0) +
-    (directionFilter ? 1 : 0) +
-    (freightTypeFilter ? 1 : 0) +
-    (paymentStatusFilter ? 1 : 0) +
-    (paidUnallocated ? 1 : 0) +
-    (ownershipFilter ? 1 : 0) +
-    (originYardFilter ? 1 : 0) +
-    (destinationYardFilter ? 1 : 0) +
-    (createdFrom || createdTo ? 1 : 0) +
-    (scheduledFrom || scheduledTo ? 1 : 0);
+  const controls = useFilters(bookingFilterDefs, { defaultSort: "createdAt:DESC", pageSize: 10 });
 
-  // Badge on the advanced-filters toggle — active filters hidden behind it.
-  const advancedFilterCount =
-    activeFilterCount - (kindFilter ? 1 : 0) - (statusFilter.length ? 1 : 0);
+  const filter: BookingListFilter = useMemo(
+    () => ({
+      ...(controls.params as unknown as BookingListFilter),
+      // React Query cache key per kind selection ("ALL" when unfiltered) —
+      // kept as a param the API ignores, matching the pre-migration cache key.
+      tab: (controls.values.bookingType?.v[0] as BookingKind | undefined) ?? "ALL",
+    }),
+    [controls.params, controls.values.bookingType],
+  );
 
-  const clearFilters = useCallback(() => {
-    setKindFilter(null);
-    setStatusFilter([]);
-    setDirectionFilter(null);
-    setFreightTypeFilter(null);
-    setPaymentStatusFilter(null);
-    setPaidUnallocated(false);
-    setOwnershipFilter(null);
-    setOriginYardFilter(null);
-    setDestinationYardFilter(null);
-    setCreatedFrom(null);
-    setCreatedTo(null);
-    setScheduledFrom(null);
-    setScheduledTo(null);
-    resetPage();
-  }, [resetPage]);
+  const { data, isLoading, isError, refetch, isFetching } = useBookingList(filter);
+  const primaryAllocateId = allocateIds[0];
+  const { data: allocateBooking } = useBookingDetail(
+    allocateOpen ? primaryAllocateId : undefined,
+  );
+  const {
+    data: summary,
+    isLoading: summaryLoading,
+    refetch: refetchSummary,
+  } = useBookingListSummary(filter);
 
   // Search is applied server-side (via the `search` filter param) — no
   // client-side filtering here.
@@ -303,8 +198,7 @@ export default function BookingRequestsPage() {
   );
 
   const total = data?.total ?? 0;
-  const pageCount = Math.max(1, Math.ceil(total / pagination.pageSize));
-  const hasSearch = query.trim().length > 0;
+  const hasSearch = controls.searchText.trim().length > 0;
   const showEmpty = !isLoading && !isError && rows.length === 0;
 
   const metrics = summary?.metrics;
@@ -585,195 +479,13 @@ export default function BookingRequestsPage() {
 
           <Card p={0}>
             <Stack gap={0}>
-              <Box px="md" pt="md" pb="sm" w="100%">
-                <Stack gap="sm">
-                  <Group gap="sm" wrap="wrap">
-                    <TextInput
-                      placeholder="Search booking, contract or customer…"
-                      leftSection={<Search size={18} />}
-                      value={query}
-                      onChange={(e) => {
-                        setQuery(e.target.value);
-                        resetPage();
-                      }}
-                      rightSection={
-                        query && (
-                          <ActionIcon
-                            size="sm"
-                            color="gray"
-                            radius="md"
-                            variant="transparent"
-                            onClick={() => {
-                              setQuery("");
-                              resetPage();
-                            }}
-                          >
-                            <X size={16} />
-                          </ActionIcon>
-                        )
-                      }
-                      style={{ flex: 1, minWidth: "200px" }}
-                      radius="lg"
-                    />
-                    <Select
-                      placeholder="All booking types"
-                      data={BOOKING_KIND_OPTIONS}
-                      value={kindFilter}
-                      onChange={(v) => {
-                        setKindFilter((v as BookingKind | null) ?? null);
-                        resetPage();
-                      }}
-                      clearable
-                      radius="lg"
-                      style={{ minWidth: 190 }}
-                    />
-                    <MultiSelect
-                      placeholder={statusFilter.length ? undefined : "All statuses"}
-                      data={STATUS_OPTIONS}
-                      value={statusFilter}
-                      onChange={(v) => {
-                        setStatusFilter(v);
-                        resetPage();
-                      }}
-                      clearable
-                      searchable
-                      radius="lg"
-                      style={{ minWidth: 220 }}
-                    />
-                    <FilterToggle
-                      count={advancedFilterCount}
-                      expanded={showAdvanced}
-                      onClick={() => setShowAdvanced((v) => !v)}
-                    />
-                    {activeFilterCount > 0 ? (
-                      <Button
-                        variant="subtle"
-                        color="gray"
-                        radius="lg"
-                        leftSection={<FilterX size={16} />}
-                        onClick={clearFilters}
-                      >
-                        Clear filters ({activeFilterCount})
-                      </Button>
-                    ) : null}
-                  </Group>
-                  <Collapse expanded={showAdvanced}>
-                  <Group gap="sm" wrap="wrap">
-                    <Select
-                      placeholder="All origins"
-                      data={yardOptions}
-                      value={originYardFilter}
-                      onChange={(v) => {
-                        setOriginYardFilter(v);
-                        resetPage();
-                      }}
-                      clearable
-                      searchable
-                      radius="lg"
-                      style={{ minWidth: 180 }}
-                    />
-                    <Select
-                      placeholder="All destinations"
-                      data={yardOptions}
-                      value={destinationYardFilter}
-                      onChange={(v) => {
-                        setDestinationYardFilter(v);
-                        resetPage();
-                      }}
-                      clearable
-                      searchable
-                      radius="lg"
-                      style={{ minWidth: 180 }}
-                    />
-                    <Select
-                      placeholder="All directions"
-                      data={filterOptions(TRADE_DIRECTION_OPTIONS)}
-                      value={directionFilter}
-                      onChange={(v) => {
-                        setDirectionFilter(v);
-                        resetPage();
-                      }}
-                      clearable
-                      radius="lg"
-                      style={{ minWidth: 150 }}
-                    />
-                    <Select
-                      placeholder="All freight types"
-                      data={FREIGHT_TYPE_OPTIONS}
-                      value={freightTypeFilter}
-                      onChange={(v) => {
-                        setFreightTypeFilter(v);
-                        resetPage();
-                      }}
-                      clearable
-                      radius="lg"
-                      style={{ minWidth: 150 }}
-                    />
-                    <Select
-                      placeholder="All payment statuses"
-                      data={PAYMENT_STATUS_OPTIONS}
-                      value={paymentStatusFilter}
-                      onChange={(v) => {
-                        setPaymentStatusFilter(v);
-                        resetPage();
-                      }}
-                      clearable
-                      radius="lg"
-                      style={{ minWidth: 180 }}
-                    />
-                    <Checkbox
-                      label="Paid, not allocated"
-                      checked={paidUnallocated}
-                      onChange={(e) => {
-                        setPaidUnallocated(e.currentTarget.checked);
-                        resetPage();
-                      }}
-                      radius="sm"
-                      style={{ alignSelf: "center" }}
-                    />
-                    <Select
-                      placeholder="Gov / Private"
-                      data={OWNERSHIP_OPTIONS}
-                      value={ownershipFilter}
-                      onChange={(v) => {
-                        setOwnershipFilter(v);
-                        resetPage();
-                      }}
-                      clearable
-                      radius="lg"
-                      style={{ minWidth: 140 }}
-                    />
-                    <DatePickerInput
-                      type="range"
-                      placeholder="Created date range"
-                      value={[createdFrom, createdTo]}
-                      onChange={([from, to]) => {
-                        setCreatedFrom(from ? new Date(from) : null);
-                        setCreatedTo(to ? new Date(to) : null);
-                        resetPage();
-                      }}
-                      presets={getDateRangePresets()}
-                      clearable
-                      radius="lg"
-                      style={{ minWidth: 220 }}
-                    />
-                    <DatePickerInput
-                      type="range"
-                      placeholder="Scheduled date range"
-                      value={[scheduledFrom, scheduledTo]}
-                      onChange={([from, to]) => {
-                        setScheduledFrom(from ? new Date(from) : null);
-                        setScheduledTo(to ? new Date(to) : null);
-                        resetPage();
-                      }}
-                      presets={getDateRangePresets()}
-                      clearable
-                      radius="lg"
-                      style={{ minWidth: 230 }}
-                    />
-                  </Group>
-                  </Collapse>
-                </Stack>
+              <Box px="md" pt="sm" pb="xs" w="100%">
+                <FilterBar
+                  defs={bookingFilterDefs}
+                  controls={controls}
+                  searchPlaceholder="Search booking, contract or customer…"
+                  viewId="booking-requests"
+                />
               </Box>
 
               {showEmpty ? (
@@ -791,18 +503,7 @@ export default function BookingRequestsPage() {
                     data={rows}
                     status={isLoading ? "loading" : isError ? "error" : "success"}
                     onRowClick={handleRowClick}
-                    pagination={{
-                      pageIndex: pagination.pageIndex,
-                      pageSize: pagination.pageSize,
-                      pageCount,
-                      totalCount: total,
-                    }}
-                    tableOptions={{
-                      state: { pagination },
-                      onPaginationChange: setPagination,
-                      manualPagination: true,
-                      pageCount,
-                    }}
+                    {...controls.tableProps(total)}
                     containerClassName="border-0 shadow-none bg-transparent"
                     footer={DataTableFooter}
                   />

apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestsPage.tsx

@@ -3,20 +3,11 @@ import { useMyTradeAccess } from "@/hooks/useMyTradeAccess";
 import {
   ActionIcon,
   Box,
-  Button,
   Card,
-  Collapse,
-  Group,
-  MultiSelect,
-  Select,
   Stack,
   Text,
-  TextInput,
   ThemeIcon,
 } from "@mantine/core";
-import { DatePickerInput } from "@mantine/dates";
-import { getDateRangePresets } from "@/components/common/dateRangePresets";
-import { useDebouncedValue } from "@mantine/hooks";
 import {
   AlertTriangle,
   ArrowRight,
@@ -24,20 +15,18 @@ import {
   CheckCircle2,
   Clock,
   FileText,
-  FilterX,
   Inbox,
   LayoutList,
   RefreshCw,
   Repeat,
-  Search,
   User,
-  X,
 } from "lucide-react";
-import { useCallback, useMemo, useState, type ReactNode } from "react";
+import { useCallback, useMemo, type ReactNode } from "react";
 import { useNavigate } from "react-router-dom";
+import { useQuery } from "@tanstack/react-query";
+import { api } from "@/services/api";
 
 import { ContractStatusBadge } from "@/components/contracts/ContractStatusBadge";
-import { FilterToggle } from "@/components/common/FilterToggle";
 import { bookingTable } from "@/components/bookings/booking-ui.styles";
 import { KpiStrip, PageContainer, PageHeader } from "@/components/page";
 import {
@@ -61,9 +50,9 @@ import {
   Badge,
   DataTable,
   DataTableFooter,
-  usePagination,
   type ColumnDef,
 } from "@edr/ui-common";
+import { FilterBar, dateRangeParams, useFilters, type FilterDef } from "@/components/filters";
 
 /** Every filterable status — the pill tabs are gone, so the select carries them all. */
 const STATUS_OPTIONS = CONTRACT_LIST_TABS.flatMap((t) => t.statuses ?? []).map(
@@ -112,99 +101,91 @@ const COLUMN_META = {
   cellClassName: "whitespace-normal break-words align-top",
 };
 
-/** Local start-of-day → ISO, for inclusive "from" date filters. */
-function startOfDayIso(d: Date): string {
-  const x = new Date(d);
-  x.setHours(0, 0, 0, 0);
-  return x.toISOString();
-}
-
-/** Local end-of-day → ISO, for inclusive "to" date filters. */
-function endOfDayIso(d: Date): string {
-  const x = new Date(d);
-  x.setHours(23, 59, 59, 999);
-  return x.toISOString();
-}
-
 export default function ContractRequestsPage() {
   const navigate = useNavigate();
-  const { pagination, setPagination } = usePagination({ pageSize: 10 });
-  const [query, setQuery] = useState("");
-  const [debouncedQuery] = useDebouncedValue(query, 300);
-  // Filter controls (empty/null = "all").
-  const [statusFilter, setStatusFilter] = useState<string[]>([]);
   const { filterOptions } = useMyTradeAccess();
-  const [directionFilter, setDirectionFilter] = useState<string | null>(null);
-  const [freightTypeFilter, setFreightTypeFilter] = useState<string | null>(
-    null,
+
+  // Yard options for the route filter (shared routes reference list, same
+  // query BookingRequestsPage uses).
+  const { data: yardRefs } = useQuery(
+    api.routes.yards.queryOptions({ staleTime: 5 * 60_000 }),
+  );
+  const yardOptions = useMemo(
+    () => (yardRefs ?? []).map((y) => ({ value: y.id, label: y.label ?? y.code })),
+    [yardRefs],
   );
-  const [kindFilter, setKindFilter] = useState<string | null>(null);
-  const [currencyFilter, setCurrencyFilter] = useState<string | null>(null);
-  const [createdFrom, setCreatedFrom] = useState<Date | null>(null);
-  const [createdTo, setCreatedTo] = useState<Date | null>(null);
-  const [sort, setSort] = useState<string>("createdAt:DESC");
-  // All filters start empty (no URL params on this page), so collapsed is safe.
-  const [showAdvanced, setShowAdvanced] = useState(false);
 
-  const resetPage = useCallback(() => {
-    setPagination({ pageIndex: 0, pageSize: pagination.pageSize });
-  }, [setPagination, pagination.pageSize]);
+  // Static shape only (no facet counts) — this is what useFilters needs to
+  // parse the URL and build API params. Counts are attached separately below,
+  // for rendering only, once the summary query (which itself depends on
+  // these params) has resolved.
+  const filterDefs: FilterDef[] = useMemo(
+    () => [
+      { key: "statuses", label: "Status", type: "enum", options: STATUS_OPTIONS },
+      {
+        key: "contractKind",
+        label: "Kind",
+        type: "enum",
+        multiple: false,
+        options: CONTRACT_KIND_OPTIONS,
+      },
+      {
+        key: "tradeDirection",
+        label: "Direction",
+        type: "enum",
+        multiple: false,
+        options: filterOptions(TRADE_DIRECTION_OPTIONS),
+      },
+      {
+        key: "freightType",
+        label: "Freight",
+        type: "enum",
+        multiple: false,
+        options: FREIGHT_TYPE_OPTIONS,
+      },
+      {
+        key: "paymentCurrency",
+        label: "Currency",
+        type: "enum",
+        multiple: false,
+        options: CURRENCY_OPTIONS,
+        secondary: true,
+      },
+      {
+        key: "created",
+        label: "Created",
+        type: "date",
+        secondary: true,
+        // Before/after are safe to expose: the repository applies
+        // createdFrom/createdTo independently, so a single-sided bound
+        // already works server-side.
+        operators: ["between", "before", "after"],
+        toParams: dateRangeParams("createdFrom", "createdTo"),
+      },
+      {
+        key: "route",
+        label: "Route",
+        type: "route",
+        options: yardOptions,
+        toParams: ({ v }) => ({ originYardId: v[0], destinationYardId: v[1] }),
+      },
+    ],
+    [filterOptions, yardOptions],
+  );
 
-  const filter: ContractListFilter = useMemo(() => {
-    const [sortBy, sortOrder] = sort.split(":") as [string, "ASC" | "DESC"];
-    return {
-      page: pagination.pageIndex + 1,
-      pageSize: pagination.pageSize,
-      sortBy,
-      sortOrder,
+  const controls = useFilters(filterDefs, {
+    defaultSort: "createdAt:DESC",
+    pageSize: 10,
+  });
+
+  const filter: ContractListFilter = useMemo(
+    () => ({
+      ...(controls.params as unknown as ContractListFilter),
       // Kept as the React Query cache-key discriminator (tabs themselves are gone).
       tab: "all",
-      // Server-side free-text search (contract reference, customer name).
-      ...(debouncedQuery.trim() ? { search: debouncedQuery.trim() } : {}),
-      ...(statusFilter.length ? { statuses: statusFilter.join(",") } : {}),
-      ...(directionFilter ? { tradeDirection: directionFilter } : {}),
-      ...(freightTypeFilter ? { freightType: freightTypeFilter } : {}),
-      ...(kindFilter ? { contractKind: kindFilter } : {}),
-      ...(currencyFilter ? { paymentCurrency: currencyFilter } : {}),
-      ...(createdFrom ? { createdFrom: startOfDayIso(createdFrom) } : {}),
-      ...(createdTo ? { createdTo: endOfDayIso(createdTo) } : {}),
-    };
-  }, [
-    pagination.pageIndex,
-    pagination.pageSize,
-    debouncedQuery,
-    statusFilter,
-    directionFilter,
-    freightTypeFilter,
-    kindFilter,
-    currencyFilter,
-    createdFrom,
-    createdTo,
-    sort,
-  ]);
-
-  const activeFilterCount =
-    (statusFilter.length ? 1 : 0) +
-    (directionFilter ? 1 : 0) +
-    (freightTypeFilter ? 1 : 0) +
-    (kindFilter ? 1 : 0) +
-    (currencyFilter ? 1 : 0) +
-    (createdFrom || createdTo ? 1 : 0);
-
-  // Badge on the advanced-filters toggle — active filters hidden behind it.
-  const advancedFilterCount =
-    activeFilterCount - (statusFilter.length ? 1 : 0) - (kindFilter ? 1 : 0);
-
-  const clearFilters = useCallback(() => {
-    setStatusFilter([]);
-    setDirectionFilter(null);
-    setFreightTypeFilter(null);
-    setKindFilter(null);
-    setCurrencyFilter(null);
-    setCreatedFrom(null);
-    setCreatedTo(null);
-    setPagination({ pageIndex: 0, pageSize: pagination.pageSize });
-  }, [setPagination, pagination.pageSize]);
+    }),
+    [controls.params],
+  );
 
   const { data, isLoading, isError, refetch, isFetching } =
     useContractList(filter);
@@ -214,13 +195,27 @@ export default function ContractRequestsPage() {
     refetch: refetchSummary,
   } = useContractListSummary(filter);
 
+  const statusCounts = useMemo(
+    () => Object.fromEntries((summary?.facets?.status ?? []).map((b) => [b.value, b.count])),
+    [summary?.facets],
+  );
+
+  // filterDefs + counts, for the bar to render. Kept separate from filterDefs
+  // itself so the URL-parsing hook above never has to wait on this query.
+  const defs: FilterDef[] = useMemo(
+    () =>
+      filterDefs.map((d) =>
+        d.key === "statuses" && d.type === "enum" ? { ...d, counts: statusCounts } : d,
+      ),
+    [filterDefs, statusCounts],
+  );
+
   const rows = useMemo(
     () => (data?.items ?? []).map(toContractListRow),
     [data?.items],
   );
 
   const total = data?.total ?? 0;
-  const pageCount = Math.max(1, Math.ceil(total / pagination.pageSize));
   const showEmpty = !isLoading && !isError && rows.length === 0;
 
   const metrics = summary?.metrics;
@@ -450,153 +445,14 @@ export default function ContractRequestsPage() {
 
         <Card p={0}>
           <Stack gap={0}>
-            <Box px="md" pt="md" pb="sm" w="100%">
-              <Stack gap="sm">
-                <Group gap="sm" wrap="wrap">
-                  <TextInput
-                    placeholder="Search reference or customer…"
-                    leftSection={<Search size={18} />}
-                    value={query}
-                    onChange={(e) => {
-                      setQuery(e.target.value);
-                      resetPage();
-                    }}
-                    rightSection={
-                      query && (
-                        <ActionIcon
-                          size="sm"
-                          color="gray"
-                          radius="md"
-                          variant="transparent"
-                          onClick={() => {
-                            setQuery("");
-                            resetPage();
-                          }}
-                        >
-                          <X size={16} />
-                        </ActionIcon>
-                      )
-                    }
-                    style={{ flex: 1, minWidth: "200px" }}
-                    radius="lg"
-                  />
-                  <Select
-                    data={SORT_OPTIONS}
-                    value={sort}
-                    onChange={(v) => {
-                      setSort(v ?? "createdAt:DESC");
-                      resetPage();
-                    }}
-                    allowDeselect={false}
-                    radius="lg"
-                    style={{ minWidth: 170 }}
-                    aria-label="Sort contracts"
-                  />
-                  <MultiSelect
-                    placeholder={
-                      statusFilter.length ? undefined : "All statuses"
-                    }
-                    data={STATUS_OPTIONS}
-                    value={statusFilter}
-                    onChange={(v) => {
-                      setStatusFilter(v);
-                      resetPage();
-                    }}
-                    clearable
-                    searchable
-                    radius="lg"
-                    style={{ minWidth: 220 }}
-                    aria-label="Filter by status"
-                  />
-                  <Select
-                    placeholder="All kinds"
-                    data={CONTRACT_KIND_OPTIONS}
-                    value={kindFilter}
-                    onChange={(v) => {
-                      setKindFilter(v);
-                      resetPage();
-                    }}
-                    clearable
-                    radius="lg"
-                    style={{ minWidth: 160 }}
-                    aria-label="Filter by contract kind"
-                  />
-                  <FilterToggle
-                    count={advancedFilterCount}
-                    expanded={showAdvanced}
-                    onClick={() => setShowAdvanced((v) => !v)}
-                  />
-                  {activeFilterCount > 0 ? (
-                    <Button
-                      variant="subtle"
-                      color="gray"
-                      radius="lg"
-                      leftSection={<FilterX size={16} />}
-                      onClick={clearFilters}
-                    >
-                      Clear filters ({activeFilterCount})
-                    </Button>
-                  ) : null}
-                </Group>
-                <Collapse expanded={showAdvanced}>
-                <Group gap="sm" wrap="wrap">
-                  <Select
-                    placeholder="All directions"
-                    data={filterOptions(TRADE_DIRECTION_OPTIONS)}
-                    value={directionFilter}
-                    onChange={(v) => {
-                      setDirectionFilter(v);
-                      resetPage();
-                    }}
-                    clearable
-                    radius="lg"
-                    style={{ minWidth: 150 }}
-                    aria-label="Filter by trade direction"
-                  />
-                  <Select
-                    placeholder="All freight types"
-                    data={FREIGHT_TYPE_OPTIONS}
-                    value={freightTypeFilter}
-                    onChange={(v) => {
-                      setFreightTypeFilter(v);
-                      resetPage();
-                    }}
-                    clearable
-                    radius="lg"
-                    style={{ minWidth: 160 }}
-                    aria-label="Filter by freight type"
-                  />
-                  <Select
-                    placeholder="All currencies"
-                    data={CURRENCY_OPTIONS}
-                    value={currencyFilter}
-                    onChange={(v) => {
-                      setCurrencyFilter(v);
-                      resetPage();
-                    }}
-                    clearable
-                    radius="lg"
-                    style={{ minWidth: 140 }}
-                    aria-label="Filter by payment currency"
-                  />
-                  <DatePickerInput
-                    type="range"
-                    placeholder="Created date range"
-                    value={[createdFrom, createdTo]}
-                    onChange={([from, to]) => {
-                      setCreatedFrom(from ? new Date(from) : null);
-                      setCreatedTo(to ? new Date(to) : null);
-                      resetPage();
-                    }}
-                    presets={getDateRangePresets()}
-                    clearable
-                    radius="lg"
-                    style={{ minWidth: 220 }}
-                    aria-label="Created date range"
-                  />
-                </Group>
-                </Collapse>
-              </Stack>
+            <Box px="md" pt="sm" pb="xs" w="100%">
+              <FilterBar
+                defs={defs}
+                controls={controls}
+                searchPlaceholder="Search reference or customer…"
+                sortOptions={SORT_OPTIONS}
+                viewId="contract-requests"
+              />
             </Box>
 
             {showEmpty ? (
@@ -615,18 +471,7 @@ export default function ContractRequestsPage() {
                     isLoading ? "loading" : isError ? "error" : "success"
                   }
                   onRowClick={handleRowClick}
-                  pagination={{
-                    pageIndex: pagination.pageIndex,
-                    pageSize: pagination.pageSize,
-                    pageCount,
-                    totalCount: total,
-                  }}
-                  tableOptions={{
-                    state: { pagination },
-                    onPaginationChange: setPagination,
-                    manualPagination: true,
-                    pageCount,
-                  }}
+                  {...controls.tableProps(total)}
                   // table-fixed makes the per-column widths stick; without
                   // it auto-layout re-widens columns once cells wrap.
                   containerClassName="border-0 shadow-none bg-transparent [&_table]:table-fixed [&_table]:min-w-[960px]"

apps/edr-freight-web/backoffice/src/pages/customers/CustomersPage.tsx

@@ -5,13 +5,10 @@ import {
   Card,
   Group,
   SegmentedControl,
-  Select,
   Stack,
   Text,
-  TextInput,
   Tooltip,
 } from "@mantine/core";
-import { useDebouncedValue } from "@mantine/hooks";
 import { useQuery } from "@tanstack/react-query";
 import {
   Building2,
@@ -22,10 +19,8 @@ import {
   Mail,
   Phone,
   RefreshCw,
-  Search,
   ShieldOff,
   Users,
-  X,
 } from "lucide-react";
 import { useMemo, useState } from "react";
 import { useNavigate } from "react-router-dom";
@@ -40,12 +35,8 @@ import { KpiStrip, PageContainer, PageHeader } from "@/components/page";
 import { api } from "@/services/api";
 import type { Company, CompanyStatus } from "@/types/customer";
 import { isOnboardingDraft } from "@/types/customer";
-import {
-  DataTable,
-  DataTableFooter,
-  usePagination,
-  type ColumnDef,
-} from "@edr/ui-common";
+import { DataTable, DataTableFooter, type ColumnDef } from "@edr/ui-common";
+import { FilterBar, useFilters, type FilterDef } from "@/components/filters";
 
 /**
  * The list's segmented views. "Pending approval" means submitted-and-awaiting-
@@ -92,28 +83,29 @@ const SORT_OPTIONS = [
   { value: "name:DESC", label: "Name (Z–A)" },
 ] as const;
 
+/** No filter pills — search/sort/page are the only real filter dimensions;
+ * `view` below is a tab (mutually exclusive, navigational), not a filter. */
+const NO_FILTER_DEFS: FilterDef[] = [];
+
 export default function CustomersPage() {
   const navigate = useNavigate();
-  const { pagination, setPagination } = usePagination({ pageSize: 10 });
-  const [query, setQuery] = useState("");
-  const [debouncedQuery] = useDebouncedValue(query, 300);
   const [view, setView] = useState<CustomerView>("all");
-  const [sort, setSort] = useState<string>("review:DESC");
+  const controls = useFilters(NO_FILTER_DEFS, { defaultSort: "review:DESC", pageSize: 10 });
 
   const filter = useMemo(() => {
-    const [sortBy, sortOrder] = sort.split(":") as [
+    const [sortBy, sortOrder] = controls.sort.split(":") as [
       "review" | "name" | "createdAt" | "updatedAt",
       "ASC" | "DESC",
     ];
     return {
-      page: pagination.pageIndex + 1,
-      pageSize: pagination.pageSize,
-      search: debouncedQuery,
+      page: controls.page,
+      pageSize: controls.pageSize,
+      search: String(controls.params.search ?? ""),
       sortBy,
       sortOrder,
       ...VIEW_FILTERS[view],
     };
-  }, [pagination.pageIndex, pagination.pageSize, debouncedQuery, view, sort]);
+  }, [controls.page, controls.pageSize, controls.params.search, controls.sort, view]);
 
   const { data: stats } = useQuery(
     api.customers.stats.queryOptions({ input: {} }),
@@ -125,7 +117,6 @@ export default function CustomersPage() {
 
   const rows = data?.items ?? [];
   const total = data?.total ?? 0;
-  const pageCount = Math.max(1, Math.ceil(total / pagination.pageSize));
 
   const columns: ColumnDef<Company>[] = useMemo(
     () => [
@@ -295,35 +286,24 @@ export default function CustomersPage() {
       <Card p={0}>
         <Stack gap={0}>
           <Box px="md" pt="md" pb="sm" w="100%">
-            <Group justify="space-between" gap="md" wrap="wrap">
-              <TextInput
-                placeholder="Search by company, TIN, email or profile reference…"
-                leftSection={<Search size={18} />}
-                value={query}
-                onChange={(e) => setQuery(e.target.value)}
-                rightSection={
-                  query ? (
-                    <ActionIcon
-                      size="sm"
-                      color="gray"
-                      radius="md"
-                      variant="transparent"
-                      onClick={() => setQuery("")}
-                    >
-                      <X size={16} />
-                    </ActionIcon>
-                  ) : null
-                }
-                style={{ flex: 1, minWidth: "240px" }}
-                radius="lg"
-              />
+            <FilterBar
+              defs={NO_FILTER_DEFS}
+              controls={controls}
+              searchPlaceholder="Search by company, TIN, email or profile reference…"
+              sortOptions={SORT_OPTIONS.map((o) => ({ ...o }))}
+              viewId="customers"
+            >
               <SegmentedControl
                 size="sm"
                 radius="md"
                 value={view}
                 onChange={(v) => {
+                  // `view` lives outside useFilters (it's a tab, not a
+                  // filter pill), so switching it needs its own page reset —
+                  // the same "stranded on page 5" hazard useFilters guards
+                  // against for its own filters.
                   setView(v as CustomerView);
-                  setPagination((prev) => ({ ...prev, pageIndex: 0 }));
+                  controls.setPage(1);
                 }}
                 data={[
                   { label: "All", value: "all" },
@@ -333,21 +313,7 @@ export default function CustomersPage() {
                   { label: "Active", value: "active" },
                 ]}
               />
-              <Select
-                size="sm"
-                radius="md"
-                w={160}
-                allowDeselect={false}
-                aria-label="Sort customers"
-                value={sort}
-                onChange={(v) => {
-                  if (!v) return;
-                  setSort(v);
-                  setPagination((prev) => ({ ...prev, pageIndex: 0 }));
-                }}
-                data={SORT_OPTIONS.map((o) => ({ ...o }))}
-              />
-            </Group>
+            </FilterBar>
           </Box>
 
           <Box style={{ overflowX: "auto" }} w="100%">
@@ -358,7 +324,7 @@ export default function CustomersPage() {
                 status={isLoading ? "loading" : isError ? "error" : "success"}
                 onRowClick={(row) => navigate(`/dashboard/customers/${row.id}`)}
                 emptyMessage={
-                  debouncedQuery
+                  controls.searchText
                     ? "No companies match your search."
                     : "No companies yet."
                 }
@@ -370,18 +336,7 @@ export default function CustomersPage() {
                     }
                     : undefined
                 }
-                pagination={{
-                  pageIndex: pagination.pageIndex,
-                  pageSize: pagination.pageSize,
-                  pageCount,
-                  totalCount: total,
-                }}
-                tableOptions={{
-                  state: { pagination },
-                  onPaginationChange: setPagination,
-                  manualPagination: true,
-                  pageCount,
-                }}
+                {...controls.tableProps(total)}
                 containerClassName="border-0 shadow-none bg-transparent"
                 footer={DataTableFooter}
               />

apps/edr-freight-web/backoffice/src/pages/fleet/CompliancePage.tsx

@@ -18,11 +18,16 @@ import {
 } from "@mantine/core";
 import { Plus, AlertTriangle } from "lucide-react";
 import Breadcrumbs from "@/components/ui/Breadcrumbs";
-import ListControls from "@/components/common/ListControls";
 // Generic list footer — already shared by the fleet and train-scheduling lists
 // despite the ruleEngine path.
 import RuleEngineListFooter from "@/components/ruleEngine/RuleEngineListFooter";
-import { useListControls } from "@/hooks/useListControls";
+import {
+  applyClientFilters,
+  FilterBar,
+  toRuleEngineFooterProps,
+  useFilters,
+  type FilterDef,
+} from "@/components/filters";
 import { useToast } from "@/hooks/use-toast";
 import {
   complianceService,
@@ -52,6 +57,8 @@ const statusColor = (status: ComplianceRecord["status"]) => {
 const formatDate = (value?: string | null) =>
   value ? new Date(value).toLocaleDateString() : "—";
 
+const COMPLIANCE_FILTER_DEFS: FilterDef[] = [{ key: "expiryDate", label: "Expiry", type: "date" }];
+
 const emptyForm = {
   vehicleId: "",
   type: "INSPECTION" as ComplianceType,
@@ -91,10 +98,18 @@ export default function CompliancePage() {
     },
   });
 
-  const controls = useListControls(records as ComplianceRecord[], {
-    searchKeys: ["type", "status", "documentNumber"],
-    dateKey: "expiryDate",
-  });
+  const controls = useFilters(COMPLIANCE_FILTER_DEFS, { pageSize: 10 });
+  const filteredRecords = applyClientFilters(
+    records as ComplianceRecord[],
+    COMPLIANCE_FILTER_DEFS,
+    controls.values,
+    controls.searchText,
+    { searchKeys: ["type", "status", "documentNumber"] },
+  );
+  const pagedRecords = filteredRecords.slice(
+    (controls.page - 1) * controls.pageSize,
+    controls.page * controls.pageSize,
+  );
 
   const createMutation = useMutation({
     mutationFn: async (data: typeof formData) => {
@@ -220,17 +235,11 @@ export default function CompliancePage() {
         Compliance Records
       </Title>
       <Card withBorder>
-        <ListControls
-          search={controls.search}
-          onSearchChange={controls.setSearch}
+        <FilterBar
+          defs={COMPLIANCE_FILTER_DEFS}
+          controls={controls}
           searchPlaceholder="Search type, status, document no…"
-          dateFrom={controls.dateFrom}
-          onDateFromChange={controls.setDateFrom}
-          dateTo={controls.dateTo}
-          onDateToChange={controls.setDateTo}
-          dateLabel="Expiry"
-          hasFilters={controls.hasFilters}
-          onReset={controls.reset}
+          viewId="fleet-compliance"
         />
         <Table striped highlightOnHover>
           <Table.Thead>
@@ -261,7 +270,7 @@ export default function CompliancePage() {
                 </Table.Td>
               </Table.Tr>
             ) : null}
-            {controls.pagedRows.map((record) => (
+            {pagedRecords.map((record) => (
               <Table.Tr key={record.id}>
                 <Table.Td>{vehicleLabel(record)}</Table.Td>
                 <Table.Td>
@@ -282,11 +291,8 @@ export default function CompliancePage() {
           </Table.Tbody>
         </Table>
         <RuleEngineListFooter
-          pagination={controls.pagination}
-          pageCount={controls.pageCount}
-          totalCount={controls.totalCount}
           itemLabel="records"
-          onPaginationChange={controls.setPagination}
+          {...toRuleEngineFooterProps(controls, filteredRecords.length)}
         />
       </Card>
 

apps/edr-freight-web/backoffice/src/pages/fleet/FleetCrudPages.tsx

@@ -1,5 +1,5 @@
 import { useMutation, useQuery } from '@tanstack/react-query';
-import { Edit, Eye, Plus, Search, Trash2 } from 'lucide-react';
+import { Edit, Eye, Plus, Trash2 } from 'lucide-react';
 import { FormEvent, ReactNode, useMemo, useState } from 'react';
 
 import { api } from '@/services/api';
@@ -44,6 +44,13 @@ import type { Train } from '@/services/trains.service';
 import type { WagonType } from '@/services/wagon-types.service';
 import type { Wagon } from '@/services/wagon.service';
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@edr/ui-common';
+import {
+    applyClientFilters,
+    FilterBar,
+    useFilters,
+    type FilterDef,
+    type FilterOption,
+} from '@/components/filters';
 
 type FormValue = string | number | boolean | string[];
 
@@ -86,6 +93,8 @@ type FleetCrudPageProps<T extends { id: string }> = {
   hideViewAction?: boolean;
   /** Optional custom actions rendered before the view/edit/delete buttons in each row. */
   rowActions?: (item: T) => React.ReactNode;
+  /** Enables the Status filter pill; the item's `status` field is matched against these. */
+  statusOptions?: FilterOption[];
 };
 
 const normalizePayload = (values: Record<string, FormValue>) =>
@@ -172,9 +181,16 @@ function FleetCrudPage<T extends { id: string }>({
   removeSuccessMessage,
   hideViewAction = false,
   rowActions,
+  statusOptions,
 }: FleetCrudPageProps<T>) {
-  const [search, setSearch] = useState('');
-  const [page, setPage] = useState(1);
+  const filterDefs: FilterDef[] = useMemo(
+    () =>
+      statusOptions
+        ? [{ key: 'status', label: 'Status', type: 'enum', multiple: false, options: statusOptions }]
+        : [],
+    [statusOptions],
+  );
+  const controls = useFilters(filterDefs, { pageSize: 10 });
   const [sortKey, setSortKey] = useState<string>('');
   const [sortDirection, setSortDirection] = useState<'asc' | 'desc'>('asc');
   const [formOpen, setFormOpen] = useState(false);
@@ -184,11 +200,13 @@ function FleetCrudPage<T extends { id: string }>({
   const [fieldErrors, setFieldErrors] = useState<Record<string, string>>({});
   const { toast } = useToast();
 
-  const filtered = useMemo(() => {
-    const query = search.trim().toLowerCase();
-    if (!query) return data ?? [];
-    return (data ?? []).filter((item) => searchText(item).toLowerCase().includes(query));
-  }, [data, search, searchText]);
+  const filtered = useMemo(
+    () =>
+      applyClientFilters(data ?? [], filterDefs, controls.values, controls.searchText, {
+        searchValue: searchText,
+      }),
+    [data, filterDefs, controls.values, controls.searchText, searchText],
+  );
   const sorted = useMemo(() => {
     if (!sortKey) return filtered;
     return [...filtered].sort((a, b) => {
@@ -198,12 +216,13 @@ function FleetCrudPage<T extends { id: string }>({
       return sortDirection === 'asc' ? result : -result;
     });
   }, [filtered, sortDirection, sortKey]);
-  const pageSize = 10;
+  const pageSize = controls.pageSize;
+  const page = controls.page;
   const pageCount = Math.max(1, Math.ceil(sorted.length / pageSize));
   const paged = sorted.slice((page - 1) * pageSize, page * pageSize);
 
   const toggleSort = (key: string) => {
-    setPage(1);
+    controls.setPage(1);
     if (sortKey === key) {
       setSortDirection((current) => (current === 'asc' ? 'desc' : 'asc'));
       return;
@@ -298,18 +317,11 @@ function FleetCrudPage<T extends { id: string }>({
         </Button>
       </div>
 
-      <div className="flex max-w-md items-center gap-2 rounded-md border bg-background px-3">
-        <Search className="size-4 text-muted-foreground" />
-        <Input
-          className="border-0 px-0 shadow-none focus-visible:ring-0"
-          placeholder={`Search ${title.toLowerCase()}`}
-          value={search}
-          onChange={(event) => {
-            setSearch(event.target.value);
-            setPage(1);
-          }}
-        />
-      </div>
+      <FilterBar
+        defs={filterDefs}
+        controls={controls}
+        searchPlaceholder={`Search ${title.toLowerCase()}`}
+      />
 
       <div className="overflow-hidden rounded-lg border bg-card">
         <Table>
@@ -379,10 +391,10 @@ function FleetCrudPage<T extends { id: string }>({
           Showing {sorted.length === 0 ? 0 : (page - 1) * pageSize + 1}-{Math.min(page * pageSize, sorted.length)} of {sorted.length}
         </span>
         <div className="flex gap-2">
-          <Button variant="outline" size="sm" disabled={page === 1} onClick={() => setPage((current) => current - 1)}>
+          <Button variant="outline" size="sm" disabled={page === 1} onClick={() => controls.setPage(page - 1)}>
             Previous
           </Button>
-          <Button variant="outline" size="sm" disabled={page === pageCount} onClick={() => setPage((current) => current + 1)}>
+          <Button variant="outline" size="sm" disabled={page === pageCount} onClick={() => controls.setPage(page + 1)}>
             Next
           </Button>
         </div>
@@ -487,6 +499,47 @@ const statusBadge = (status?: string) => <Badge variant="outline">{status ?? '-'
 const optionLabel = (options: { value: string; label: string }[], value?: string | null) =>
   options.find((option) => option.value === value)?.label ?? value ?? '-';
 
+const TRAIN_STATUS_OPTIONS: FilterOption[] = [
+  { value: 'AVAILABLE', label: 'Available' },
+  { value: 'SCHEDULED', label: 'Scheduled' },
+  { value: 'IN_SERVICE', label: 'In service' },
+  { value: 'UNDER_MAINTENANCE', label: 'Under maintenance' },
+  { value: 'OUT_OF_SERVICE', label: 'Out of service' },
+  { value: 'DEACTIVATED', label: 'Deactivated' },
+];
+
+const WAGON_STATUS_OPTIONS: FilterOption[] = [
+  { value: 'AVAILABLE', label: 'Available' },
+  { value: 'IMPORT_READY', label: 'Import ready' },
+  { value: 'EXPORT_READY', label: 'Export ready' },
+  { value: 'ASSIGNED', label: 'Assigned' },
+  { value: 'MAINTENANCE', label: 'Maintenance' },
+  { value: 'DETAINED', label: 'Detained' },
+];
+
+const CONTAINER_STATUS_OPTIONS: FilterOption[] = [
+  { value: 'AVAILABLE', label: 'Available' },
+  { value: 'LOADED', label: 'Loaded' },
+  { value: 'IN_TRANSIT', label: 'In transit' },
+  { value: 'MAINTENANCE', label: 'Maintenance' },
+  { value: 'DAMAGED', label: 'Damaged' },
+];
+
+const CARGO_STATUS_OPTIONS: FilterOption[] = [
+  { value: 'PENDING', label: 'Pending' },
+  { value: 'LOADED', label: 'Loaded' },
+  { value: 'IN_TRANSIT', label: 'In transit' },
+  { value: 'DELIVERED', label: 'Delivered' },
+  { value: 'UNLOADED', label: 'Unloaded' },
+];
+
+const LOCOMOTIVE_STATUS_OPTIONS: FilterOption[] = [
+  { value: 'AVAILABLE', label: 'Available' },
+  { value: 'MAINTENANCE', label: 'Maintenance' },
+  { value: 'ASSIGNED', label: 'Assigned' },
+  { value: 'OUT_OF_SERVICE', label: 'Out of service' },
+];
+
 export function TrainMasterDataPage() {
   const query = useQuery(api.trains.list.queryOptions());
   return (
@@ -499,6 +552,7 @@ export function TrainMasterDataPage() {
       create={useMutation(api.trains.create.mutationOptions())}
       update={useMutation(api.trains.update.mutationOptions())}
       remove={useMutation(api.trains.remove.mutationOptions())}
+      statusOptions={TRAIN_STATUS_OPTIONS}
       searchText={(train) => [train.code, train.trainNumber, train.trainName, train.status].join(' ')}
       columns={[
         { key: 'code', label: 'Code' },
@@ -522,14 +576,17 @@ export function TrainMasterDataPage() {
   );
 }
 
+const WAGON_TYPE_FILTER_DEFS: FilterDef[] = [
+  { key: 'isActive', label: 'Status', type: 'boolean', trueLabel: 'Active', falseLabel: 'Inactive' },
+];
+
 export function WagonTypesCrudPage() {
   const query = useQuery(api.wagonTypes.list.queryOptions());
   const create = useMutation(api.wagonTypes.create.mutationOptions());
   const update = useMutation(api.wagonTypes.update.mutationOptions());
   const remove = useMutation(api.wagonTypes.remove.mutationOptions());
   const { toast } = useToast();
-  const [search, setSearch] = useState('');
-  const [page, setPage] = useState(1);
+  const controls = useFilters(WAGON_TYPE_FILTER_DEFS, { pageSize: 10 });
   const [sortKey, setSortKey] = useState<keyof WagonType>('code');
   const [sortDirection, setSortDirection] = useState<'asc' | 'desc'>('asc');
   const [formOpen, setFormOpen] = useState(false);
@@ -546,18 +603,15 @@ export function WagonTypesCrudPage() {
   });
   const [fieldErrors, setFieldErrors] = useState<Record<string, string>>({});
 
-  const pageSize = 10;
-  const filtered = useMemo(() => {
-    const queryText = search.trim().toLowerCase();
-    const rows = query.data ?? [];
-    if (!queryText) return rows;
-    return rows.filter((type) =>
-      [type.code, type.name, type.supportedLoadTypes?.join(' '), type.isActive ? 'active' : 'inactive']
-        .join(' ')
-        .toLowerCase()
-        .includes(queryText),
-    );
-  }, [query.data, search]);
+  const pageSize = controls.pageSize;
+  const page = controls.page;
+  const filtered = useMemo(
+    () =>
+      applyClientFilters(query.data ?? [], WAGON_TYPE_FILTER_DEFS, controls.values, controls.searchText, {
+        searchValue: (type) => [type.code, type.name, type.supportedLoadTypes?.join(' ')].join(' '),
+      }),
+    [query.data, controls.values, controls.searchText],
+  );
 
   const sorted = useMemo(() => {
     return [...filtered].sort((left, right) => {
@@ -573,7 +627,7 @@ export function WagonTypesCrudPage() {
   const isSaving = create.isPending || update.isPending;
 
   const toggleSort = (key: keyof WagonType) => {
-    setPage(1);
+    controls.setPage(1);
     if (sortKey === key) {
       setSortDirection((current) => (current === 'asc' ? 'desc' : 'asc'));
       return;
@@ -689,16 +743,7 @@ export function WagonTypesCrudPage() {
           </MantineButton>
         </Group>
 
-        <TextInput
-          maw={420}
-          leftSection={<Search size={16} />}
-          placeholder="Search wagon types"
-          value={search}
-          onChange={(event) => {
-            setSearch(event.currentTarget.value);
-            setPage(1);
-          }}
-        />
+        <FilterBar defs={WAGON_TYPE_FILTER_DEFS} controls={controls} searchPlaceholder="Search wagon types" />
 
         <Paper withBorder radius="md">
           <ScrollArea>
@@ -789,7 +834,7 @@ export function WagonTypesCrudPage() {
             Showing {sorted.length === 0 ? 0 : (page - 1) * pageSize + 1}-{Math.min(page * pageSize, sorted.length)} of{' '}
             {sorted.length}
           </Text>
-          <Pagination total={pageCount} value={page} onChange={setPage} size="sm" />
+          <Pagination total={pageCount} value={page} onChange={controls.setPage} size="sm" />
         </Group>
       </Stack>
 
@@ -906,6 +951,7 @@ export function WagonsCrudPage() {
       create={useMutation(api.wagons.create.mutationOptions())}
       update={useMutation(api.wagons.update.mutationOptions())}
       remove={useMutation(api.wagons.remove.mutationOptions())}
+      statusOptions={WAGON_STATUS_OPTIONS}
       searchText={(wagon) => [
         wagon.wagonNumber,
         wagon.wagonTypeId,
@@ -959,14 +1005,7 @@ export function WagonsCrudPage() {
           key: 'status',
           label: 'Status',
           type: 'select',
-          options: [
-            { value: 'AVAILABLE', label: 'Available' },
-            { value: 'IMPORT_READY', label: 'Import ready' },
-            { value: 'EXPORT_READY', label: 'Export ready' },
-            { value: 'ASSIGNED', label: 'Assigned' },
-            { value: 'MAINTENANCE', label: 'Maintenance' },
-            { value: 'DETAINED', label: 'Detained' },
-          ],
+          options: WAGON_STATUS_OPTIONS,
         },
         { key: 'notes', label: 'Notes' },
       ]}
@@ -999,6 +1038,7 @@ export function ContainersCrudPage() {
       create={useMutation(api.containers.create.mutationOptions())}
       update={useMutation(api.containers.update.mutationOptions())}
       remove={useMutation(api.containers.remove.mutationOptions())}
+      statusOptions={CONTAINER_STATUS_OPTIONS}
       searchText={(container) => [container.containerNumber, container.containerTypeId, container.wagonId, container.status].join(' ')}
       columns={[
         { key: 'containerNumber', label: 'Number' },
@@ -1058,6 +1098,7 @@ export function CargoesCrudPage() {
       create={useMutation(api.cargoes.create.mutationOptions())}
       update={useMutation(api.cargoes.update.mutationOptions())}
       remove={useMutation(api.cargoes.remove.mutationOptions())}
+      statusOptions={CARGO_STATUS_OPTIONS}
       searchText={(cargo) => [cargo.cargoReference, cargo.description, cargo.containerId, cargo.status].join(' ')}
       columns={[
         { key: 'cargoReference', label: 'Reference' },
@@ -1122,6 +1163,7 @@ export function LocomotivesCrudPage() {
       removeActionLabel="Decommission"
       removeConfirmMessage="Decommission this locomotive?"
       removeSuccessMessage="Locomotive decommissioned"
+      statusOptions={LOCOMOTIVE_STATUS_OPTIONS}
       searchText={(locomotive) =>
         [
           locomotive.code,
@@ -1166,12 +1208,7 @@ export function LocomotivesCrudPage() {
           label: 'Status',
           type: 'select',
           required: true,
-          options: [
-            { value: 'AVAILABLE', label: 'Available' },
-            { value: 'MAINTENANCE', label: 'Maintenance' },
-            { value: 'ASSIGNED', label: 'Assigned' },
-            { value: 'OUT_OF_SERVICE', label: 'Out of service' },
-          ],
+          options: LOCOMOTIVE_STATUS_OPTIONS,
         },
         { key: 'maxPullWeightTons', label: 'Max pulling weight (tons)', type: 'number', required: true },
         { key: 'maxTrainLengthMeters', label: 'Max train length (meters)', type: 'number', required: true },

apps/edr-freight-web/backoffice/src/pages/fleet/FuelPurchasePage.tsx

@@ -19,11 +19,16 @@ import {
 } from "@mantine/core";
 import { Plus } from "lucide-react";
 import Breadcrumbs from "@/components/ui/Breadcrumbs";
-import ListControls from "@/components/common/ListControls";
 // Generic list footer — already shared by the fleet and train-scheduling lists
 // despite the ruleEngine path.
 import RuleEngineListFooter from "@/components/ruleEngine/RuleEngineListFooter";
-import { useListControls } from "@/hooks/useListControls";
+import {
+  applyClientFilters,
+  FilterBar,
+  toRuleEngineFooterProps,
+  useFilters,
+  type FilterDef,
+} from "@/components/filters";
 import { useToast } from "@/hooks/use-toast";
 import { api } from "@/auth/http";
 import { QUERY_KEYS } from "@/constants/QUERY_KEYS";
@@ -45,6 +50,8 @@ interface FuelPurchase {
 }
 
 
+const FUEL_FILTER_DEFS: FilterDef[] = [{ key: "purchaseDate", label: "Purchased", type: "date" }];
+
 export default function FuelPurchasePage() {
   const { toast } = useToast();
   const qc = useQueryClient();
@@ -123,10 +130,18 @@ export default function FuelPurchasePage() {
   const totalCost = formData.liters * formData.costPerLiter;
 
   // Aggregate stats (guarded against divide-by-zero when there are no purchases)
-  const controls = useListControls(purchasesData as FuelPurchase[], {
-    searchKeys: ["fuelStation", "paymentMethod"],
-    dateKey: "purchaseDate",
-  });
+  const controls = useFilters(FUEL_FILTER_DEFS, { pageSize: 10 });
+  const filteredPurchases = applyClientFilters(
+    purchasesData as FuelPurchase[],
+    FUEL_FILTER_DEFS,
+    controls.values,
+    controls.searchText,
+    { searchKeys: ["fuelStation", "paymentMethod"] },
+  );
+  const pagedPurchases = filteredPurchases.slice(
+    (controls.page - 1) * controls.pageSize,
+    controls.page * controls.pageSize,
+  );
 
   const totalLiters = (purchasesData as FuelPurchase[]).reduce(
     (sum, p) => sum + Number(p.liters),
@@ -195,17 +210,11 @@ export default function FuelPurchasePage() {
 
       {/* Purchases Table */}
       <Card withBorder>
-        <ListControls
-          search={controls.search}
-          onSearchChange={controls.setSearch}
+        <FilterBar
+          defs={FUEL_FILTER_DEFS}
+          controls={controls}
           searchPlaceholder="Search station or payment method…"
-          dateFrom={controls.dateFrom}
-          onDateFromChange={controls.setDateFrom}
-          dateTo={controls.dateTo}
-          onDateToChange={controls.setDateTo}
-          dateLabel="Purchased"
-          hasFilters={controls.hasFilters}
-          onReset={controls.reset}
+          viewId="fleet-fuel-purchases"
         />
         <Table striped highlightOnHover>
           <Table.Thead>
@@ -237,7 +246,7 @@ export default function FuelPurchasePage() {
                 </Table.Td>
               </Table.Tr>
             ) : null}
-            {controls.pagedRows.map((purchase) => (
+            {pagedPurchases.map((purchase) => (
               <Table.Tr key={purchase.id}>
                 <Table.Td>{(purchase as any).vehicle?.registrationNumber || (purchase as any).vehicle?.plateNumber || purchase.vehicleId}</Table.Td>
                 <Table.Td>{new Date(purchase.purchaseDate).toLocaleDateString()}</Table.Td>
@@ -253,11 +262,8 @@ export default function FuelPurchasePage() {
           </Table.Tbody>
         </Table>
         <RuleEngineListFooter
-          pagination={controls.pagination}
-          pageCount={controls.pageCount}
-          totalCount={controls.totalCount}
           itemLabel="purchases"
-          onPaginationChange={controls.setPagination}
+          {...toRuleEngineFooterProps(controls, filteredPurchases.length)}
         />
       </Card>
 

apps/edr-freight-web/backoffice/src/pages/fleet/IncidentsPage.tsx

@@ -20,11 +20,16 @@ import {
 } from "@mantine/core";
 import { Plus } from "lucide-react";
 import Breadcrumbs from "@/components/ui/Breadcrumbs";
-import ListControls from "@/components/common/ListControls";
 // Generic list footer — already shared by the fleet and train-scheduling lists
 // despite the ruleEngine path.
 import RuleEngineListFooter from "@/components/ruleEngine/RuleEngineListFooter";
-import { useListControls } from "@/hooks/useListControls";
+import {
+  applyClientFilters,
+  FilterBar,
+  toRuleEngineFooterProps,
+  useFilters,
+  type FilterDef,
+} from "@/components/filters";
 import { useToast } from "@/hooks/use-toast";
 import {
   incidentsService,
@@ -89,6 +94,8 @@ const initialForm = {
   reportedBy: "",
 };
 
+const INCIDENT_FILTER_DEFS: FilterDef[] = [{ key: "occurredAt", label: "Occurred", type: "date" }];
+
 export default function IncidentsPage() {
   const { toast } = useToast();
   const qc = useQueryClient();
@@ -166,10 +173,18 @@ export default function IncidentsPage() {
     })) || [];
 
   const incidents = incidentsData as Incident[];
-  const controls = useListControls(incidents, {
-    searchKeys: ["type", "severity", "status"],
-    dateKey: "occurredAt",
-  });
+  const controls = useFilters(INCIDENT_FILTER_DEFS, { pageSize: 10 });
+  const filteredIncidents = applyClientFilters(
+    incidents,
+    INCIDENT_FILTER_DEFS,
+    controls.values,
+    controls.searchText,
+    { searchKeys: ["type", "severity", "status"] },
+  );
+  const pagedIncidents = filteredIncidents.slice(
+    (controls.page - 1) * controls.pageSize,
+    controls.page * controls.pageSize,
+  );
   const totalCount = incidents.length;
   const openCount = incidents.filter((i) => OPEN_STATUSES.includes(i.status)).length;
   const underReviewCount = incidents.filter((i) => i.status === "UNDER_REVIEW").length;
@@ -246,17 +261,11 @@ export default function IncidentsPage() {
 
       {/* Incidents Table */}
       <Card withBorder>
-        <ListControls
-          search={controls.search}
-          onSearchChange={controls.setSearch}
+        <FilterBar
+          defs={INCIDENT_FILTER_DEFS}
+          controls={controls}
           searchPlaceholder="Search type, severity, status…"
-          dateFrom={controls.dateFrom}
-          onDateFromChange={controls.setDateFrom}
-          dateTo={controls.dateTo}
-          onDateToChange={controls.setDateTo}
-          dateLabel="Occurred"
-          hasFilters={controls.hasFilters}
-          onReset={controls.reset}
+          viewId="fleet-incidents"
         />
         <Table striped highlightOnHover>
           <Table.Thead>
@@ -288,7 +297,7 @@ export default function IncidentsPage() {
                 </Table.Td>
               </Table.Tr>
             ) : null}
-            {controls.pagedRows.map((incident) => (
+            {pagedIncidents.map((incident) => (
               <Table.Tr key={incident.id}>
                 <Table.Td>{new Date(incident.occurredAt).toLocaleDateString()}</Table.Td>
                 <Table.Td>
@@ -316,11 +325,8 @@ export default function IncidentsPage() {
           </Table.Tbody>
         </Table>
         <RuleEngineListFooter
-          pagination={controls.pagination}
-          pageCount={controls.pageCount}
-          totalCount={controls.totalCount}
           itemLabel="incidents"
-          onPaginationChange={controls.setPagination}
+          {...toRuleEngineFooterProps(controls, filteredIncidents.length)}
         />
       </Card>
 

apps/edr-freight-web/backoffice/src/pages/warehouses/LoadedInventoryPage.tsx

@@ -1,7 +1,6 @@
 import { Badge, Card, Group, Text } from '@mantine/core';
 import { DataTable, type ColumnDef } from '@edr/ui-common';
-import ListControls from '@/components/common/ListControls';
-import { useListControls } from '@/hooks/useListControls';
+import { applyClientFilters, FilterBar, useFilters, type FilterDef } from '@/components/filters';
 
 import { PageContainer, PageHeader } from '@/components/page';
 import { useQuery } from '@tanstack/react-query';
@@ -63,16 +62,27 @@ const columns: ColumnDef<Loading>[] = [
   },
 ];
 
+const LOADING_FILTER_DEFS: FilterDef[] = [{ key: 'loadedAt', label: 'Loaded', type: 'date' }];
+
 /** Record of every inventory item loaded onto a wagon. */
 export default function LoadedInventoryPage() {
   const { data, isLoading } = useQuery(
     api.warehouses.loadings.queryOptions({ input: {} }),
   );
   const loadings = data ?? [];
-  const controls = useListControls(loadings, {
-    searchKeys: ['wagonNumber'],
-    dateKey: 'loadedAt',
-  });
+  const controls = useFilters(LOADING_FILTER_DEFS, { pageSize: 10 });
+  // Endpoint takes no params at all — everything filters client-side.
+  const filteredLoadings = applyClientFilters(
+    loadings,
+    LOADING_FILTER_DEFS,
+    controls.values,
+    controls.searchText,
+    { searchKeys: ['wagonNumber'] },
+  );
+  const pagedLoadings = filteredLoadings.slice(
+    (controls.page - 1) * controls.pageSize,
+    controls.page * controls.pageSize,
+  );
 
   return (
     <PageContainer>
@@ -90,24 +100,18 @@ export default function LoadedInventoryPage() {
           />
         ) : (
           <>
-            <ListControls
-              search={controls.search}
-              onSearchChange={controls.setSearch}
+            <FilterBar
+              defs={LOADING_FILTER_DEFS}
+              controls={controls}
               searchPlaceholder="Search by wagon…"
-              dateFrom={controls.dateFrom}
-              onDateFromChange={controls.setDateFrom}
-              dateTo={controls.dateTo}
-              onDateToChange={controls.setDateTo}
-              dateLabel="Loaded"
-              hasFilters={controls.hasFilters}
-              onReset={controls.reset}
+              viewId="loaded-inventory"
             />
             <DataTable
               columns={columns}
-              data={controls.pagedRows}
+              data={pagedLoadings}
               status={isLoading ? 'loading' : 'success'}
               containerClassName="border-0 shadow-none"
-              {...controls.tableProps}
+              {...controls.tableProps(filteredLoadings.length)}
             />
           </>
         )}

apps/edr-freight-web/backoffice/src/pages/warehouses/TrucksOnSitePage.tsx

@@ -11,11 +11,16 @@ import {
 } from "@mantine/core";
 
 import { PageContainer, PageHeader } from "@/components/page";
-import ListControls from "@/components/common/ListControls";
 // Generic list footer — already shared by the fleet and train-scheduling lists
 // despite the ruleEngine path; reused here rather than adding a second one.
 import RuleEngineListFooter from "@/components/ruleEngine/RuleEngineListFooter";
-import { useListControls } from "@/hooks/useListControls";
+import {
+  applyClientFilters,
+  FilterBar,
+  toRuleEngineFooterProps,
+  useFilters,
+  type FilterDef,
+} from "@/components/filters";
 import { useTrucksOnSite } from "@/hooks/useWarehouses";
 import type { TruckOnSite } from "@/types/warehouse";
 import { formatDateTime } from "@/lib/format";
@@ -142,10 +147,14 @@ function Rows({ rows }: { rows: TruckOnSite[] }) {
   );
 }
 
+const TRUCK_FILTER_DEFS: FilterDef[] = [{ key: "arrivedAt", label: "Arrived", type: "date" }];
+
 export default function TrucksOnSitePage() {
   const { data: trucks = [], isLoading } = useTrucksOnSite();
   // The dashboard's "Trucks on-site" card counts only arrived trucks, so it
-  // deep-links here with ?scope=ON_SITE to land on the matching tab.
+  // deep-links here with ?scope=ON_SITE to land on the matching tab. Read
+  // once at mount, same as before — scope/source stay page-level tab state
+  // (mutually exclusive, dashboard-linked), not filter pills.
   const [searchParams] = useSearchParams();
   const scopeParam = searchParams.get("scope");
   const [scope, setScope] = useState<"ALL" | "ON_SITE" | "INBOUND">(
@@ -153,7 +162,7 @@ export default function TrucksOnSitePage() {
   );
   const [source, setSource] = useState<"ALL" | "CUSTOMER" | "EDR">("ALL");
 
-  // Scope/source are page filters and run first; the shared control then does
+  // Scope/source are page filters and run first; the filter bar then does
   // search + arrival-date range + pagination over what they leave.
   const scoped = useMemo(
     () =>
@@ -163,10 +172,14 @@ export default function TrucksOnSitePage() {
     [trucks, scope, source],
   );
 
-  const controls = useListControls(scoped, {
+  const controls = useFilters(TRUCK_FILTER_DEFS, { pageSize: 10 });
+  const filteredTrucks = applyClientFilters(scoped, TRUCK_FILTER_DEFS, controls.values, controls.searchText, {
     searchKeys: ["plateNumber", "driverName", "bookingReference", "customerName", "containers"],
-    dateKey: "arrivedAt",
   });
+  const pagedTrucks = filteredTrucks.slice(
+    (controls.page - 1) * controls.pageSize,
+    controls.page * controls.pageSize,
+  );
 
   const onSiteCount = trucks.filter((t) => t.status === "ON_SITE").length;
   const inboundCount = trucks.length - onSiteCount;
@@ -185,7 +198,10 @@ export default function TrucksOnSitePage() {
           <SegmentedControl
             size="xs"
             value={scope}
-            onChange={(v) => setScope(v as typeof scope)}
+            onChange={(v) => {
+              setScope(v as typeof scope);
+              controls.setPage(1);
+            }}
             data={[
               { label: `All (${trucks.length})`, value: "ALL" },
               { label: `On site (${onSiteCount})`, value: "ON_SITE" },
@@ -195,7 +211,10 @@ export default function TrucksOnSitePage() {
           <SegmentedControl
             size="xs"
             value={source}
-            onChange={(v) => setSource(v as typeof source)}
+            onChange={(v) => {
+              setSource(v as typeof source);
+              controls.setPage(1);
+            }}
             data={[
               { label: "All", value: "ALL" },
               { label: `Customer (${customerCount})`, value: "CUSTOMER" },
@@ -205,30 +224,21 @@ export default function TrucksOnSitePage() {
         </Group>
       </Group>
 
-      <ListControls
-        search={controls.search}
-        onSearchChange={controls.setSearch}
+      <FilterBar
+        defs={TRUCK_FILTER_DEFS}
+        controls={controls}
         searchPlaceholder="Plate, driver, booking, container…"
-        dateFrom={controls.dateFrom}
-        onDateFromChange={controls.setDateFrom}
-        dateTo={controls.dateTo}
-        onDateToChange={controls.setDateTo}
-        dateLabel="Arrived"
-        hasFilters={controls.hasFilters}
-        onReset={controls.reset}
+        viewId="trucks-on-site"
       />
 
       {isLoading ? (
         <Text size="sm">Loading…</Text>
       ) : (
         <>
-          <Rows rows={controls.pagedRows} />
+          <Rows rows={pagedTrucks} />
           <RuleEngineListFooter
-            pagination={controls.pagination}
-            pageCount={controls.pageCount}
-            totalCount={controls.totalCount}
             itemLabel="trucks"
-            onPaginationChange={controls.setPagination}
+            {...toRuleEngineFooterProps(controls, filteredTrucks.length)}
           />
         </>
       )}

apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInvoicesPage.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useState } from 'react';
+import { useEffect, useMemo, useState } from 'react';
 import {
   ActionIcon,
   Badge,
@@ -18,8 +18,7 @@ import {
 import { Ban, CreditCard, DoorOpen, Download, ExternalLink, Eye, Receipt } from 'lucide-react';
 import { useNavigate } from 'react-router-dom';
 import { DataTable, type ColumnDef } from '@edr/ui-common';
-import ListControls from '@/components/common/ListControls';
-import { useListControls } from '@/hooks/useListControls';
+import { applyClientFilters, FilterBar, useFilters, type FilterDef } from '@/components/filters';
 
 import { PageContainer, PageHeader } from '@/components/page';
 import { AccrualDashboard } from '@/components/warehouses';
@@ -54,9 +53,21 @@ const STATUS_COLOR: Record<WarehouseInvoiceStatus, string> = {
 const fmt = (n: number, c: string) => formatMoney(n, c, 2);
 const fmtDate = (d?: string | null) => (d ? new Date(d).toLocaleDateString() : '—');
 
+const INVOICE_FILTER_DEFS: FilterDef[] = [
+  {
+    key: 'status',
+    label: 'Status',
+    type: 'enum',
+    multiple: false,
+    options: WAREHOUSE_INVOICE_STATUSES.map((s) => ({ value: s, label: s.replace(/_/g, ' ') })),
+  },
+  { key: 'issuedAt', label: 'Issued', type: 'date' },
+];
+
 export default function WarehouseInvoicesPage() {
-  const [status, setStatus] = useState<WarehouseInvoiceStatus | null>(null);
   const [detailId, setDetailId] = useState<string | null>(null);
+  const controls = useFilters(INVOICE_FILTER_DEFS, { pageSize: 10 });
+  const status = (controls.values.status?.v[0] as WarehouseInvoiceStatus | undefined) ?? null;
 
   const { data, isLoading } = useQuery(
     api.warehouses.invoices.queryOptions({
@@ -65,10 +76,20 @@ export default function WarehouseInvoicesPage() {
   );
   const invoices = data ?? [];
 
-  const controls = useListControls(invoices, {
-    searchKeys: ['invoiceNumber', 'bookingReference', 'customerName', 'containerNumber'],
-    dateKey: 'issuedAt',
-  });
+  // Endpoint only filters by `status`; search + issued-date range are
+  // applied client-side (the client bridge — see components/filters/clientFilter.ts).
+  // Flip to server mode by deleting this call once the endpoint takes more params.
+  const filteredInvoices = applyClientFilters(
+    invoices,
+    INVOICE_FILTER_DEFS,
+    controls.values,
+    controls.searchText,
+    { searchKeys: ['invoiceNumber', 'bookingReference', 'customerName', 'containerNumber'] },
+  );
+  const pagedInvoices = useMemo(
+    () => filteredInvoices.slice((controls.page - 1) * controls.pageSize, controls.page * controls.pageSize),
+    [filteredInvoices, controls.page, controls.pageSize],
+  );
 
   const invoiceColumns: ColumnDef<WarehouseFeeInvoice>[] = [
     {
@@ -135,36 +156,20 @@ export default function WarehouseInvoicesPage() {
       </Stack>
 
       <Card>
-        <ListControls
-          search={controls.search}
-          onSearchChange={controls.setSearch}
+        <FilterBar
+          defs={INVOICE_FILTER_DEFS}
+          controls={controls}
           searchPlaceholder="Search invoice no / booking / customer"
-          dateFrom={controls.dateFrom}
-          onDateFromChange={controls.setDateFrom}
-          dateTo={controls.dateTo}
-          onDateToChange={controls.setDateTo}
-          dateLabel="Issued"
-          hasFilters={controls.hasFilters}
-          onReset={controls.reset}
-        >
-          <Select
-            label="Status"
-            placeholder="All statuses"
-            data={WAREHOUSE_INVOICE_STATUSES.map((s) => ({ value: s, label: s.replace(/_/g, ' ') }))}
-            value={status}
-            onChange={(v) => setStatus((v as WarehouseInvoiceStatus) ?? null)}
-            clearable
-            w={200}
-          />
-        </ListControls>
+          viewId="warehouse-invoices"
+        />
 
         <DataTable
           columns={invoiceColumns}
-          data={controls.pagedRows}
+          data={pagedInvoices}
           status={isLoading ? 'loading' : 'success'}
           emptyMessage="No invoices found."
           containerClassName="border-0 shadow-none"
-          {...controls.tableProps}
+          {...controls.tableProps(filteredInvoices.length)}
         />
       </Card>
 

apps/edr-freight-web/backoffice/src/services/contracts.service.ts

@@ -91,6 +91,13 @@ export interface ContractListSummaryTabs {
 export interface ContractListSummary {
   metrics: ContractListSummaryMetrics;
   tabs: ContractListSummaryTabs;
+  /**
+   * Per-column value counts for the filter bar's enum popovers, scoped to
+   * every OTHER currently-active filter. Optional: pages built before the
+   * pill filter bar don't read it, and it degrades gracefully — an absent
+   * key just means that popover shows no counts.
+   */
+  facets?: Record<string, { value: string; count: number }[]>;
 }
 
 export interface ContractView {

apps/edr-freight-web/portal/src/components/FaydaVerifyPanel.tsx

@@ -25,6 +25,10 @@ import {
   type IdentitySubject,
   type IdentityVerificationState,
 } from "@/services/verifayda.service";
+import { isBypassEnv } from "@/utils/dev-bypass";
+
+/** Sentinel code that skips the real eSignet exchange in dev/staging (see api's DEV_BYPASS_FAYDA_CODE). */
+const DEV_BYPASS_FAYDA_CODE = "DEV_BYPASS";
 
 interface FaydaVerifyPanelProps {
   subject: IdentitySubject;
@@ -80,6 +84,23 @@ export default function FaydaVerifyPanel({
     setError(null);
     setLoading(true);
     try {
+      // Dev/staging only: send the tab straight to /fayda/callback with the
+      // sentinel code instead of round-tripping through eSignet — that page's
+      // existing completeIdentity()/navigate-back logic runs unchanged.
+      if (isBypassEnv()) {
+        stashPendingVerification({
+          subject,
+          returnTo:
+            window.location.pathname +
+            window.location.search +
+            window.location.hash,
+        });
+        window.location.assign(
+          `/fayda/callback?code=${DEV_BYPASS_FAYDA_CODE}&state=bypass`,
+        );
+        return;
+      }
+
       const authorizationUrl = await verifaydaService.start();
       // Record who is being verified and where to come back to before the tab
       // leaves — /fayda/callback has no other way to know either.

apps/edr-freight-web/portal/src/utils/dev-bypass.ts

@@ -0,0 +1,4 @@
+/** True when VITE_ENV is "dev" or "staging" — mirrors the API's ENV gate. */
+export function isBypassEnv(): boolean {
+  return ["dev", "staging"].includes(import.meta.env.VITE_ENV ?? "");
+}

apps/edr-freight-web/portal/src/vite-env.d.ts

@@ -23,6 +23,8 @@ interface ImportMetaEnv {
   readonly VITE_POSTHOG_KEY?: string;
   /** Self-hosted PostHog instance URL. */
   readonly VITE_POSTHOG_HOST?: string;
+  /** "dev" | "staging" — enables the OTP/payment/Fayda bypass. Unset in prod. */
+  readonly VITE_ENV?: string;
 }
 
 interface ImportMeta {