@@ -0,0 +1,14 @@
+---
+'@object-ui/types': patch
+'@object-ui/components': patch
+---
+
+refactor(ui-types): one source for the filter-builder field-type list, read by the validator, the interface and the renderer
+
+Clause-②: no
+Metadata-protocol: none
+
+The `filter-builder` field types used to be listed three times by hand: in `FilterFieldSchema.type`, in `FilterField['type']`, and in the renderer's behaviour buckets. Each copy could drift from the others, and past fixes repaired exactly that drift. There is now one declaration. The accepted set is unchanged: the same fourteen members, `type` still optional, and `text` still the default when it is absent.
+
+- **`@object-ui/types`** exports `FILTER_FIELD_TYPES` and the four behaviour buckets it is built from: `FILTER_NUMBER_LIKE_TYPES`, `FILTER_DATE_LIKE_TYPES`, `FILTER_SELECT_LIKE_TYPES` and `FILTER_LOOKUP_LIKE_TYPES`. It also exports the member type `FilterFieldType`. `FilterFieldSchema.type` builds its enum from the list, and `FilterField['type']` is `FilterFieldType`.
+- **`@object-ui/components`**: `filter-builder` takes its number-, date-, select- and lookup-like buckets from `@object-ui/types` and no longer declares its own. What it draws for each type is unchanged.
@@ -451,7 +451,7 @@ jobs:
               # spelled it, exactly as the two narrower `skills/` entries were.
               - 'docs/**'
             # The objectui tree, the root files the ui jobs build from, and the
-            # four roots outside ui/ that the ui jobs' gates and tests read
+            # five paths outside ui/ that the ui jobs' gates and tests read
             # (objectstack#25712):
             #   - every root workflow, not ci.yml alone: Lint UI's pre-install
             #     import graph check scans all of `.github/workflows/` for ui
 
