@freighttech/ui 0.13.18

package/src/backend/dynamic-table/__tests__/perspectiveTransforms.formulas.test.ts

@@ -0,0 +1,85 @@
+import { apiToDynamicTable, dynamicTableToApi } from '../utils/perspectiveTransforms'
+import type { PerspectiveConfig } from '../types/perspective'
+import type { PerspectiveDto, PerspectiveSettings } from '@open-mercato/shared/modules/perspectives/types'
+
+const allColumns = ['revenue', 'cost']
+
+function config(overrides: Partial<PerspectiveConfig> = {}): PerspectiveConfig {
+  return {
+    id: 'p1',
+    name: 'View',
+    columns: { visible: allColumns, hidden: [] },
+    filters: [],
+    sorting: [],
+    ...overrides,
+  }
+}
+
+function dtoFromSettings(settings: PerspectiveSettings): PerspectiveDto {
+  return { id: 'p1', name: 'View', tableId: 'folders', settings } as PerspectiveDto
+}
+
+const margin = {
+  key: 'formula__marza',
+  label: 'Marża',
+  expression: 'revenue - cost',
+  resultType: 'number' as const,
+}
+
+describe('perspectiveTransforms — calculated columns', () => {
+  it('persists formulas INSIDE the filters passthrough, never as a top-level key', () => {
+    // The upstream settings schema silently strips unknown top-level keys. A
+    // formula saved there would vanish on reload with no error anywhere — the
+    // exact failure `_aggregations`, `_lookups` and `_conditionalFormats` all
+    // already ride this channel to avoid.
+    const settings = dynamicTableToApi(config({ formulas: [margin] }))
+    const filters = settings.filters as Record<string, unknown>
+    expect(filters._formulas).toEqual([margin])
+    expect((settings as Record<string, unknown>).formulas).toBeUndefined()
+  })
+
+  it('round-trips a formula column unchanged', () => {
+    const settings = dynamicTableToApi(config({ formulas: [margin] }))
+    const back = apiToDynamicTable(dtoFromSettings(settings), allColumns)
+    expect(back.formulas).toEqual([margin])
+  })
+
+  it('emits an empty list rather than undefined, so a cleared set is really cleared', () => {
+    const settings = dynamicTableToApi(config({ formulas: [] }))
+    expect((settings.filters as Record<string, unknown>)._formulas).toEqual([])
+  })
+
+  it('drops a malformed entry instead of crashing the table', () => {
+    const dto = dtoFromSettings({
+      columnOrder: allColumns,
+      columnVisibility: { revenue: true, cost: true },
+      filters: {
+        v: 2,
+        rows: [],
+        _formulas: [
+          margin,
+          { key: 'not_a_formula_key', expression: 'x' },
+          { key: 'formula__blank', expression: '   ' },
+          'nonsense',
+          null,
+        ],
+      },
+      sorting: [],
+      grouping: [],
+    } as unknown as PerspectiveSettings)
+
+    expect(apiToDynamicTable(dto, allColumns).formulas).toEqual([margin])
+  })
+
+  it('reads a view saved before formulas existed as having none', () => {
+    const dto = dtoFromSettings({
+      columnOrder: allColumns,
+      columnVisibility: { revenue: true, cost: true },
+      filters: { v: 2, rows: [] },
+      sorting: [],
+      grouping: [],
+    } as unknown as PerspectiveSettings)
+
+    expect(apiToDynamicTable(dto, allColumns).formulas).toEqual([])
+  })
+})

package/src/backend/dynamic-table/__tests__/perspectiveTransforms.frozenColumns.test.ts