@@ -59,5 +59,5 @@ source of truth for that mapping.
 - Console routes: `packages/app-shell/src/console/AppContent.tsx`
 - Bare data surface decision record: `docs/adr/0055-parameterized-bare-data-surface.md`
   (amends ADR-0053's context table)
-- Human-facing version: https://objectstack.ai/docs/ui/apps
+- Human-facing version: [Apps](https://objectstack.ai/docs/ui/apps)
   (derived from this guide — update both together)
@@ -315,6 +315,6 @@ channel triples, not finished colours:
 }
 ```
 
-See https://objectstack.ai/docs/frontend/theming for the token list and `ThemeProvider`.
+See [Theming](https://objectstack.ai/docs/frontend/theming) for tokens and `ThemeProvider`.
 
 **Without these imports, ObjectUI components will render but look completely unstyled.**
@@ -103,7 +103,7 @@ interface BaseSchema {
 - **#0.1 — Fix the metadata, not the renderer (contract-first).** Corollary to #0. This is a metadata-driven system: `@objectstack/spec` is the contract between producers and this renderer. When a piece of metadata "doesn't render," ask **first**: *is it spec-compliant? is this the long-term-correct direction?* If the metadata is off-spec, fix it at the **producer** (and have it rejected at authoring/publish) — do **not** add a lenient fallback/alias in the renderer (reading both `columns` and `fields`, coercing a malformed shape, `??`-defaulting around bad input) to make non-compliant metadata "work." A tolerant fallback fossilizes the wrong convention into a second de-facto contract, dilutes the spec, and hides the producer's bug — one strict contract beats N dialects. We own both ends, so Postel's "be liberal in what you accept" does **not** apply (that's for untrusted boundaries). Change the **spec** only when it is genuinely wrong — deliberately, in `@objectstack/spec`, never by accreting renderer-side fallbacks.
   - **The TypeScript authoring face is part of the contract (objectui#7927 ruling, executed by objectui#8347).** `BaseSchema` declares no index signature, so a node literal typed with its node type refuses, at the authoring site, a key no declaration names — a misspelling included. When a key you need is refused, this rule applies unchanged: declare it on the node type that reads it, by reference to the spec row, or fix the producer; a key only the host writes at runtime is typed on a package-local hand-off type where its producer and consumer live, never on the authoring face (objectui#6356). ⛔ Never make it compile with `as any`, a cast to `Record<string, unknown>`, a re-added index signature or an open `type: string` arm. Tolerance stays where it is deliberate: renderer props (`ComponentRendererProps` keeps its signature) and the tolerant zod face (`.passthrough()`); the derived strict zod face, `StrictAnyComponentSchema`, refuses an unknown key in metadata that arrives as data. ⚠️ The bound, said per #9: TypeScript excess-checks only a FRESH object literal, so a value that reached its annotation through a wider variable is not re-checked. `packages/types/src/__tests__/base-schema-closed-face-8347.test.ts` pins both directions and that bound.
 - **#1 — Protocol-agnostic.** Never hardcode `objectql.find()`. Use the DataSource interface; inject `dataSource` via `<SchemaRendererProvider dataSource={...} />`.
-- **#2 — Docs-driven.** For every feature/refactor, update package `README.md` **and** `content/docs/guide/*.md`. Not done until docs reflect the code.
+- **#2 — Docs-driven.** For every feature/refactor, update package `README.md` **and** the matching page under `content/docs/frontend/` (the repo root's docs tree). Not done until docs reflect the code.
 - **#3 — "Shadcn-native" aesthetics.** We are "serializable Shadcn". Follow Shadcn's DOM structure (`CardHeader`/`CardTitle`/`CardContent`). Always expose `className` in schema props so users can override via JSON.
 - **#4 — Action system (objectui#7898, objectui#6497, objectui#11183).** Actions are **data, not functions**, and a control that RUNS something is its own NODE TYPE — `action:button` — never a handler key or an event bag on an ordinary node. The block's props live in the node's `properties` bag, which is the spec's `ComponentPropsMap` row for it: `actionType` names the executor the action runner dispatches to, and the row's other keys carry that executor's arguments. ⛔ Never write them flat on the node: the spec's `PageComponentSchema` is `.strict()` (ADR-0089 D3a) and refuses a node-level `actionType` / `target` as mis-layered, and objectui's strict authoring face refuses the same two keys. The runtime reads both spellings through the `SchemaRenderer` `properties` hoist, so the bag costs nothing at render:
   ```json
 
@@ -47,6 +47,7 @@ import { render } from '@testing-library/react';
 import { createHash } from 'node:crypto';
 import '@object-ui/components';
 import { SchemaRenderer, toRenderableSchema } from '@object-ui/react';
+import { FILTER_FIELD_TYPES } from '@object-ui/types';
 import { getExample } from '../src/index.js';
 
 const IDS = [
@@ -403,13 +404,30 @@ describe('objectui#6939 — the vocabulary the mirror now names is live', () =>
     expect(oneRow('string').inputs).not.toEqual(oneRow('number').inputs);
   });
 
-  it.each(['status', 'currency', 'percent', 'rating', 'lookup', 'master_detail', 'user'])(
-    '`%s` is live too, and the mirror refuses it — a pre-existing gap, reported not repaired',
-    (type) => {
-      // These draw a REAL control (a number input, or the option-driven Select),
-      // so they are not phantoms like `string`; the mirror refused them before
-      // this change and still does. Recorded here so the gap is a decision.
-      expect(oneRow(type).inputs).not.toEqual(oneRow('zzz-not-a-field-type').inputs);
-    },
-  );
+  /**
+   * objectstack#27369 — the ruling's precondition, held for EVERY member of the
+   * shared list rather than a hand-kept seven: a member that `FilterFieldSchema`
+   * accepts must draw something a nonsense spelling does not. A fifteenth
+   * member added to `FILTER_FIELD_TYPES` without a bucket reddens here.
+   *
+   * `text` is the one member left out, and only because it IS the fallthrough
+   * target: it draws what a nonsense spelling draws by construction, and its
+   * branch is by NAME (`fieldType || "text"`), pinned in the validator half.
+   */
+  const BRANCHED = FILTER_FIELD_TYPES.filter((type) => type !== 'text');
+
+  it('the branched population is the whole list but `text`', () => {
+    expect(BRANCHED).toHaveLength(FILTER_FIELD_TYPES.length - 1);
+    expect(BRANCHED.length).toBeGreaterThan(0);
+  });
+
+  it.each(BRANCHED)('`%s` draws a branch of its own, not the fallthrough', (type) => {
+    const nonsense = oneRow('zzz-not-a-field-type');
+    const row = oneRow(type);
+    expect(
+      `${row.inputs.join(',')}|${row.triggers.length}`,
+      `FILTER_FIELD_TYPES carries \`${type}\`, but the renderer draws it exactly as an unrecognised `
+        + 'spelling — give it a bucket in custom/filter-builder.tsx or take it out of the list',
+    ).not.toBe(`${nonsense.inputs.join(',')}|${nonsense.triggers.length}`);
+  });
 });
@@ -18,9 +18,13 @@ import {
 } from "@objectstack/spec/ui"
 import { expandEmptyOperator } from "@objectstack/spec/data"
 import { SchemaRendererContext } from "@object-ui/react"
-import type {
-  FilterBuilderCondition as AuthoredFilterBuilderCondition,
-  FilterGroup as AuthoredFilterGroup,
+import {
+  FILTER_DATE_LIKE_TYPES,
+  FILTER_LOOKUP_LIKE_TYPES,
+  FILTER_NUMBER_LIKE_TYPES,
+  FILTER_SELECT_LIKE_TYPES,
+  type FilterBuilderCondition as AuthoredFilterBuilderCondition,
+  type FilterGroup as AuthoredFilterGroup,
 } from "@object-ui/types"
 // The retirement gate (objectui#4914, ruling B). Read from
 // `@object-ui/core` rather than from `@object-ui/fields` — which is where
@@ -1203,24 +1207,18 @@ const dateOperators: readonly FilterBuilderOperator[] = ["equals", "not_equals",
 const selectOperators: readonly FilterBuilderOperator[] = ["equals", "not_equals", "in", "not_in", "is_empty", "is_not_empty", ...NULLNESS_OPERATORS]
 const lookupOperators: readonly FilterBuilderOperator[] = ["equals", "not_equals", "in", "not_in", "is_empty", "is_not_empty", ...NULLNESS_OPERATORS]
 
-/** Field types that share the same operator/input behavior as number (numeric comparison operators, number input) */
-const numberLikeTypes = ["number", "currency", "percent", "rating"]
-/** Field types that share the same operator/input behavior as date (before/after operators, date/datetime/time input) */
-const dateLikeTypes = ["date", "datetime", "time"]
-/** Field types that use select operators (equals/in/not_in) and render dropdown or checkbox list when options provided */
-const selectLikeTypes = ["select", "status"]
-/**
- * Relational/reference field types that use lookup operators (equals/in/not_in)
- * and render dropdown or checkbox list when options provided.
- *
- * `owner` left this list with objectui#4914: it is a RETIRED spelling, and
- * the gate below answers for it before this membership test is ever reached.
- * The deletion is lockstep hygiene rather than the behavioural half — a list
- * that still named a retired spelling would be a second, contradicting
- * authority on what is live — and it is exactly the shape PR #4932 used when
- * it retired the same word from `INLINE_ROUTED_FIELD_TYPES`.
- */
-const lookupLikeTypes = ["lookup", "master_detail", "user"]
+// The four behaviour buckets are declared once, in `@object-ui/types`
+// (`filter-field-types.ts`), where `FilterFieldSchema.type` and
+// `FilterField['type']` take the same members — so a spelling cannot be
+// validated without a branch here, or drawn here without being validated.
+// Widened to `readonly string[]` because every test below asks about an
+// authored, unchecked `type` string. `owner` is in none of them: it is a
+// RETIRED spelling (objectui#4914), answered by the gate in
+// `operatorsForFieldType` before any membership test is reached.
+const numberLikeTypes: readonly string[] = FILTER_NUMBER_LIKE_TYPES
+const dateLikeTypes: readonly string[] = FILTER_DATE_LIKE_TYPES
+const selectLikeTypes: readonly string[] = FILTER_SELECT_LIKE_TYPES
+const lookupLikeTypes: readonly string[] = FILTER_LOOKUP_LIKE_TYPES
 
 /**
  * The operators a row on a field of `fieldType` can HOLD, given the opt-in ids
Original file line number	Diff line number	Diff line change
`@@ -315,6 +315,6 @@ channel triples, not finished colours:`
`315`	`315`	`}`
`316`	`316`	```
`317`	`317`
`318`		-See https://objectstack.ai/docs/frontend/theming for the token list and `ThemeProvider`.
	`318`	+See [Theming](https://objectstack.ai/docs/frontend/theming) for tokens and `ThemeProvider`.
`319`	`319`
`320`	`320`	`Without these imports, ObjectUI components will render but look completely unstyled.`