@@ -0,0 +1,124 @@
+import { apiToDynamicTable, dynamicTableToApi } from '../utils/perspectiveTransforms'
+import type { PerspectiveConfig } from '../types/index'
+import type { PerspectiveDto, PerspectiveSettings } from '@open-mercato/shared/modules/perspectives/types'
+
+const allColumns = ['name', 'departure', 'arrival']
+
+function baseConfig(overrides: Partial<PerspectiveConfig> = {}): PerspectiveConfig {
+  return {
+    id: 'p1',
+    name: 'Ocean ops',
+    color: 'blue',
+    columns: { visible: allColumns, hidden: [] },
+    filters: [{ id: 'f1', field: 'name', operator: 'contains', values: ['x'] } as any],
+    sorting: [],
+    grouping: [],
+    aggregations: [],
+    ...overrides,
+  }
+}
+
+function dtoFromSettings(settings: PerspectiveSettings): PerspectiveDto {
+  return { id: 'p1', name: 'Ocean ops', tableId: 'transport', settings, isDefault: false, createdAt: '2026-07-20T00:00:00Z' }
+}
+
+describe('perspectiveTransforms — frozenColumns (HEDGE-102)', () => {
+  /**
+   * ═══ THE ASSERTION THAT IS THE WHOLE POINT ═══
+   *
+   * `expect(settings.frozenColumns).toBeUndefined()` is not pedantry about
+   * shape. The upstream settings schema is a bare `z.object` whose vocabulary
+   * is columnOrder / columnVisibility / filters / sorting / grouping / pageSize
+   * / searchValue, and Zod strips everything else — so a top-level key is
+   * accepted with 200 OK and never reaches the database. Measured against the
+   * running API, not inferred: a save carrying both spellings stored only the
+   * one inside `filters`.
+   *
+   * Moving this key to the top level would therefore leave every test that only
+   * checks the round-trip passing, and freeze silently broken again in exactly
+   * the way HEDGE-102 was filed for.
+   */
+  it('round-trips frozen columns through filters._frozenColumns, NOT a top-level key', () => {
+    const settings = dynamicTableToApi(baseConfig({ frozenColumns: ['name', 'departure'] }))
+
+    expect((settings as any).frozenColumns).toBeUndefined()
+    expect((settings.filters as any)._frozenColumns).toEqual(['name', 'departure'])
+
+    const restored = apiToDynamicTable(dtoFromSettings(settings), allColumns)
+    expect(restored.frozenColumns).toEqual(['name', 'departure'])
+  })
+
+  /** The `v: 2` marker is the other half of the trap — without it the upstream
+   *  service drops the whole `filters` object on READ, so the pins would
+   *  persist and never come back. */
+  it('writes the v:2 marker that keeps the passthrough readable', () => {
+    const settings = dynamicTableToApi(baseConfig({ frozenColumns: ['name'] }))
+    expect((settings.filters as any).v).toBe(2)
+  })
+
+  it('keeps pin ORDER — offsets stack left to right, so the order is data', () => {
+    const settings = dynamicTableToApi(baseConfig({ frozenColumns: ['arrival', 'name'] }))
+    const restored = apiToDynamicTable(dtoFromSettings(settings), allColumns)
+    expect(restored.frozenColumns).toEqual(['arrival', 'name'])
+  })
+
+  it('writes no key at all when nothing is pinned, so an untouched view stays clean', () => {
+    const settings = dynamicTableToApi(baseConfig({ frozenColumns: [] }))
+    expect((settings.filters as any)._frozenColumns).toBeUndefined()
+
+    const restored = apiToDynamicTable(dtoFromSettings(settings), allColumns)
+    expect(restored.frozenColumns).toBeUndefined()
+  })
+
+  it('unpinning the last column clears the saved key rather than leaving it behind', () => {
+    const pinned = dynamicTableToApi(baseConfig({ frozenColumns: ['name'] }))
+    expect((pinned.filters as any)._frozenColumns).toEqual(['name'])
+
+    const cleared = dynamicTableToApi(baseConfig({ frozenColumns: [] }))
+    expect((cleared.filters as any)._frozenColumns).toBeUndefined()
+    expect(apiToDynamicTable(dtoFromSettings(cleared), allColumns).frozenColumns).toBeUndefined()
+  })
+
+  it('is undefined for a legacy view saved before the feature existed', () => {
+    const restored = apiToDynamicTable(
+      dtoFromSettings({ columnOrder: allColumns, columnVisibility: {}, filters: { v: 2, rows: [] } as any }),
+      allColumns,
+    )
+    expect(restored.frozenColumns).toBeUndefined()
+  })
+
+  /**
+   * Defensive like its neighbours, and for a concrete reason: the frozen keys
+   * drive the sticky-left offset maths. A `null` or a number reaching that
+   * calculation from a hand-edited or half-migrated row would pin an offset
+   * against `undefined` rather than fail loudly.
+   */
+  it('drops malformed entries instead of carrying them into the offset maths', () => {
+    const settings = {
+      columnOrder: allColumns,
+      columnVisibility: {},
+      filters: { v: 2, rows: [], _frozenColumns: ['name', 7, null, '', { k: 1 }, 'arrival'] },
+    } as any
+    expect(apiToDynamicTable(dtoFromSettings(settings), allColumns).frozenColumns).toEqual(['name', 'arrival'])
+  })
+
+  it('ignores a non-array _frozenColumns entirely', () => {
+    const settings = {
+      columnOrder: allColumns,
+      columnVisibility: {},
+      filters: { v: 2, rows: [], _frozenColumns: 'name' },
+    } as any
+    expect(apiToDynamicTable(dtoFromSettings(settings), allColumns).frozenColumns).toBeUndefined()
+  })
+
+  it('leaves the neighbours on the channel untouched', () => {
+    const restored = apiToDynamicTable(
+      dtoFromSettings(dynamicTableToApi(baseConfig({ frozenColumns: ['name'], dateFormat: 'iso-hm' }))),
+      allColumns,
+    )
+    expect(restored.color).toBe('blue')
+    expect(restored.filters).toHaveLength(1)
+    expect(restored.dateFormat).toBe('iso-hm')
+    expect(restored.frozenColumns).toEqual(['name'])
+  })
+})

package/src/backend/dynamic-table/__tests__/rollupColumns.test.ts

@@ -0,0 +1,149 @@
+/**
+ * Rollup ("summarised") columns — the client half.
+ *
+ * Written from the symptom a user reports, not from the shape of the code.
+ * The failures this feature has are all silent ones: a column that renders
+ * `0,00` for every row, a column that renders `—` for every row, or a saved
+ * view that quietly forgets a column it had.
+ */
+import {
+  buildRollupColumnDefs,
+  isRollupColumnKey,
+  parseRollupColumnKey,
+  parseRollupColumns,
+  rollupColumnDataKey,
+  rollupColumnsToParam,
+} from '../utils/rollupColumns'
+import type { RollupColumnRef } from '../types/rollup'
+import { apiToDynamicTable, dynamicTableToApi } from '../utils/perspectiveTransforms'
+import type { PerspectiveConfig } from '../types/perspective'
+
+const COUNT: RollupColumnRef = { source: 'lines', field: 'id', fn: 'count', label: 'Cost lines · Lines' }
+const SUM: RollupColumnRef = {
+  source: 'lines',
+  field: 'estimated_cost',
+  fn: 'sum',
+  label: 'Cost lines · Sum of Estimated cost',
+}
+
+function renderOf(ref: RollupColumnRef, value: unknown): string {
+  const col = buildRollupColumnDefs([ref], { locale: 'pl-PL' })[0]
+  return String(col.renderer!(value, {}, col, 0, 0))
+}
+
+describe('rollup column keys', () => {
+  it('round-trips a key', () => {
+    const key = rollupColumnDataKey(SUM)
+    expect(key).toBe('rollup__lines__estimated_cost__sum')
+    expect(isRollupColumnKey(key)).toBe(true)
+    expect(parseRollupColumnKey(key)).toEqual({
+      source: 'lines',
+      field: 'estimated_cost',
+      fn: 'sum',
+    })
+  })
+
+  it('does not mistake a lookup or formula column for a rollup', () => {
+    expect(isRollupColumnKey('lookup__contractor__tax_id')).toBe(false)
+    expect(isRollupColumnKey('formula__marza')).toBe(false)
+    expect(parseRollupColumnKey('rollup__lines__estimated_cost')).toBeUndefined()
+    expect(parseRollupColumnKey('rollup__lines__cost__median')).toBeUndefined()
+  })
+})
+
+describe('the rollups query param', () => {
+  it('is empty when the view has no summarised column — so the route is untouched', () => {
+    expect(rollupColumnsToParam([])).toBe('')
+  })
+
+  it('asks the server for each aggregate exactly once', () => {
+    // Two refs differing only in label are ONE aggregate to the server; asking
+    // twice would buy a second GROUP BY for nothing.
+    const param = rollupColumnsToParam([COUNT, SUM, { ...COUNT, label: 'Renamed' }])
+    expect(param).toBe('lines:id:count,lines:estimated_cost:sum')
+  })
+})
+
+describe('the saved view', () => {
+  it('keeps its summarised columns across a save/reload', () => {
+    const config = {
+      id: 'p1',
+      name: 'Costs',
+      columns: { visible: ['id', rollupColumnDataKey(SUM)], hidden: [] },
+      filters: [],
+      sorting: [],
+      rollupColumns: [COUNT, SUM],
+    } as unknown as PerspectiveConfig
+
+    const settings = dynamicTableToApi(config)
+    // The upstream settings schema strips unknown TOP-LEVEL keys; the rollups
+    // must travel inside `filters`, or they vanish on the first reload.
+    expect((settings as any).rollups).toBeUndefined()
+    expect((settings.filters as any)._rollups).toEqual([COUNT, SUM])
+
+    const back = apiToDynamicTable(
+      { id: 'p1', name: 'Costs', settings, isDefault: false } as any,
+      ['id', rollupColumnDataKey(SUM)],
+    )
+    expect(back.rollupColumns).toEqual([COUNT, SUM])
+  })
+
+  it('drops a malformed or unknown entry instead of crashing the table', () => {
+    expect(
+      parseRollupColumns([
+        COUNT,
+        null,
+        'nonsense',
+        { source: 'lines' },
+        { source: 'lines', field: 'x', fn: 'median' },
+        // COUNT is only ever over the child's id — the server enforces it, so a
+        // ref that disagrees would render a permanently empty column.
+        { source: 'lines', field: 'estimated_cost', fn: 'count' },
+        COUNT,
+      ]),
+    ).toEqual([COUNT])
+  })
+
+  it('falls back to the key when a stored label is missing', () => {
+    const [ref] = parseRollupColumns([{ source: 'lines', field: 'id', fn: 'count' }])
+    expect(ref.label).toBe('rollup__lines__id__count')
+  })
+})
+
+describe('the rendered cell', () => {
+  it('shows the number Postgres actually sent, not 0,00', () => {
+    // COUNT comes back as int8 ("7") and SUM over numeric as "18400.0000".
+    // Both are non-finite to `Number.isFinite`, which is how every server-side
+    // total used to render as 0,00.
+    expect(renderOf(COUNT, '7')).toBe('7')
+    expect(renderOf(SUM, '18400.0000')).toBe('18 400,00')
+  })
+
+  it('keeps "no children" visually distinct from "did not resolve"', () => {
+    expect(renderOf(COUNT, 0)).toBe('0')
+    expect(renderOf(COUNT, null)).toBe('—')
+    expect(renderOf(COUNT, undefined)).toBe('—')
+  })
+
+  it('is numeric, right-aligned, monospace and read-only in every write path', () => {
+    const [col] = buildRollupColumnDefs([SUM])
+    // `type: 'numeric'` is load-bearing: grouping's AggregationRule refuses a
+    // non-numeric column and getSortDirectionLabels would offer "A → Z".
+    expect(col.type).toBe('numeric')
+    expect(col.align).toBe('right')
+    expect(col.mono).toBe(true)
+    expect(col.readOnly).toBe(true)
+    expect(col.disableFill).toBe(true)
+  })
+
+  it('exports the raw number, not the locale-formatted string', () => {
+    const [col] = buildRollupColumnDefs([SUM], { locale: 'pl-PL' })
+    expect(col.exportValue!('18400.0000', {})).toBe('18400.0000')
+    expect(col.exportValue!(null, {})).toBe('')
+  })
+
+  it('carries the label the user saw when they added it', () => {
+    const [col] = buildRollupColumnDefs([SUM])
+    expect(col.title).toBe('Cost lines · Sum of Estimated cost')
+  })
+})

package/src/backend/dynamic-table/__tests__/sharedCriteria.test.ts

@@ -0,0 +1,255 @@
+/**
+ * Shared-criteria mapping — the mechanism that lets ONE workspace control drive
+ * panes holding different entities.
+ *
+ * The assertions here are all variations on a single product rule: a pane that
+ * cannot honour a criterion must SAY SO. Every silent path (an unmapped table,
+ * a widget with no entry, a key nobody defined) is pinned to either a visible
+ * report or a hard drop — never to "looks filtered, isn't".
+ *
+ * Spec: .ai/specs/2026-08-17-split-view-workspace-composition.md (TC-SPLIT-62x)
+ */
+
+import {
+  SHARED_FILTER_ID_PREFIX,
+  WIDGET_SHARED_FILTERS,
+  mapCriteriaForTable,
+  mapCriteriaForWidget,
+  mergeSharedFilters,
+  type SharedCriteria,
+  type SharedCriterionRule,
+} from '../split-view/sharedCriteria'
+// NOTE (open-mercato-modules): the original suite also asserted this client
+// enum matches `@freighttech/split-view`'s server zod enum, reached by relative
+// path. That parity guard only makes sense in the FMS monorepo where both
+// packages live; split-view is not part of this repo, so that single test was
+// removed here. The mapping behaviour below still fully covers this module.
+import type { FilterRow } from '../types/index'
+
+/** Two tables that answer "customer" with DIFFERENT field names — the whole point. */
+const TRANSPORTS = { sharedFilters: { customer: 'contractorId', status: 'state' } }
+const OFFERS = { sharedFilters: { customer: 'customerId' } }
+/** A registered table that never opted in. */
+const CARRIERS = {}
+
+const customerRule: SharedCriterionRule = {
+  key: 'customer',
+  operator: 'is_any_of',
+  values: ['acme-1'],
+}
+
+function criteria(...rules: SharedCriterionRule[]): SharedCriteria {
+  return { search: '', rules }
+}
+
+describe('TC-SPLIT-620 — a criterion maps to the table declared field name', () => {
+  it('emits the declaring table own field, not the criterion key', () => {
+    const { filters, unmapped } = mapCriteriaForTable(criteria(customerRule), TRANSPORTS)
+
+    expect(unmapped).toEqual([])
+    expect(filters).toEqual([
+      {
+        id: `${SHARED_FILTER_ID_PREFIX}customer`,
+        field: 'contractorId',
+        operator: 'is_any_of',
+        values: ['acme-1'],
+      },
+    ])
+  })
+
+  it('gives the SAME criterion a different field on a different table', () => {
+    const shared = criteria(customerRule)
+
+    expect(mapCriteriaForTable(shared, TRANSPORTS).filters[0].field).toBe('contractorId')
+    expect(mapCriteriaForTable(shared, OFFERS).filters[0].field).toBe('customerId')
+  })
+
+  it('maps each rule independently, mapping what it can', () => {
+    const { filters, unmapped } = mapCriteriaForTable(
+      criteria(customerRule, { key: 'status', operator: 'is_any_of', values: ['open'] }),
+      OFFERS,
+    )
+
+    expect(filters.map((f) => f.field)).toEqual(['customerId'])
+    expect(unmapped).toEqual(['status'])
+  })
+
+  it('keeps the filter row identity stable across calls, so the request string does not churn', () => {
+    const a = mapCriteriaForTable(criteria(customerRule), TRANSPORTS)
+    const b = mapCriteriaForTable(criteria(customerRule), TRANSPORTS)
+
+    expect(JSON.stringify(a.filters)).toBe(JSON.stringify(b.filters))
+  })
+})
+
+describe('TC-SPLIT-621 — an unmapped table yields no rule AND reports itself', () => {
+  it('returns no filters and names the criterion it cannot answer', () => {
+    const { filters, unmapped } = mapCriteriaForTable(criteria(customerRule), CARRIERS)
+
+    expect(filters).toEqual([])
+    expect(unmapped).toEqual(['customer'])
+  })
+
+  it('reports every live criterion it cannot answer, once each', () => {
+    const { unmapped } = mapCriteriaForTable(
+      criteria(
+        customerRule,
+        { key: 'customer', operator: 'contains', values: ['x'] },
+        { key: 'transportMode', operator: 'is_any_of', values: ['sea'] },
+      ),
+      CARRIERS,
+    )
+
+    expect(unmapped).toEqual(['customer', 'transportMode'])
+  })
+
+  it('treats a missing metadata object the same as one with no mapping', () => {
+    expect(mapCriteriaForTable(criteria(customerRule), undefined).unmapped).toEqual(['customer'])
+    expect(mapCriteriaForTable(criteria(customerRule), null).unmapped).toEqual(['customer'])
+  })
+})
+
+describe('TC-SPLIT-622 — shared rules never mutate the pane own filters array', () => {
+  const own: FilterRow[] = [{ id: 'local-1', field: 'status', operator: 'is_any_of', values: ['open'] }]
+
+  it('leaves the pane array untouched when shared rules are merged for a request', () => {
+    const before = JSON.parse(JSON.stringify(own))
+    const { filters: shared } = mapCriteriaForTable(criteria(customerRule), TRANSPORTS)
+
+    const merged = mergeSharedFilters(own, shared)
+
+    expect(own).toEqual(before)
+    expect(own).toHaveLength(1)
+    expect(merged).not.toBe(own)
+    expect(merged.map((f) => f.field)).toEqual(['status', 'contractorId'])
+  })
+
+  it('returns the pane own array BY REFERENCE when nothing is shared', () => {
+    // Byte-identical behaviour for the 29 pages that never pass shared filters:
+    // a new array here would churn every memo downstream of it.
+    expect(mergeSharedFilters(own, [])).toBe(own)
+    expect(mergeSharedFilters(own, undefined)).toBe(own)
+    expect(mergeSharedFilters(own, null)).toBe(own)
+  })
+
+  it('lets a shared rule win over a local rule on the SAME field, for the request only', () => {
+    const { filters: shared } = mapCriteriaForTable(
+      criteria({ key: 'status', operator: 'is_any_of', values: ['closed'] }),
+      TRANSPORTS,
+    )
+
+    const merged = mergeSharedFilters(
+      [{ id: 'local-1', field: 'state', operator: 'is_any_of', values: ['open'] }],
+      shared,
+    )
+
+    // One rule for the column, not two ANDed into zero rows.
+    expect(merged).toHaveLength(1)
+    expect(merged[0].values).toEqual(['closed'])
+  })
+})
+
+describe('TC-SPLIT-623 — disabling the toggle emits zero shared rules', () => {
+  it('emits nothing when the workspace passes no criteria at all', () => {
+    expect(mapCriteriaForTable(null, TRANSPORTS)).toEqual({ filters: [], unmapped: [] })
+    expect(mapCriteriaForTable(undefined, TRANSPORTS)).toEqual({ filters: [], unmapped: [] })
+  })
+
+  it('emits nothing — and reports nothing unmapped — for an empty rule set', () => {
+    const { filters, unmapped } = mapCriteriaForTable({ search: 'acme', rules: [] }, CARRIERS)
+
+    // A pane must not claim "not filtered by customer" when nobody asked for a
+    // customer: the marker means a LIVE criterion was dropped.
+    expect(filters).toEqual([])
+    expect(unmapped).toEqual([])
+  })
+
+  it('drops a rule whose operator takes values but has none', () => {
+    const { filters } = mapCriteriaForTable(
+      criteria({ key: 'customer', operator: 'is_any_of', values: [] }),
+      TRANSPORTS,
+    )
+
+    expect(filters).toEqual([])
+  })
+
+  it('keeps a value-less operator that means something on its own', () => {
+    const { filters } = mapCriteriaForTable(
+      criteria({ key: 'dateRange', operator: 'is_today', values: [] }),
+      { sharedFilters: { dateRange: 'etd' } },
+    )
+
+    expect(filters).toEqual([
+      { id: `${SHARED_FILTER_ID_PREFIX}dateRange`, field: 'etd', operator: 'is_today', values: [] },
+    ])
+  })
+})
+
+describe('TC-SPLIT-624 — a widget with no entry reports unmapped, still renders', () => {
+  it('ships with no invented mappings', () => {
+    // An entry is earned by reading the widget and confirming it accepts the
+    // value through `settings`. A guessed one produces a pane that claims to be
+    // filtered and is not.
+    expect(WIDGET_SHARED_FILTERS).toEqual({})
+  })
+
+  it('reports the criterion and hands the pane nothing to apply', () => {
+    const { filters, unmapped } = mapCriteriaForWidget(
+      criteria(customerRule),
+      'shipment-tracking:ships-map',
+    )
+
+    // Nothing to apply → the widget renders its own data, unfiltered…
+    expect(filters).toEqual([])
+    // …and the pane has what it needs to say "not filtered by customer".
+    expect(unmapped).toEqual(['customer'])
+  })
+
+  it('behaves the same for a widget id that is not known at all', () => {
+    expect(mapCriteriaForWidget(criteria(customerRule), undefined)).toEqual({
+      filters: [],
+      unmapped: ['customer'],
+    })
+  })
+
+  it('maps through an entry once one is declared', () => {
+    const declared = { ...WIDGET_SHARED_FILTERS, 'invoicing:inflows': { customer: 'contractorId' } }
+    // Same mechanism the table path uses, so a declared widget cannot drift
+    // from a declared table.
+    expect(
+      mapCriteriaForTable(criteria(customerRule), {
+        sharedFilters: declared['invoicing:inflows'],
+      }).filters[0].field,
+    ).toBe('contractorId')
+  })
+})
+
+describe('TC-SPLIT-625 — an unknown criterion key is dropped, never forwarded', () => {
+  const bogus = { key: 'vessel', operator: 'is_any_of', values: ['ever given'] } as unknown as SharedCriterionRule
+
+  it('never reaches the request, even when a mapping names it', () => {
+    const { filters, unmapped } = mapCriteriaForTable(criteria(bogus), {
+      sharedFilters: { vessel: 'vesselName' } as never,
+    })
+
+    expect(filters).toEqual([])
+    // Not reportable either: a pane cannot honestly caption a criterion whose
+    // meaning nobody defines. The server's zod enum refuses it on save; this is
+    // the same refusal one layer earlier.
+    expect(unmapped).toEqual([])
+  })
+
+  it('drops only the unknown rule and keeps the known ones', () => {
+    const { filters, unmapped } = mapCriteriaForTable(criteria(bogus, customerRule), TRANSPORTS)
+
+    expect(filters.map((f) => f.field)).toEqual(['contractorId'])
+    expect(unmapped).toEqual([])
+  })
+
+  it('applies the same drop on the widget path', () => {
+    expect(mapCriteriaForWidget(criteria(bogus), 'invoicing:inflows')).toEqual({
+      filters: [],
+      unmapped: [],
+    })
+  })
+})