Hello docs
` is React's - own element. - - **What does not move.** `PUBLIC_BLOCKS` is unchanged and the two rosters are - pinned disjoint; every curated manifest entry serialises byte-identically - (`tier` is written as exactly `'html'` or omitted). `div` is not declared: the - gate keeps refusing `
` on an html page, and `box` remains the JSON
- surface's replacement. `code` is not declared either — the bare `code` key is
- the `field:code` widget's namespace fallback, not an element renderer — nor is
- `kbd`; both are recorded, with reasons, in the console's exclusion ledger.
- No registration changes; `html-elements.tsx` is untouched.
-
- ⚠️ **Dated note, 2026-09-27 — `code` has since joined the roster — objectui#10756.** At this change the roster held 47 tags and `code` was undeclared because the bare key was the `field:code` widget's fallback; `html-elements.tsx` now registers `code` as a sanitised passthrough (`ui:code`), `@object-ui/fields` registers the widget with `skipFallback` so it keeps only `field:code`, and the manifest declares `code` with `tier: 'html'` — 48 html-tier entries. `div` and `kbd` are still out. The rest of this entry is kept as the reading of this change.
-
- The manifest the framework ships regenerates from objectui's built tree at the
- pin (its `gen-sdui-manifest-node.mjs`); its lockstep copy of `manifestFromConfigs`
- must take this port for the stamp to reach that file — until then the tags are
- declared there without the marker, which the gate treats identically.
-- c80236e: The base-prop list is declared once, and the renderer's `visibleWhen`, `hiddenOn` and `testId` join it (objectui#11044).
-
- `validateTree` and `generateDts` each kept their own hand-written list of the base props: the `BaseSchema` keys a node may carry without its registration declaring them. The two lists had drifted. After objectui#11008 the validator accepted `bind` and `hidden` on every node, while the generated JSX types (`SduiBaseProps` in `sdui-intrinsics.d.ts`) still refused both (`TS2322 … Property 'bind' does not exist`). Both now read one exported list, `SDUI_BASE_PROPS`, and the generated `SduiBaseProps` interface is emitted from it.
-
- Three changes to what is accepted come with it:
-
- - **`visibleWhen`, `hiddenOn` and `testId` are base props of every node.** `BaseSchema` declares all three, no registration declares any of them, and `SchemaRenderer` reads them for every node. It evaluates `visibleWhen` and `hiddenOn` in its hide chain, and it re-emits `testId` as `data-testid`. `validateTree` answered each with an `unknown-prop` warning on every registered type. Now none of them draws a diagnostic, and the generated JSX types accept them, along with `bind` and `hidden`. The canonical ADR-0089 predicate, `visibleWhen`, used to warn while the deprecated `visibleOn` was silent. A near-miss spelling such as `testid` still draws `unknown-prop`.
- - **`name`, `label`, `description`, `placeholder`, `data` and `ariaLabel` are base props where a type does not declare them.** Some registrations declare each of these `BaseSchema` members as a typed input. On those types the declared input wins, and a wrong-typed value still draws `type-mismatch`. On every other type the key no longer draws `unknown-prop`. In the generated JSX types, an interface that declares one of these keys extends `Omit` for it, so its declared type is the one an author compiles against.
- - **The cost is named.** On a type that does not declare one of the six keys, the parser tier no longer reports it, whether or not the renderer reads it. For example, `description` on `page-header` is the retired alias of `subtitle` (objectui#3226), and it used to draw `unknown-prop`. It now draws nothing.
-
- `SDUI_BASE_PROPS` and its `SduiBaseProp` / `SduiBasePropScope` types are new exports. Each entry names a `BaseSchema` member, the scope it is a base prop in (`'every-node'` or `'where-undeclared'`), and its type in the generated JSX surface.
-
- ⚠️ **Dated note, 2026-10-02 — the `page-header` example no longer applies — objectui#10859.**
- Later in this same release objectui#10859 batch 8 (phase 2c) unregistered `page-header`, so a
- `page-header` node now draws `unknown-component` before any prop check runs. The cost this entry names
- is unchanged for every type that is still registered. The rest of this entry is kept as the reading of
- this change.
-- 4d377ed: The generated JSX types let a declared input win with its type for every base prop, so `sdui-intrinsics.d.ts` compiles as generated (objectui#11075).
-
- `generateDts` over the real public manifest produced a `.d.ts` that did not compile under `tsc --strict` without `skipLibCheck`: `TS2430 Interface 'RecordAlertProps' incorrectly extends interface 'SduiBaseProps'`. `record:alert` declares `visible` as a boolean, a bare CEL string or a `{ dialect: 'cel', source }` envelope, and its renderer honours all three. `visible` is an `'every-node'` base prop typed `boolean` in `SduiBaseProps`, and objectui#11044's `Omit` covered only the `'where-undeclared'` members. An author compiling against the file got an error inside the generated file instead of a check on their own JSX. With `skipLibCheck` on, the base `boolean` hid the string and envelope arms.
-
- Now an interface `Omit`s every base attribute its registration declares, whatever the member's scope, and types it with the declared type:
-
- - **`` accepts `visible` as a string and as the `cel` envelope** in the generated types, as the manifest declares and the renderer reads. A number is still refused.
- - **Where a registration declares a base attribute with the base type** (`className?: string` on most html-tier tags and many blocks, `disabled?: boolean` on `element:button`), the interface extends `Omit` for it too. What those interfaces accept does not change.
- - **`SduiBaseProps` itself is unchanged**: `visible`, `disabled` and `hidden` stay `boolean` on every type that does not declare them.
-
- `validateTree` is unchanged: it still skips an `'every-node'` key before the declared-input lookup.
-- 0db4fb3: html tier: a braced attribute value that is not strict JSON now draws a `inert-expression` warning instead of vanishing silently (objectui#6598)
-
- `interpretBrace` materializes strict-JSON values only; anything else — the
- single-quoted array every JSX author writes (`columns={['name','amount']}`),
- unquoted object keys, any JS expression — compiles to the deferred `{ $expr }`
- marker, and nothing downstream evaluates that marker: the html tier parses,
- never executes (ADR-0080), and no renderer consumes `$expr`. The value reached
- the renderer as an opaque object, defensive non-array/non-object reads degraded
- it to "not declared", and the author's binding vanished with zero diagnostics
- anywhere — a production page's `list-view` rendered its row count and toolbar
- with no data columns, through eight `columns` spellings (objectui#6598, moved
- from objectstack#12649). That is ADR-0078's prohibited parsed-but-silently-inert
- state.
-
- `validateTree` now emits a warning-severity `inert-expression` diagnostic when a
- declared input's value is the `$expr` marker, with the fix in the message: write
- the value as JSON (double-quoted strings and keys). Warning, not error, per the
- `8d58f46b4` posture for inert authored keys — pages keep compiling and
- rendering exactly as before; the silence is what changed. Escalating the
- severity, widening the accepted literal grammar (e.g. materializing
- single-quoted strings), and covering base props like `style` are contract
- decisions deliberately left on objectui#6598.
-- 4703651: html tier: braced attribute values now materialize the JS literal subset — single-quoted strings and unquoted identifier keys work (objectui#6614)
-
- The html tier is the untrusted-safe DATA tier: source is parsed, never executed
- (ADR-0080), which makes it the only safe carrier for runtime AI- or
- tenant-authored pages. But `interpretBrace` accepted only strict JSON inside
- braces while the surface called itself JSX, so `columns={['name','amount']}` —
- the spelling every JSX author and every AI author writes by habit — compiled to
- the deferred `{ $expr }` marker that nothing downstream evaluates, and the
- author's whole data binding vanished at render. A production page's `list-view`
- rendered its row count and toolbar with zero data columns through eight
- `columns` spellings before the author gave up (objectui#6598, moved from
- objectstack#12649). That was a trap, not a contract.
-
- `interpretBrace` now materializes the JS **literal subset**. Exactly two
- widenings over JSON, and nothing else:
-
- 1. **single-quoted strings**, in value position and in key position —
- `title={'Accounts'}`, `columns={['name','amount']}`, `{{'pageSize': 25}}`;
- 2. **unquoted identifier object keys** — `options={{pageSize: 25}}`,
- `columns={[{field:'name',label:'Full Name'}]}`.
-
- Everything else JSON refuses is still refused, still compiles to `{ $expr }`,
- and still draws the warning-severity `inert-expression` diagnostic: trailing
- commas, comments, array holes, spreads, `undefined`/`NaN`/`Infinity`,
- `+1`/`.5`/`1.`/`0x1f`, template literals, and every genuine expression —
- identifiers, member access, calls, operators, ternaries. The subset contains no
- identifier lookup and no operator, so there is nothing in it to execute: this
- moves habitual spellings onto the materialized side, it does not move the
- boundary between data and code. An authored `__proto__` key becomes an ordinary
- own property, as `JSON.parse` gives it — never the prototype setter.
-
- Strict JSON is unchanged, structurally: `JSON.parse` still runs first and
- untouched, so any value it accepts takes byte-identically the path it always
- did, and the literal reader only ever sees input `JSON.parse` has already
- thrown on.
-
- The `inert-expression` message changed with the grammar. It used to advise
- "write it as JSON (double-quoted strings and keys)" and named
- `columns={['name','amount']}` as the wrong form — advice that would now send an
- author to edit working source. It names the accepted literal grammar instead.
-
- Maintainer ruling of 2026-08-28 (objectui#6614 Q1-A). ⛔ Two ruled items are
- deliberately NOT in this change: escalating `inert-expression` from warning to
- error (Q2 — it belongs at the save gate, once the framework wires the registry
- manifest into `validate-jsx-pages`), and base-prop (`style`) `$expr` inertness
- (Q3 — sequenced after this, so no warning is added for spellings this change
- legalises).
-- 2acd8e1: **BREAKING (authoring surface): `body` is no longer a child-list key. Author `children`.**
-
- `BaseSchema` declared two spellings of one concept — `body` and `children` — and left the
- choice per component. **Thirteen** registrations read `body` and nothing else, so it was
- their ONLY door — the twelve the ruling enumerated plus `tooltip`, which it did not, and
- which is the count the committed instrument carries (`BODY_ONLY` plus
- `BODY_ONLY_UNRULED` in `scripts/body-dialect-census.mjs`). `div`, `card`, `page`,
- `button`, `aspect-ratio`, the seven sectioning tags and the safe-HTML tag factory read
- `children || body` and took either. The authoring tier only ever knew `children`, so
- an author writing the one spelling that resolved got `unknown-prop` — the same warning a
- typo draws, on the tier built to accept AI-authored pages, where the diagnostic **is** the
- contract (objectui#6771).
-
- Ruled 2026-09-01: one concept, one spelling, and the spelling is `children`.
-
- ## What changed
-
- - **Renderers.** `alert`, `badge`, `tooltip` and the `sidebar-*` family read `children`.
- Every `children || body` fallback drops its `body` arm **except the four `page:*`
- reads named below** — `div`, `card`, `button`, `aspect-ratio`, the sectioning tags,
- the safe-HTML tag factory behind ~36 tags, `page`'s flat content list, and
- `@object-ui/core`'s recursive `validateSchema`.
- - **Item-level `body` is a DIFFERENT key and is untouched.** At this change, `list`
- draws each entry as `item.content || renderChildren(item.body)` and `tabs` as
- `item.content || item.body`, both filed under the ITEM type rather than the node,
- and `tabs` still ships `body` inside its own `defaultProps`. ⛔ Neither is this
- spelling and neither is refused here: the node-level retirement does not reach a
- member of a declared `items` array. Retiring the item-level dialect is
- objectui#9590's card, and the two named above are recorded on it.
- ⚠️ **Dated note, 2026-09-25 — neither half of this bullet holds any longer — objectui#9590.**
- objectui#9941 respelled the `tabs` `defaultProps` items to `content`, and
- objectui#9590 retired both item-level reads: a `list` item and a `tabs` item draw
- `content` and nothing else, and both item faces now refuse `body` by name,
- pointing at `content`. The rest of this bullet is kept as the reading of this change.
- - **What still reads `body` at NODE level, and why.** Four renderer reads, all `page:*`: `page:card`
- (renderer and Studio canvas) and the three thin `page:section` / `page:footer` /
- `page:sidebar` containers. ⛔ Authoring the key is refused on them as it is
- everywhere else; only the READ survives, for documents already STORED under it.
- `@objectstack/spec` states the ground on `PageContainerProps` itself: «The renderers
- keep reading `body` as a back-compat fallback for stored documents; that fallback is
- objectui's to retire on its own schedule, and it is not a second authorable
- spelling.» ⚠️ What separates the two halves is a CONVERSION, not a ground: the spec's
- registry carries `page-card-body-to-children` (`toMajor: 17`, surface
- `page.component.page:card.body`, shipped `retiredFromLoadPath: true` in spec 17.0.0)
- and carries none for the other three — so a stored row under their key has no
- migration path at all. Nothing in this repository authors any of them, and the
- committed census over those keys is how to see that rather than take it on trust:
- `node scripts/body-dialect-census.mjs --keys page:section,page:footer,page:sidebar,page:card,card`.
- ⚠️ This sentence used to restate that table's answer instead of pointing at it, and
- the very commit that edited the sentence moved the figure — a count copied into prose
- is what AGENTS.md #9 forbids, so the instrument replaces the number. Read the table
- for three things: `card` + `body` is a control that FIRES on the head that ships (so
- a zero elsewhere is a reading, not a blind spot), every node still carrying `body`
- under these keys falls in the `test` bucket, and `page:section` is a LIT zero — 6
- nodes resolved, 0 `body`, 4 `children` — rather than a key nobody asked about.
- Retiring the THREE THIN reads is objectui#9916,
- which asks for the stored-corpus reading they turn on; `page:card`'s read is not
- that card's either — it is objectui's own, grounded by objectstack#5775 /
- ADR-0087 D2 rather than owned by it, and it ends when the stored rows have been
- replayed through the conversion that already shipped for it.
- - **The published type.** `BaseSchema.body` is `never` on the TypeScript face and an
- alias refusal naming `children` on the Zod mirror, as are the four per-component
- redeclarations (`CardSchema`, `AspectRatioSchema`, `PageNodeSchema`, `TooltipSchema`).
- ⚠️ Refused **by name**, not deleted: `BaseSchema` carries an index signature and the
- mirror ends `.passthrough()`, so a deleted member would be accepted silently and
- rendered by nothing — the exact silence this retirement ends.
- - **The VS Code extension (`object-ui`) changes behaviour, not just teaching.** Its
- preview no longer draws a `body`-spelled document — the node renders empty, the way
- the runtime renders it — and its validator now emits a warning naming `children` at
- the key's own position. That warning is skipped for node types that declare their
- own `body` input (`record:alert`), so a declared translation-map `body` is not
- reported as the retired spelling.
- - **Two new `@object-ui/sdui-parser` exports.** `RETIRED_CHILD_LIST_KEY` (the retired
- spelling, so a consumer names it once) and `checkRetiredBodyDialect` (the diagnostic
- the tier substitutes for `unknown-prop` on that key).
- - **The authoring tier.** `sdui-parser` answers an authored `body` with the replacement
- named, instead of the bare "has no prop" every typo gets — and a `body` child list
- under a non-container draws the same containment code the `children` spelling draws.
- - **Corpus and teaching, in the same change.** 114 authored nodes across the docs site,
- the schema catalog, five package READMEs and the VS Code extension's snippets, JSON
- schema, syntax map, hovers and completions. The platform does not refuse a spelling it
- still ships.
-
- ## Migrating
-
- Rename the key. `{ "type": "card", "body": [...] }` becomes
- `{ "type": "card", "children": [...] }`; both faces now name `children` in the refusal,
- and `pnpm census:body-dialect` reports where the dialect still lives in a tree.
-
- ⚠️ **Four renderer reads are deliberately untouched, all in the `page:*` namespace** —
- `page:card` and the three thin `page:section` / `page:footer` / `page:sidebar`
- containers. They are read-only back-compat paths for STORED documents, not a second
- authoring face: `@objectstack/spec`'s `PageContainerProps` says so itself — `children`
- is canonical, `body` is deliberately not declared, and «the renderers keep reading
- `body` as a back-compat fallback for stored documents; that fallback is objectui's to
- retire on its own schedule».
-
- ⛔ **Authoring `body` on them is still refused**, on both published faces and at the
- authoring tier, exactly as everywhere else. What survives is the READ.
-
- ⚠️ The two halves are not in the same state. `page:card` has a migration path — the
- spec's conversions registry carries `page-card-body-to-children` (`toMajor: 17`,
- surface `page.component.page:card.body`), which shipped with `retiredFromLoadPath: true`
- in spec 17.0.0. The other three have **no conversion at all**, so a stored row under
- their key has nowhere to be migrated to. ⇒ the two halves are tracked separately, and
- the pointer is not one card: retiring the three thin reads is objectui#9916, whose
- question is the stored corpus; retiring `page:card`'s read was **grounded by**
- objectstack#5775 / ADR-0087 D2, whose conversion has already shipped and whose
- remaining condition is replayed rows. ⚠️ Grounded by, not owned by — the distinction
- is the point. objectstack#5775 is CLOSED and its body is a props-declaration audit
- that carries no such step, so a reader sent there for the action finds none. The
- action is objectui's, on the spec's own terms quoted above: «that fallback is
- objectui's to retire on its own schedule.»
-
- **Non-rendering readers keep their arm on the same rule**, and none of them renders
- anything: while a renderer still reaches stored `body` content, a reader that must see
- the SAME content keeps its arm, or the renderer draws what the reader cannot find.
- Those are the two tab-subtree walkers in `renderers/layout/containers.tsx`,
- `app-shell`'s `pageSchemaIntrospect` (`CONTAINER_KEYS`) and `PageBlockInspector`
- (`STRUCTURAL_PROP_KEYS`, the inspector half of a stored `properties.body`), and the
- CLI's `OBJECTUI_STRUCTURAL_KEYS` — a file-IDENTIFICATION marker, where keeping `body` is
- what lets an old file still be recognised as an ObjectUI node and therefore refused,
- instead of silently not judged.
-
- ⚠️ **Dated note, 2026-10-02 — the `sidebar-*` parts are retired — objectui#10859.**
- Later in this same release objectui#10859 batch 8 (phase 2d) unregistered the ten `sidebar-*` part keys. Of the
- family the **Renderers** line names, only `sidebar` remains, and it reads `children`. The rest of this entry is
- kept as the reading of this change.
-- 9e37d9b: `binding` on a component input is framework-set, not author-declared: `@object-ui/types` gains `InjectedComponentInput`, the `'field'` binding arm is retired from `@object-ui/sdui-parser`'s `RegistryConfigLike`, and the `as ComponentMeta` cast at the injection seam in `@object-ui/core` is gone (maintainer ruling of 2026-09-07, director decision batch #69; ADR-0049 enforce-or-remove).
-
- **What was measured.** `binding` was published — the manifest serializer forwards it — and read — `validateTree` records a binding site for it — while `ComponentInput`, the authoring type every registration writes against, did not declare it. The one writer in the tree, `ELEMENT_DATA_SOURCE_INPUT`, therefore carried a hand-written inline type and reached a registration's `inputs` through `as ComponentMeta` in `Registry.register`. Declared narrower than enforced, on a published type — and `ComponentInput`'s own docblock listed `binding` among the forwarded per-input keys.
-
- **The ruling** answered the product question the card asked — may an ordinary registration declare a binding input? — with no. So:
-
- - **`@object-ui/types`** exports `InjectedComponentInput`, an `interface … extends ComponentInput` with the required marker `binding: 'object'`. `ComponentInput` itself does not change: no member is added, and authoring `binding` on a registration stays an excess-property `tsc` error — now on purpose and documented at the interface. The two tombstone docblocks that listed `binding` as a forwarded key now say it is forwarded from the framework's injected input, not authored.
- - **`@object-ui/core`** types `ELEMENT_DATA_SOURCE_INPUT` as `InjectedComponentInput` and splices it through a typed local; the cast is gone. Runtime behaviour is unchanged — the same key, `type`, `binding` and `description` reach the manifest, and `validateTree` still records the binding site.
- - **`@object-ui/sdui-parser`** narrows `RegistryConfigLike.inputs[].binding` from `'object' | 'field'` to `'object'`. The `'field'` arm had zero writers — every `binding:` literal in `packages/`, `apps/` and `examples/` is `'object'`, 7 of 7 at this change's merge-base — and nothing on either side of the manifest resolved a field binding. **Breaking, deliberately:** a config that feeds `manifestFromConfigs` a `binding: 'field'` input is now a type error instead of a manifest entry the server would never resolve. `ManifestInput.binding`, the manifest reader's vocabulary, is not narrowed by this change.
-
- If a real need for author-declared bindings is ever measured, it is filed as a widening of `ComponentInput` with the vocabulary decided then — not by putting the cast back.
-- 492bbd8: Refuse an authored `type=` attribute on the `kind:'html'` tier (objectui#7235 — the
- port of objectstack#13957, maintainer ruling 2026-09-01, recorded as an append-only
- amendment on ADR-0080).
-
- **Breaking, deliberately, and the direction is a narrowing.** On this tier the tag
- name *is* the node's `type`, so an authored `type=` attribute is a name collision
- with the envelope's own discriminator. It is now one `forbidden-attr` error naming
- both the tag and the attribute, and the node is composed as `{ ...props, type: tag }`
- so the tag always wins the slot.
-
- Two outcomes it replaces, the first of which produced no diagnostic at all:
-
- - the value named another **registered** type (``) — the tree
- carried `type:'grid'`, the manifest resolved it, every check passed, and a grid
- rendered where the author wrote a flex. Zero diagnostics.
- - the value named **nothing registered** (``) — loud, but
- `unknown-component` naming `"bar"` read as a missing plugin rather than as an
- attribute that should not be there.
-
- The existing `forbidden-attr` code is reused rather than a new one minted: the two
- copies of this parser (this one, which the renderer and the console's live edit
- preview run, and objectstack's, which the save gate runs) are held to one diagnostic
- vocabulary by `check:sdui-lockstep`, and a code minted on one side only is the dialect
- split that gate exists to catch.
-
- ⚠️ Not carried over: the react tier's `specType` rescue (objectui#2880). The ruling
- declined it by name; that rescue stays where it lives.
-
- One visible non-behavioural consequence of the reversed spread: a compiled node's
- `type` key is now **last** rather than first in insertion order, so `JSON.stringify`
- of a parsed tree emits the same pairs in a different order. The key set, every value,
- the children and the html-tier provenance marker are unchanged.
-- cf1d29e: `ComponentInput.of` — the coarse kind of an input's MEMBERS, with readers on day one
- (objectui#8067).
-
- A registration's `type: 'array'` said a value was a list and stopped there, so a member
- that drifted from `@objectstack/spec` was invisible to every layer that reads a
- declaration. `page:header.actions` is the measured cost: the contract declares
- `z.array(z.string())` ("Action IDs"), the renderer read the members as `ActionDef`
- objects, and the repo-wide parity gate in
- `apps/console/src/__tests__/registry-inputs-spec-parity.test.ts` stayed green for the
- whole life of the drift because both sides carried the key and neither could say what
- was inside it. What settled it was a maintainer ruling, not a test — and even after the
- fix, "these are ids" survived only as English in the registration's `description`.
-
- **What is new.** `ComponentInput` gains an optional `of`, carrying the same coarse-kind
- vocabulary as `type` one level down: the ELEMENTS of an `array`, or the VALUES of an
- `object` used as a map. One kind, or an array of them for a member contract that is a
- union, with `type`'s semantics — a member passes when any declared arm accepts it. The
- manifest serializer forwards it, so `sdui.manifest.json` now carries seven keys per
- input instead of six.
-
- **Three readers ship with it**, which was the bar this slot had to clear (objectui#5905
- is the precedent: five `ComponentInput` keys declared and read by nothing). The
- repo-wide parity gate compares every declared `of` against the member kind
- `ComponentPropsMap[type]` actually accepts and fails on one the contract refuses;
- `sdui-parser`'s `validateTree` reports a member that fits no declared kind, as a new
- `member-type-mismatch` diagnostic naming the offending positions; and the generated
- `sdui-intrinsics.d.ts` narrows the authoring type — `page:header`'s `actions` is
- `string[]` where it used to be `unknown[]`.
-
- **Fifteen keys now declare one**, across ten blocks, each DERIVED rather than chosen:
- every container key's member position was probed with one value of each coarse kind and
- a declaration written only where exactly one kind was accepted. A member contract that
- admits several kinds — `record:highlights.fields` takes a field name or an inline field
- object — is deliberately left undeclared and pinned with its reason, because picking one
- arm there is a narrowing this repo leaves un-gated and picking all of them would
- advertise shapes only a per-block pin can vouch for.
-
- **The ceiling is unchanged.** `of` is a KIND and never a value domain, so the maintainer
- ruling of 2026-08-17 quoted on `ComponentInput.type` — the coarse arm plus `description`
- is the publication face's expression ceiling, and spec is the sole judge of values —
- stands exactly as written. `of: 'object'` says the members are objects; which keys they
- carry is still `description`'s job and `os validate`'s.
-
- **Nothing published before this changes.** An input that declares no `of` validates,
- serializes and types byte-identically: `validateTree` checks no member, the serializer
- emits no key, and the codegen emits the same `unknown[]`.
-- 80cb063: html tier: name the inert `quickAdd` on `object-kanban` / `kanban` instead of calling it unknown
-
- The Quick Add control is gated on BOTH `quickAdd` and an `onQuickAdd` handler, and
- `onQuickAdd` takes a function, which no parsed page can write and which `ObjectKanban`
- supplies none of its own for. objectui#11234 retires `onQuickAdd` on `object-kanban` in the
- same release; it remains a host-supplied prop on `KanbanRenderer`'s `schema`. So an authored
- `quickAdd: true` on either
- `ObjectKanbanRenderer` tag has never produced a control.
-
- Until now the only thing the tier said about it was `unknown-prop`, "has no prop
- quickAdd" — false against `@objectstack/spec`, which publishes the key, and
- indistinguishable from a typo. It now draws an `inert-quick-add` **warning** that names
- the missing half of the pair and points at `kanban-ui`, where a React host can supply
- the function. Severity is unchanged (warning, as `unknown-prop` was), so no page that
- saves today stops saving.
-
- New exports: `checkKanbanQuickAdd`, `INERT_QUICK_ADD`, `QUICK_ADD_HOST_TYPES`,
- `QUICK_ADD_KEY`.
-
- Interim by ruling (objectui#8285, decision batch #91): the contract-side refusal is
- retiring `object-kanban.quickAdd` from the spec's `ComponentPropsMap`, and this
- diagnostic is removed by the change that lands it. `kanban-ui` keeps the
- `quickAdd` / `onQuickAdd` pair untouched.
-
- ⚠️ **Dated note, 2026-09-29 — the contract moved in this same release — objectui#11073.**
- The reason given above, that "has no prop quickAdd" was false because `@objectstack/spec` publishes the key, no longer holds. Later in this release this repository began resolving `@objectstack/spec` 17.5.0, which carries the retirement this diagnostic was declared interim for: `object-kanban.quickAdd` is now a spec tombstone, refused by name at the authoring door. The diagnostic's own removal belongs to the change that ruled it and is not made here. Until then, the key it names is one the contract itself refuses.
-- 6f864cf: **BREAKING** — `quickAdd` is retired on `object-kanban` (objectui#8285, ruling B of
- the director seat's decision batch #91: the board does not grow an inline
- record-creation write path). This is objectui's half; `@objectstack/spec` 17.5.0
- already tombstones the same key in `ComponentPropsMap['object-kanban']`.
-
- **Why it never did anything.** The Quick Add control is gated on BOTH `quickAdd`
- and an `onQuickAdd` handler. `onQuickAdd` is a host-supplied function that no JSON
- document can carry, and `ObjectKanban` supplies none of its own, so an authored
- `quickAdd: true` parsed green and drew nothing.
-
- - **`@object-ui/types`** — `ObjectKanbanSchema.quickAdd` is `?: never` on the
- TypeScript face and a `retirementTombstone()` on the zod mirror: an authored
- value is refused BY NAME (`invalid_type` at `quickAdd`, carrying the remedy), not
- stripped. A tombstone rather than a deletion, because `BaseSchema` ends
- `.passthrough()` and a deleted member would be kept silently.
- - **`@object-ui/plugin-kanban`** — `ObjectKanban` no longer forwards `quickAdd` to
- the board, on every `object-kanban` entry point (the registered tag, the
- `kanbanComponents` map, a host mounting `ObjectKanban`). So even a document that
- carries both halves of the pair draws no control. `KanbanRenderer` is unchanged:
- a React host that mounts it directly still passes `quickAdd` and `onQuickAdd` on
- its `schema` and gets the control.
- - **`@object-ui/sdui-parser`** — the interim `inert-quick-add` warning is removed,
- with its four exports `checkKanbanQuickAdd`, `INERT_QUICK_ADD`,
- `QUICK_ADD_HOST_TYPES` and `QUICK_ADD_KEY`. It was declared interim until the
- spec refused the key by name; that has landed, and with the key retired on every
- face the tier's own `unknown-prop` warning ("has no prop quickAdd") is true and
- is the whole remedy on a constrained-JSX page, which cannot write the handler
- anyway. Severity is unchanged (warning), so no page that saves today stops saving.
-
- **Migration.** Delete `quickAdd` from `object-kanban` nodes; it never drew a
- control there. To offer Quick Add, mount `KanbanRenderer` from
- `@object-ui/plugin-kanban` in a React host and pass both `quickAdd` and
- `onQuickAdd` on its `schema`. Code that switched on the `inert-quick-add`
- diagnostic code, or imported one of the four removed names, drops that branch:
- the key now draws `unknown-prop` like any other prop the block does not have.
-
- `ObjectKanbanSchema.onQuickAdd` is retired on `object-kanban` too, by objectui#11234
- in the same release: on that element it was never called, because its partner is
- gone. The Quick Add pair on `KanbanRenderer` is unchanged.
-- 483b794: Retire the `binding: 'field'` arm on the manifest READER and PRODUCER faces, so
- `@object-ui/sdui-parser` states one vocabulary instead of two (objectui#8315).
-
- The 2026-09-07 maintainer ruling that `9e37d9b39` landed (director decision batch #69)
- retired the zero-writer `'field'` arm under ADR-0049 enforce-or-remove, naming
- **one** coordinate: `RegistryConfigLike.inputs[].binding`, the serializer's input
- boundary, which PR #8297 narrowed. Two declarations in `types.ts` kept the arm, so
- the published package narrowed on one face and stayed wide on the other:
-
- - `ManifestInput.binding` — now `'object'`
- - `ManifestValidationResult.bindings[].kind` — now `'object'`
-
- **Breaking for TypeScript consumers, deliberately, and compile-time only.** A
- hand-written `Manifest` literal or a `bindings[]` entry that spells `'field'` is now
- a `tsc` error. Runtime behaviour is unchanged: types are erased, this package has no
- runtime validator for a manifest it is handed, and `validateTree` still forwards
- whatever a manifest says — a pin in
- `src/__tests__/injected-component-input-6950.test.ts` states that limit so the
- narrowing is not mistaken for a runtime rejection.
-
- **Migration.** Nothing measured has to change. `binding: 'field'` has zero writers in
- this repo and zero in the objectstack copy of this package (measured 2026-09-09 on
- both heads, each with a firing `binding: 'object'` control), and the only manifest
- producer in either tree is `manifestFromConfigs`, whose input face was already narrow.
- Every `binding: 'field'` spelling left under `packages/`, `apps/` and `examples/` is
- an `@ts-expect-error` negative pin asserting the refusal, or a docblock mention of
- the retirement — not a writer.
-
- **Why not leave the reader face wide.** The counter-argument — producer → reader is a
- subset relation, so a permissive reader is not wrong — was answered rather than assumed
- away. `ManifestInput` is not a pure reader face (`manifestFromConfigs` returns it), and
- `bindings[].kind` is a pure **producer** face where the relation inverts: a wider union
- there accepts nothing extra, it obliges every consumer to handle an arm this package
- cannot emit. The two are coupled by `validateTree`'s `kind: input.binding` assignment,
- so narrowing one alone would need a cast at the only conversion site — the lenient
- fallback AGENTS.md #0.1 bans. The reasoning now lives on the declarations themselves,
- where a later reader lands. The reopen route is the ruling's own: a measured need for
- field bindings is filed as a widening with the vocabulary decided then.
-- adf5812: Four node type keys retire, and the kanban and gantt families converge on their
- `object-*` spellings: `kanban` (objectui#8802), `kanban-ui` and `kanban-enhanced`
- (objectui#8257), and `gantt` (objectui#8008). All four were ruled by the
- maintainer in one batch on 2026-09-09.
-
- **⛔ No stored document moves.** The strings `kanban` and `gantt` name two
- different things at two different layers, and only one of them is retiring:
-
- | layer | value | who writes it | retired? |
- | --- | --- | --- | --- |
- | stored `NamedListView.type` | `"kanban"`, `"gantt"` | `CreateViewDialog`, persisted per tenant | **no — untouched** |
- | node type key | `kanban`, `gantt` | hand-authored JSON | **yes** |
-
- `ObjectView`'s `switch (viewType)` maps a stored view type onto the node type it
- renders, and it already emitted `object-kanban` and `object-gantt` — as it does
- for all twelve stored view types. So every kanban and gantt view any user ever
- created through the console already renders through the surviving spelling.
- Nothing in a tenant database changes, and ⛔ nothing should be migrated there.
-
- **What each retirement was, measured.** Three of the four were
- registration-only: no schema face in `@object-ui/types` ever declared
- `kanban-ui`, `kanban-enhanced` or `gantt` as a component node type, so
- unregistering is the whole retirement. The bare `kanban` key was the exception —
- it had a declared arm on both faces (`KanbanSchema` in `complex.ts` and its Zod
- mirror), and a plain deletion there would have been the objectui#7664 failure:
- `BaseSchema` is `.passthrough()`, so a document naming a dropped key validates
- green and renders nothing. It therefore retires as a **named refusal**: the Zod
- union keeps an arm claiming the literal and answers a `{ "type": "kanban" }`
- document with a message naming `object-kanban` as the remedy, while the
- TypeScript half is the absence of the arm from `ComplexSchema` and of the key
- from `SchemaRegistry`, so `tsc` refuses it at the authoring site.
-
- **⭐ This closes objectui#8818's `objectFields` hole — for that ENTRY, not for
- the class.** `SchemaRenderer` strips a fixed enumerated metadata list and
- spreads the rest as React props; `objectFields` is not on that list, and
- `KanbanRenderer` — the component the `kanban-ui` key resolved to — declares
- `objectFields` as a real prop, so an authored value reached the predicate layer
- with no schema face judging it. With the registration gone, no authored node
- reaches that component through the registry. ⚠️ The **class** is still open: the
- hole returns the moment another registered renderer declares an `objectFields`
- prop. objectui#8818's option (a) — stripping at the `SchemaRenderer` boundary —
- is what would close the class.
-
- Superseded in this release by objectui#8818: option (a) landed, so the class
- is closed as well. `objectFields` is now on `SchemaRenderer`'s stripped-metadata
- list, and the legacy `props` alias bag drops it too, so an authored
- `objectFields` reaches no component prop on any type key. The paragraph above
- describes the tree this entry was written against.
-
- **⚠️ What the `kanban` arm took with it, stated because it is the cost of this
- change.** That arm was the only schema face that ever declared `columns`,
- `cardTitle`, `swimlaneField`, `grouping` and `navigation`, the only one that
- refused `allowCollapse` / `cardTemplates` / `columnWidths` / `titleField` /
- `draggable` / `onColumnAdd` / `onCardAdd` by name, and — through
- `columns: KanbanColumn[]` — the only one that judged a lane's `cards`
- (`240b80f31`).
-
- ⭐ **The sentence that stood here — «The surviving `ObjectKanbanSchema` face
- declares none of them» — is retired, and the two reasons it failed are DIFFERENT
- defects (objectui#9713).** It is replaced by a dated reading rather than silently
- overwritten, because half of it was true when written and erasing that would be a
- false record of its own:
-
- | key named just above | on `ObjectKanbanSchema` when this entry was written (`adf581278`, 2026-09-10) | on `main`, 2026-09-17 | what moved |
- | --- | --- | --- | --- |
- | `columns` | not declared | **declared** | objectui#8913 (PR objectui#8989), six hours after this entry was written |
- | `cardTitle` | not declared | **declared** | objectui#9606 (PR objectui#9709) |
- | `titleField` | **declared** | **declared** | nothing — the sentence was never true of this key |
- | `allowCollapse` | **declared**, a live `z.boolean().optional()` | **declared**, as a `retirementTombstone()` | objectui#8801 retired it; it was declared on this face throughout |
- | `swimlaneField`, `grouping`, `navigation`, `cardTemplates`, `columnWidths`, `draggable`, `onColumnAdd`, `onCardAdd`, and a lane's `cards` | not declared | not declared | nothing |
-
- ⇒ For `columns` and `cardTitle` the claim **ROTTED**: it was true on 2026-09-10 and
- was falsified afterwards by cards that had no reason to read this file. For
- `titleField` and `allowCollapse` it was **BORN FALSE**: those two are named above as
- keys the `kanban` arm refused BY NAME — which the surviving face indeed does not do
- — but the surviving face declared both of them the whole time, and «declares none of
- them» said otherwise. ⛔ Do not restate any of this in the present tense: a pending
- entry publishes verbatim into the CHANGELOG, and an undated present-tense claim
- about another file is the construction that failed here.
-
- ⛔ Nothing about an `object-kanban` document changes: it was never judged by the
- `kanban` arm, so all of those keys have always ridden `BaseSchema`'s index
- signature there. What is gone is the `kanban` document that had them. Declaring
- them on `ObjectKanbanSchema` would WIDEN a published accept set, which is a
- maintainer ruling and not part of this one; every one of these readings is
- pinned where it can be seen rather than left to be rediscovered.
-
- **Migrating.** Replace `"type": "kanban"` with `"type": "object-kanban"` and
- `"type": "gantt"` with `"type": "object-gantt"` in hand-authored documents. The
- `object-kanban` face requires `groupBy` and one of `bind` / `data` /
- `objectName`; a purely static board (lanes carrying their own cards, no record
- source) adds `"groupBy"` and `"data": []`. `kanban-ui` and `kanban-enhanced`
- have no authored documents anywhere in this repository to migrate.
-
- **⚠️ The namespaced spellings retire with the registrations — `view:kanban` and
- `view:gantt` are the same two keys.** `ComponentRegistry.register(type, C,
- { namespace })` stores BOTH `namespace:type` and a bare-`type` fallback, so
- every one of these keys had a namespaced twin that goes with it:
-
- | retired spelling | namespaced twin | author instead |
- | --- | --- | --- |
- | `kanban` | `view:kanban` | `object-kanban` |
- | `gantt` | `view:gantt` | `object-gantt` |
- | `kanban-ui` | `plugin-kanban:kanban-ui` | `object-kanban` |
- | `kanban-enhanced` | `plugin-kanban:kanban-enhanced` | `object-kanban` |
-
- Both spellings are pinned as gone, each against a firing control on the
- surviving key, in `plugin-kanban/src/__tests__/kanban-family-registry-keys-retired-8257.test.ts`
- and `plugin-gantt/src/__tests__/bare-gantt-node-key-retired-8008.test.ts`.
-
- **What an unmigrated `view:kanban` / `view:gantt` node now renders depends on
- the host.** In `apps/console` it renders the protocol **placeholder** panel, not
- the OBJUI-001 "Unknown component type" error: the console calls the opt-in
- `registerPlaceholders()` (`@object-ui/components`, `renderers/placeholders.tsx`)
- *after* its plugin registrations, `view:kanban` and `view:gantt` are both in
- that file's `PROTOCOL_COMPONENTS` list, and the placeholder only claims a key
- nothing else has taken — which, until this change, `@object-ui/plugin-kanban`
- and `@object-ui/plugin-gantt` had. In every other host, which does not call that
- bootstrap, the same node renders OBJUI-001.
-
- **⚠️ `objectui check` will NOT flag either namespaced spelling.** The CLI's
- `known-schema-types.ts` is generated from the repository's real registration
- calls, and the placeholder registration is a real one — so `view:kanban` and
- `view:gantt` are still on that list and still validate green, while the node
- renders a placeholder rather than a board. The bare `kanban` / `gantt` entries
- DID leave the generated list; only the namespaced pair survives, and only
- because of the placeholder. Grep your documents for the namespaced spellings
- directly; do not rely on `objectui check` to find them.
-
- `KanbanRenderer` is still exported from this package's entry point
- (`@object-ui/plugin-kanban`); only its registry key is gone. ⚠️ `KanbanEnhanced`
- is a different case, and the earlier draft of this note stated it wrongly: this
- package's `exports` map has exactly two entries — `.` and `./style.css` — and
- the barrel never re-exported the component, so
- `@object-ui/plugin-kanban/KanbanEnhanced` has never been a resolvable specifier
- for a consumer. At this change, with `kanban-enhanced` unregistered,
- `KanbanEnhanced.tsx` had zero non-test importers, and the file was deliberately
- left in place: deleting published-but-unreachable source is a further narrowing
- and needed its own maintainer ruling, which this change did not have.
-
- ⚠️ **Dated note, 2026-09-25 — that ruling came, and the file has since been
- deleted — objectui#8932.** Later in this same release
- `packages/plugin-kanban/src/KanbanEnhanced.tsx` was deleted, and with it the
- `dist/KanbanEnhanced.d.ts` typings this package shipped for it. The rest of this
- entry is kept as the reading of this change; the objectui#8932 entry states what
- ships.
-
- **⚠️ `@object-ui/sdui-parser`: `QUICK_ADD_HOST_TYPES` loses `kanban` with the
- registration.** The `inert-quick-add` diagnostic (objectui#8285) named the two
- tags `ObjectKanbanRenderer` answered to; one of them retires here, so the set is
- now `{ 'object-kanban' }`. ⛔ Nothing is silently dropped by that narrowing, and
- this is measured rather than argued: `checkKanbanQuickAdd` has exactly one call
- site — `validate.ts`'s per-prop walk — and that walk runs only in the branch
- where the manifest RESOLVED the tag. A tag no registration produces is answered
- one level up by `unknown-component`, an **error**, and its props are never
- walked, so on a manifest built from the live registry a `` node
- draws `error/unknown-component` and nothing else, against a firing control on
- `` that still draws `warning/inert-quick-add`. Keeping
- `kanban` in the set would have been reachable only through a hand-built manifest
- declaring a component of that name — which, after this retirement, is somebody
- else's component, and the message asserts things about `ObjectKanban` that would
- be false of it. This supersedes the `kanban` half of the objectui#8285 entry.
-
- **The diagnostic's remedy text moves from a tag to a component.** It used to end
- "render `` from a React host that passes `onQuickAdd`". That sentence
- is falsified by this change: `kanban-ui` is no longer a node type key, so a page
- written to the old advice draws `unknown-component`. It now names
- `KanbanRenderer` from `@object-ui/plugin-kanban` — still exported, still
- forwarding both halves by identity — which is the surviving way to get the pair.
- `content/docs/plugins/plugin-kanban.mdx` says the same thing the same way.
-- 5ea623e: fix(sdui-parser,components,layout,types): containment is the declared `children` slot, not `isContainer` (objectui#9910)
-
- `validateTree`'s `not-a-container` diagnostic now reads exactly one declaration:
- an input named `children` in the component's registration `inputs`. Ten
- registrations already carried such an input — `slot`-typed on `tooltip` and the
- four `page:*` containers, `array`-typed on the five page kinds — and the
- predicate reads the NAME, so both count. `isContainer` is no longer
- consulted and is not a fallback — new exports `acceptsChildren` and
- `CHILD_LIST_KEY` in `@object-ui/sdui-parser` spell the predicate, and the
- retired `body` dialect follows the same reading.
-
- Why: the flag was hand-kept and drifted from the renderers four times; after
- objectui#6771 converged a dozen `schema.body` readers onto `children`, and with
- objectui#6804 ruling the flag OFF for that population (it means layout
- containment, and declaring it deletes a public tag from every react page's JSX
- scope), the diagnostic landed FALSE on the one key `button`, `badge`, `alert`
- and the `sidebar-*` parts render. The maintainer ruled declare-and-pin
- (2026-09-24).
-
- What is declared: every renderer under `@object-ui/components` and
- `@object-ui/layout` that puts `schema.children` on the page — 65 registrations
- measured bare plus `sidebar` and `sidebar-menu-button` in their provider
- context — now declares the `children` slot; the 34 flow/inline HTML tags, the
- seven sectioning tags, the layout primitives, `button` / `badge` / `alert` /
- `toggle` (label and description fallbacks), `span` (read ahead of `value`),
- `div`, `form`, `scroll-area`, the ten `sidebar-*` parts and `page-header`. Nine public blocks
- gain the slot in `sdui.manifest.json`; a `slot` input emits no JSX attribute, so
- the generated `.d.ts` is unchanged. `isContainer` is kept everywhere it was
- declared and re-described on every published face (`ComponentMeta`,
- `RuntimeWidgetManifest`, `ComponentMetaSchema`, the manifest types) as LAYOUT
- containment — the react-page scope builder keeps reading it unchanged.
-
- The runtime containment census is re-pointed from the flag to the input in both
- directions (declared ⇔ actually renders, with named context probes for the
- provider-scoped and portal renderers), `scripts/container-declaration-baseline.json`
- is at zero, and a registration that is a layout container but renders no
- authored list (`page:tabs`, `page:accordion`, `responsive-grid`) now draws the
- TRUE `not-a-container` the flag used to silence.
-
- ⚠️ **Dated note, 2026-10-02 — `page-header` is retired — objectui#10859.**
- Later in this same release objectui#10859 batch 8 (phase 2c) unregistered `@object-ui/layout`'s
- `page-header` (and `layout:page-header`), so its `children` slot declaration left with it; authors write
- `page:header`. The rest of this entry is kept as the reading of this change.
-
- ⚠️ **Dated note, 2026-10-02 — `responsive-grid` is retired — objectui#11441.**
- Later in this same release objectui#11441 unregistered `@object-ui/layout`'s `responsive-grid` (and
- `layout:responsive-grid`), so it no longer draws `not-a-container`: a node written with it renders the "Unknown
- component type" panel. Authors write `grid` with a breakpoint `columns` object. The rest of this entry is kept as the
- reading of this change.
-
- ⚠️ **Dated note, 2026-10-02 — the ten `sidebar-*` parts are retired — objectui#10859.**
- Later in this same release objectui#10859 batch 8 (phase 2d) unregistered the ten `sidebar-*` parts, so their
- `children` slot declarations left with them. `sidebar` keeps its declaration, and it now mounts its own provider
- when none is above it, so the containment census measures it bare and its provider-scoped context probe is
- gone, as is `sidebar-menu-button`'s. The rest of this entry is kept as the reading of this change.
-- 8d58f46: `validateTree` now reports a dashboard widget `options` key that no renderer
- consumes as a `unconsumed-widget-option` **warning** naming the consumed set
- (maintainer ruling 2026-08-23). The census behind the accepted set — the spec's five
- declared query keys (`dateGranularity`, `sortBy`, `sortOrder`, `limit`,
- `stageOrder`) plus the `description` sub-caption convention key — is
- re-measured on every test run against `@objectstack/spec` and the
- `plugin-dashboard` renderer sources. The check fires only on dataset-bound
- shorthand widgets (the spec-legal form) hosted by `dashboard` /
- `dashboard-grid` nodes, and honours the spec's per-widget
- `suppressWarnings: ['unconsumed-widget-option']` escape hatch. Warning
- severity only: documents keep parsing, saving and rendering. Exported for
- other surfaces: `checkDashboardWidgetOptions`, `CONSUMED_WIDGET_OPTION_KEYS`,
- `DASHBOARD_WIDGET_HOST_TYPES`, `UNCONSUMED_WIDGET_OPTION`.
-
-### Patch Changes
-
-- 39b8d51: feat(components): `div` is deprecated on the html tier too — a `kind:'html'` page that authors `
` is refused at compile time, and the error names `box`
-
- Executes the maintainer's ruling A on objectstack#20112 ("`div` stays
- deprecated") in the renderer. Until now the published manifest left `div` out of
- the html tier, so `os validate` refused a `
` page as `forbidden-tag`, while
- the console compiled and rendered the same page. `div`'s registration declared
- the deprecation for the JSON surface only, and its renderer exempted nodes the
- html parser emitted (objectui#4000).
-
- **What moves for a consumer.**
-
- - **BREAKING (authoring): a `kind:'html'` (or legacy `kind:'jsx'`) page that
- authors `
` or `` no longer renders.** The html compile fails, and
- like every compile error this fails the whole page: the console shows the
- "HTML page failed to compile" panel. Each refusal is the parser's
- `forbidden-tag` sentence, followed by the declared replacement guidance, which
- names `box`. Migration: retype `
` to ``. `box` renders the same
- element with the same `className` and no layout of its own.
- - `div`'s registration now declares `deprecated.surfaces: ['json', 'html']`, so
- `ComponentRegistry.deprecationFor('div', 'html')` answers the declaration
- (with the unchanged `replacement`) instead of `undefined`. The html compile
- derives what it refuses from `deprecationFor(type, 'html')`, the registration's
- declaration, rather than from a list of tag names.
- - The `div` renderer no longer exempts nodes carrying html-tier provenance, and
- its dev-build notice now says it applies to JSON-authored nodes and html pages
- alike. The migration bullets are unchanged.
- - `span` is unchanged: it is still deprecated on the JSON surface only, and it
- still compiles on html pages.
-
- Semver: `minor`, not `major`, per this repository's version-alignment rule. The
- breaking semantics are stated above.
-
- **Published declaration text (prose only, no behaviour change).**
-
- - `@object-ui/core`: the emitted `dist/registry/Registry.d.ts` carries the
- rewritten `ComponentDeprecation` and `deprecationFor` docblocks, where `span` is
- now the worked example of a json-only deprecation and `div` is stated to name
- both surfaces. `dist/registry/html-tier-intrinsics.d.ts` carries the rewritten
- `HTML_TIER_INTRINSICS` docblock: its `div` bullet and the sentence describing the
- console's html-tier whitelist.
- - `@object-ui/sdui-parser`: the emitted `dist/provenance.d.ts` carries the
- rewritten file-header sentence, where `span` is now the example of a tag that
- stays html-tier vocabulary.
-- 99878d8: `validateTree` no longer calls a declared `bind` or `hidden` unknown (objectui#11008).
-
- `BaseSchema` declares `bind` and `hidden` for every node, and no registration declares either as an input. `validateTree`'s base-prop set held neither, so its undeclared-key branch answered every authored one with an `unknown-prop` warning (`has no prop "bind"`), including on the nodes that honour it: `list`, `tree-view` and the `object-*` widgets read `bind` through `useDataScope`, and `SchemaRenderer` reads `hidden` for every node. Both are now base props of the parser tier, so neither draws a diagnostic on any node. A near-miss spelling such as `bindTo` still draws `unknown-prop`.
-
- The cost is named rather than hidden. `data-table` does not read `bind` (objectui#6575), and a `bind` on it now draws nothing at the parser tier either. Its render-time console warning (`[ObjectUI] DataTable bind:`) is the one signal left. The `BaseSchema.bind` docblock, which ships in the emitted `.d.ts`, said that the console warning and the parser tier's `unknown-prop` both named such a `bind`. It now names the console warning as the one signal and says the parser tier is silent. That supersedes the wording the objectui#10981 entry describes for the same docblock: the parser half it names held until this change.
-
- At this change, `placeholder` is also a `BaseSchema` member that `validateTree` does not count as a base prop, and it is left as it was. Some registrations declare it as a typed input, and a base prop skipped the declared-input lookup, so adding it would have silenced their `type-mismatch`.
-
- ⚠️ **Dated note, 2026-09-29 — `placeholder` has since become a base prop where a type does not declare it — objectui#11044.** Later in this same release, `placeholder`, `name`, `label`, `description`, `data` and `ariaLabel` join the base props as `where-undeclared` members: each is a base prop only on a type that declares no input of that name. Where a type declares one, the declared input wins and keeps its `type-mismatch`, so no declared type check is silenced. The paragraph above is kept as the reading of this change; the objectui#11044 entry states what ships.
-- faf5269: A dataset-bound KPI tile now renders the sub-caption its author declared in
- `options.description` (objectui#7293).
-
- The sub-caption slot was wired end to end and consumed by nothing. It has its own
- translation key (`{ns}.dashboards.{dash}.widgets.{id}.subCaption`), the server's
- `translateDashboard` overlays that translation onto `options.description`, and
- `DashboardRenderer`'s `tWidgetSubCaption` resolves it — but only onto the two
- inline arms of `getComponentSchema()`. `dataset` is REQUIRED on
- `DashboardWidgetSchema` (published `@objectstack/spec@17.4.0`: the required keys
- are exactly `id` / `dataset` / `values`), so every spec-legal widget renders
- through `DatasetWidget` instead, which read the key nowhere. Every author who
- wrote a sub-caption got silence.
-
- `DatasetWidget`'s metric branch now reads the key and renders it in the caption
- row, resolving it through the same `pickLocalized` seam every other authored
- label channel uses, so an inline per-locale map resolves instead of being
- dropped. A tile that declares no sub-caption renders byte-identical markup.
-
- Read in `DatasetWidget` rather than passed down as a prop on purpose: both
- dashboard surfaces (`DashboardRenderer` and `DashboardGridLayout`) route a
- dataset-bound widget to that one component, so a prop from one dispatch site
- would have fixed one surface and left the other unchanged.
-
- `@object-ui/sdui-parser` carries no behaviour change — its `unconsumed-widget-option`
- census recorded `description` as accepted *despite* having no read site on the
- dataset-bound path, and that note is now stale prose.
-- 0b1326d: Documentation no longer teaches the "JSX/HTML + Tailwind" framing for a page's
- `source`, which ADR-0080's own 2026-06-30 header amendment (under ADR-0065,
- Accepted) retracted. objectui#5461 corrected three sites; a multiline census
- found eight more, in three spellings a line-oriented grep could not see.
-
- A page's `source` is *runtime metadata*. The console's Tailwind is compiled at
- build time by scanning the console's own `src`, and there is no safelist, so it
- never sees your page: an authored utility class produces CSS only by coincidence
- (when objectui already ships that exact class) and otherwise produces nothing,
- with no error anywhere. That is the ADR-0065 "works only by coincidence" failure
- mode, and it is how a modal's `bg-black/50` backdrop reached production fully
- transparent. `os validate` reports it as `page-source-className-tailwind`, a
- warning on kinds `html`, `react` and `jsx`, shipped in `@objectstack/lint@11.5.0`.
-
- The tiers themselves are unchanged and every load-bearing claim survives —
- parse-never-execute, the untrusted-author safety argument for `html`, and the
- deprecated `'jsx'` alias. Only the styling primitive is corrected, to the wording
- `content/docs/guide/react-pages.md` §Styling already uses:
-
- | `kind` | Style with |
- |---|---|
- | `"html"` | The blocks' own structured props (`` `` ``, `` `` ``) plus a JSON `style` object. |
- | `"react"` | Inline `style` objects. |
-
- Colors on both tiers come from the theme as `hsl(var(--token))`.
-
- Why each package has an entry — each was measured against its built artefact, not
- assumed:
-
- - **`@object-ui/react-runtime`**: `README.md` is published to npm (npm includes
- `README.md` in the tarball regardless of `files`). Its "no sandbox" callout is
- the paragraph that routes untrusted-author work to the `html` tier, and it
- carried the retracted framing line-wrapped across `:17-18`. It also gains the
- §Styling section it was missing — the absence is why the framing survived here.
- - **`@object-ui/sdui-parser`**: the corrected header of `src/types.ts` projects
- verbatim into the published `dist/types.d.ts`.
- - **`@object-ui/components`**: the corrected header of
- `src/renderers/basic/html-elements.tsx` projects verbatim into the published
- `dist/renderers/basic/html-elements.d.ts`. The `kind === 'html'` dispatch-arm
- comment in `src/renderers/layout/page.tsx` does **not** project (it is inside a
- function body) and is included here only because the same package already owes
- an entry.
-
- No behaviour change: this is prose only. `CHANGELOG.md` occurrences are
- deliberately untouched — immutable release history.
-- 305205a: `kind:'html'` page sources keep the space between a text run and an adjacent
- inline element: `A x page` now compiles to `A `/``/`
- page` and renders as `A x page` rather than `Axpage` (objectui#5661).
-
- The parser collapsed each text run's whitespace to a single space — correct, and
- what HTML itself does — and then `.trim()`ed it, which is not: HTML collapses a
- whitespace run to one space, it does not delete it. The deleted space was
- precisely the separator between a run and its inline sibling, so every authored
- sentence carrying emphasis or a link in the tier the guide recommends by default
- rendered with its words run together. It was silent: the page rendered, the
- structure was right, no diagnostic fired.
-
- The rule is deliberately mechanical rather than a block/inline taxonomy invented
- for a schema tree that has none: keep one leading space when a sibling precedes
- the run, and one trailing space when a sibling element follows it. The parent's
- own start and end still drop their edge space, so `
hi
` is unchanged. - - Its one bounded cost: a whitespace-only run BETWEEN two siblings survives as a - single space, so a pretty-printed `- ` gains one `' '` string child per gap
- between its `
- `s — one space per gap, never the source's newline and
- indentation, never at the container's own edges, and never inside an item's own
- text. That bound is pinned by a test rather than left as a claim.
-
-## 17.6.0
-
-### Minor Changes
-
-- 279fb13: `ComponentInput.type` can declare a UNION, so a block stops warning about legal
- writes its own description recommends
-
- A registration's `type` was one coarse control kind, while a good number of spec
- keys accept more than one shape. A declaration therefore had to pick an arm, and
- the repo's own manifest gate then reported `type-mismatch` on the other arm's
- legal values. Four of the five measured cases were the loud shape: the input's
- `description` teaches the author to write an inline translation map
- (`{ en, "zh-CN", … }`) while the same input's `type: 'string'` made
- `sdui-parser`'s `checkType` warn about exactly that map — one platform authority
- contradicting itself on the write it had just recommended. Because these land at
- warning severity the page still compiled and rendered; the cost is that noise on
- correct authoring trains authors, AI authors included, to dismiss the
- `unknown-prop` and `type-mismatch` reports that are real.
-
- `type` now accepts an ARRAY of coarse kinds as well as a single one (maintainer
- ruling on objectui#3832, direction (a)), and a value passes the coarse check when
- ANY declared arm accepts it. Both declaration sites in `@object-ui/types` move
- together with the registry's own copy in `@object-ui/core`, and
- `ComponentInputSchema` enforces the same widening — a non-empty array of
- DISTINCT kinds, so an empty arm list or a repeated arm is refused at authoring
- time rather than normalized behind the author's back.
-
- Five declarations now spell their real contract, and the `type-mismatch` warning
- on each of these legal writes is gone:
-
- - `page:header.title`, `page:header.subtitle`, `page:card.title` —
- string **or** inline translation map (the spec's union, measured against
- `ComponentPropsMap` at the pinned rc.6; the renderers resolve both through
- `pickLocalized`);
- - `record:alert.title`, `record:alert.body` — the same two shapes, justified
- against the RENDERER since the pinned spec carries no `record:alert` props
- schema;
- - `element:text_input.defaultValue` — `string | number`, the spec's union,
- which had been narrowed to `'string'` with the number arm named only in prose.
-
- **Backward compatible, and measured as such.** The single-kind form stays valid
- and is still the canonical spelling for a one-arm key: it validates identically
- (the diagnostics for one arm, `invalid-enum` and its `error` severity included,
- are byte-identical), and `manifestFromConfigs` collapses a one-element array back
- to the bare string, so every entry already in a published `sdui.manifest.json`
- serializes unchanged and arrays appear only where a union was really declared.
- The JSX authoring surface follows in the same step — `generateDts` emits a
- TypeScript union for a union input, so the `.d.ts` an author type-checks against
- accepts exactly what the gate accepts.
-
- A union widens what is legal; it does not switch the check off. A value matching
- NO declared arm is still reported, a multi-arm mismatch reports at its strictest
- arm's severity (`error` when an `enum` arm is present, so an enum's closed list
- does not become dismissible by having a second arm added next to it), and arms
- are meant to match the contract rather than relax the gate:
- `element:text_input.defaultValue` deliberately gains no `object` arm because the
- spec rejects a map there, and `element:record_picker.emptyText` keeps its single
- `'string'` arm because that renderer drops the map form (objectui#4163) — an arm
- the renderer never honours would advertise a shape that cannot reach the screen.
-
-### Patch Changes
-
-- 40d3a33: `div` 的废弃提示按 provenance 收窄:只对 **JSON 作者面**的节点报,不再对 `kind:'html'` tier 自己解析出的节点开火。
-
- html tier 的页面是一段受限 JSX/Tailwind 文本,由引擎自己的解析器编译(只解析、不执行),标签名原样映射成节点 —— 作者在那一层写下的盒子标签,是该 tier 词表里的一等成员,**没有别的拼法可迁移**。提示照旧对他们开火,给的还是 JSON 作者面的替代建议:一条谁都无法执行的提示不是废弃,是噪声;它同时意味着这个类型永远退不掉,因为引擎自己的编译器一直在产出它。
-
- 判据是**来源**,由生产者确立:解析器给它产出的每个节点打一个 symbol 标记(`Symbol.for` 注册键),渲染器读这个标记。symbol 对 `JSON.stringify` / `Object.keys` / DOM 全部不可见 —— 所以它既不会落进被持久化的文档,也就无法被一份(手写或 AI 生成的)JSON 元数据复制回来给自己买到豁免;通过花括号属性夹带进来的 JSON **不打标记**,那部分本来就是手写的,建议对它成立。
-
- 迁移建议一字未改,JSON 作者面照旧每次模块加载报一次;提示文案现在写明它针对哪一个作者面。
-
-## 17.5.0
-
-## 17.4.0
-
-## 17.3.0
-
-## 17.2.0
-
-### Minor Changes
-
-- 4a51e77: Stop declaring 14 symbols across ten packages under names `@objectstack/spec`
- owns (objectui#3161, objectstack#4115 batch 7 — the long tail, one or two
- entries per package). All ten packages leave the ledger, which drops from 17
- collisions across 11 packages to 3 across 1.
-
- **Renamed exports** — in every case the spec exports the same name for a
- _different_ thing, so the old name was a mis-description rather than a dialect:
-
- | package | was | now | what the spec's same-named export is |
- | :------------------------- | :--------------------------------- | :--------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------- |
- | `@object-ui/fields` | `FieldWidgetProps` | `FieldWidgetComponentProps` | the DECLARED field-widget plugin props contract (a zod object; `field.type` is the `FieldType` enum, `readonly`/`required` carry defaults) |
- | `@object-ui/layout` | `PageHeaderProps` | `PageHeaderComponentProps` | the authored `page:header` node — a zod schema of `title`, `subtitle`, an icon NAME, `breadcrumb`, `actions: string[]` |
- | `@object-ui/layout` | `Page` | `PageNodeRenderer` | the authored page metadata DOCUMENT (`name`, `label`, `type`, `regions`) |
- | `@object-ui/plugin-detail` | `ObjectFieldLike` | `ObjectDefFieldLike` | the i18n duck type `translateObject` walks (`help`/`description`, plus `[key: string]: any`) |
- | `@object-ui/plugin-grid` | `ColumnSummaryConfig` | `ColumnSummarySetting` | the OBJECT form of `ListColumn.summary` **only** — the local one was the whole union, shorthand included |
- | `@object-ui/plugin-grid` | `isMultiValueField` | `hasMultiValueShape` | the spec's classifier, which requires a def with a `type`; the local one is called with `undefined` |
- | `@object-ui/collaboration` | `RealtimeConfig` | `RealtimeSubscriptionConfig` | the app's realtime DECLARATION (`enabled`, `transport`, `subscriptions[]`) |
- | `@object-ui/plugin-charts` | `ChartConfig` | `ChartContainerConfig` | the authored chart document (`type`, `xAxis`, `series`, `showLegend`, …) |
- | `@object-ui/plugin-form` | `FormSection` / `FormSectionProps` | `FormSectionContainer` / `FormSectionContainerProps` | the authored form-section metadata (`name`, `pane`, `visibleWhen`, `fields`) |
- | `@object-ui/providers` | `Theme` | `ThemePreference` | a whole theme DOCUMENT (`name`, `label`, `colors`, `typography`) |
- | `@object-ui/runner` | `App` (default export) | `RunnerApp` | the authored application metadata type **and** the `App.create()` builder |
- | `@object-ui/sdui-parser` | `ValidationResult` | `ManifestValidationResult` | plugin-manifest validation (`{ valid, errors?, warnings? }`), exported from both `kernel` and `contracts` |
-
- `ManifestValidationResult` follows the `
Validation [0]); - -const diagnose = (node: unknown): Diagnostic[] => - validateTree(node as SchemaElement, manifest).diagnostics; - -const LEAF = { type: 'leaf', content: 'x' }; - -/** Every value shape `BaseSchema` declares for the two keys. */ -const BASE_VALUES: Record<'bind' | 'hidden', unknown[]> = { - bind: ['users', 'app.settings.users'], - hidden: [true, false, '${data.role !== "admin"}', { dialect: 'cel', source: "record.status == 'draft'" }], -}; - -describe('objectui#11008 — `bind` and `hidden` are base props of the parser tier', () => { - it('the control node draws nothing', () => { - expect(diagnose(LEAF)).toEqual([]); - }); - - it.each(Object.keys(BASE_VALUES) as Array )( - '`%s` draws no diagnostic, in every value shape BaseSchema admits', - (key) => { - const drew = BASE_VALUES[key] - .map((value) => [value, diagnose({ ...LEAF, [key]: value })] as const) - .filter(([, found]) => found.length > 0) - .map(([value, found]) => `${JSON.stringify(value)} → ${JSON.stringify(found.map((d) => d.code))}`); - expect(drew).toEqual([]); - }, - ); - - it.each([ - ['bindTo', 'users'], - ['hide', true], - ] as const)('lit control: the near-miss `%s` still draws one `unknown-prop` naming it', (key, value) => { - const found = diagnose({ ...LEAF, [key]: value }); - expect(found.map((d) => d.code)).toEqual(['unknown-prop']); - expect(found[0]!.message).toContain(`"${key}"`); - }); - - it('a registration that declares `placeholder` keeps its type check — why `placeholder` is not `every-node`', () => { - expect(diagnose({ type: 'field', placeholder: 'Search…' })).toEqual([]); - const found = diagnose({ type: 'field', placeholder: 42 }); - expect(found.map((d) => d.code)).toEqual(['type-mismatch']); - expect(found[0]!.message).toContain('"placeholder"'); - }); -}); diff --git a/ui/packages/sdui-parser/src/__tests__/base-props-one-list-11044.test.ts b/ui/packages/sdui-parser/src/__tests__/base-props-one-list-11044.test.ts deleted file mode 100644 index 6e22dc272dd..00000000000 --- a/ui/packages/sdui-parser/src/__tests__/base-props-one-list-11044.test.ts +++ /dev/null @@ -1,279 +0,0 @@ -/** - * ObjectUI - * Copyright (c) 2024-present ObjectStack Inc. - * - * This source code is licensed under the MIT license found in the - * LICENSE file in the root directory of this source tree. - */ - -/** - * The base props are ONE list, and both of its readers read it (objectui#11044). - * - * `validateTree`'s `unknown-prop` branch and `generateDts`'s `SduiBaseProps` - * used to keep separate hand-written copies of the base-prop list. They - * drifted: after objectui#11008 the validator accepted `bind` and `hidden` on - * every node, and the generated JSX types still refused both - * (`TS2322 … Property bind does not exist on type ListProps`). Both now read - * `SDUI_BASE_PROPS`. This file pins the tier's reading of a manifest; the - * live-registry half is - * `packages/components/src/renderers/__tests__/base-props-one-list-11044.test.tsx`. - * - * Four facts, kept apart because each fails differently: - * - * - ONE LIST: the generated `SduiBaseProps` block is exactly the list's - * attribute entries, and every entry is accepted on a node that declares - * nothing, while a near-miss spelling still draws `unknown-prop` (the lit - * control — without it, "draws nothing" would also pass against a tier - * that stopped warning on undeclared keys); - * - MEMBER 1: `visibleWhen` and `testId` are accepted on every node, as - * `bind` and `hidden` are; the retired `visibleOn` / `hiddenOn` / - * `disabledOn` dialects are answered by name (`retired-visibility-dialects.ts`); - * - MEMBER 2 (the triage ruling): a `'where-undeclared'` member is a base - * prop only where the type declares no input of that name. Where one does, - * the declared input wins, `type-mismatch` included; - * - MEMBER 3: the generated `.d.ts`, compiled by `tsc`, accepts the base - * props on a type that declares none of them, refuses a near-miss, and - * lets a declared input's type win without a TS2430 conflict — for an - * `'every-node'` member too (objectui#11075): `notice` declares `visible` - * wider than the base `boolean`, as `record:alert` does in the live - * registry. The real public manifest's half is - * `apps/console/src/__tests__/sdui-intrinsics-compile-11075.test.ts`. - */ -import { describe, expect, it } from 'vitest'; -import ts from 'typescript'; -import { generateDts, manifestFromConfigs, SDUI_BASE_PROPS, validateTree } from '../index.js'; -import type { Diagnostic, SchemaElement } from '../types.js'; - -/** - * `leaf` declares none of the base props, as no live registration declares - * any `'every-node'` member added here. `field` declares every - * `'where-undeclared'` member as a typed input — the input-family shape — and - * two of them with a type the base one does not admit (`label` takes any - * object, `data` only an array). `notice` declares three `'every-node'` - * members (objectui#11075): `visible` with the three arms `record:alert` - * declares, which the base `boolean` does not admit, and `disabled` / - * `className` with the base type; its `children` input is a slot. - */ -const manifest = manifestFromConfigs([ - { type: 'leaf', namespace: 'ui', inputs: [{ name: 'content', type: 'string' }] }, - { - type: 'field', - namespace: 'ui', - inputs: [ - { name: 'name', type: 'string' }, - { name: 'label', type: ['string', 'object'] }, - { name: 'description', type: 'string' }, - { name: 'placeholder', type: 'string' }, - { name: 'data', type: 'array' }, - { name: 'ariaLabel', type: 'string' }, - ], - }, - { - type: 'list', - namespace: 'ui', - inputs: [ - { name: 'title', type: 'string' }, - { name: 'items', type: 'array' }, - ], - }, - { - type: 'notice', - namespace: 'ui', - inputs: [ - { name: 'message', type: 'string' }, - { name: 'visible', type: ['boolean', 'string', 'object'] }, - { name: 'disabled', type: 'boolean' }, - { name: 'className', type: 'string' }, - { name: 'children', type: 'slot' }, - ], - }, -] as unknown as Parameters [0]); - -const diagnose = (node: unknown): Diagnostic[] => - validateTree(node as SchemaElement, manifest).diagnostics; - -const LEAF = { type: 'leaf', content: 'x' }; - -/** A value of the kind `BaseSchema` declares for each member. */ -const WELL_TYPED: Record ;` }, - { what: 'the declared `data` type wins over the base one', rejected: true, code: `export const c9 = ;` }, - { what: 'the base `data` type where undeclared', rejected: false, code: `export const c10 = ;` }, - { what: 'objectui#11075: a declared `visible` takes an envelope', rejected: false, code: `export const c12 = ;` }, - { what: 'objectui#11075: a declared `visible` still judges the value', rejected: true, code: `export const c13 = ;` }, - { what: 'objectui#11075 control: the base `visible` stays `boolean` where undeclared', rejected: true, code: `export const c14 = } { - const files: Record [0]); - -const CHILD = { type: 'text', content: 'measured' }; -const diagnose = (node: unknown): Diagnostic[] => - validateTree(node as SchemaElement, manifest).diagnostics; - -describe('objectui#6771 — the tier answers the retired `body` with its replacement', () => { - it('the exported key IS the retired spelling, so the rule and its pin cannot drift', () => { - expect(RETIRED_CHILD_LIST_KEY).toBe('body'); - }); - - it('a `body` child list under a NON-container draws `not-a-container` — the ruling clause, verbatim', () => { - const found = diagnose({ type: 'badge', body: [CHILD] }); - expect(found.map((d) => d.code)).toContain('not-a-container'); - // The SAME code the live spelling draws — that is what "the same - // `not-a-container` the `children` spelling draws" means, and a consumer - // keying on the code cannot tell the two spellings apart. - expect(diagnose({ type: 'badge', children: [CHILD] }).map((d) => d.code)).toContain('not-a-container'); - // …and only the retired one also names the remedy. - expect(found.find((d) => d.code === 'not-a-container')!.message).toContain('"children"'); - }); - - it('ONE diagnostic, not two — the replacement replaces', () => { - // ⛔ The failure this guards is the obvious implementation: leave the prop - // walk's `unknown-prop` in place and ADD a containment branch that reads - // `body`. That author gets two reports for one mistake. - const found = diagnose({ type: 'badge', body: [CHILD] }); - expect(found.filter((d) => d.message.includes('"body"'))).toHaveLength(1); - }); - - it('a `body` child list under a CONTAINER draws `unknown-prop` naming `children`', () => { - const found = diagnose({ type: 'box', body: [CHILD] }); - const own = found.filter((d) => d.message.includes('"body"')); - expect(own).toHaveLength(1); - expect(own[0]!.code).toBe('unknown-prop'); - expect(own[0]!.message).toContain('"children"'); - // CONTROL — the live spelling under the same block is silent, so the row - // above is about the key and not about the block. - expect(diagnose({ type: 'box', children: [CHILD] })).toHaveLength(0); - }); - - it('a SCALAR `body` is a dead key and nothing more — no containment sentence', () => { - // The containment wording names a shape; naming it for `body: "hi"` would - // describe a child list the author did not write. - const found = diagnose({ type: 'badge', body: 'hi' }); - const own = found.filter((d) => d.message.includes('"body"')); - expect(own).toHaveLength(1); - expect(own[0]!.code).toBe('unknown-prop'); - expect(own[0]!.message).toContain('"children"'); - }); - - it('⛔ a component that DECLARES its own `body` input is untouched', () => { - // ⚠️ The fixture below is SYNTHETIC — a manifest is an argument to - // `validateTree`, so this file can ask what the rule says about any shape. - // The real component this carve-out exists for is `record:alert`, the one - // registration in the tree that declares an input named `body` (its value is - // an inline translation map, not a child list); the extension's own gate - // names it, and `sdui-parser` needs no list because it asks inside the - // `!input` branch, deliberately: the claim is about a key nobody declares. - expect(diagnose({ type: 'detail', body: 'Updated the deal stage.' })).toHaveLength(0); - }); - - it('the tier still teaches `children` ONLY — `body` never became a base prop', () => { - // The option the ruling REFUSED was adding `body` to `BASE_PROPS`, which - // would have made it a blessed second spelling forever. If it were there, - // every row above would be silent. - expect(diagnose({ type: 'box', body: [CHILD] }).length).toBeGreaterThan(0); - }); -}); diff --git a/ui/packages/sdui-parser/src/__tests__/compile.test.ts b/ui/packages/sdui-parser/src/__tests__/compile.test.ts deleted file mode 100644 index 935bafd5e50..00000000000 --- a/ui/packages/sdui-parser/src/__tests__/compile.test.ts +++ /dev/null @@ -1,84 +0,0 @@ -import { describe, expect, it } from 'vitest'; -import { compile, generateDts, manifestFromConfigs } from '../index.js'; - -// A tiny public-tier manifest, shaped exactly like getAllConfigs() output. -// Containment is the declared `children` slot input, not `isContainer` -// (objectui#9910) — the flag stays on the fixtures as the layout fact it is. -const manifest = manifestFromConfigs([ - { type: 'flex', namespace: 'ui', isContainer: true, inputs: [ - { name: 'direction', type: 'enum', enum: ['row', 'col'] }, - { name: 'gap', type: 'number' }, - { name: 'wrap', type: 'boolean' }, - { name: 'children', type: 'slot' }, - ] }, - { type: 'card', namespace: 'ui', isContainer: true, inputs: [ - { name: 'title', type: 'string' }, - { name: 'children', type: 'slot' }, - ] }, - { type: 'object-table', namespace: 'plugin-grid', isContainer: false, inputs: [ - { name: 'object', type: 'string', required: true, binding: 'object' }, - { name: 'columns', type: 'array' }, - { name: 'pageSize', type: 'number' }, - ] }, -]); - -describe('compile (parse + validate)', () => { - it('compiles valid JSX to a tree and reports requires + bindings', () => { - const r = compile( - ` - `, - manifest, - ); - expect(r.ok).toBe(true); - expect(r.diagnostics).toEqual([]); - expect(r.tree).toMatchObject({ - type: 'flex', - direction: 'row', - gap: 4, - wrap: true, - children: [{ type: 'object-table', object: 'account', pageSize: 25 }], - }); - expect(r.requires.sort()).toEqual(['plugin-grid', 'ui']); - expect(r.bindings).toEqual([ - { tag: 'object-table', input: 'object', kind: 'object', value: 'account' }, - ]); - }); - - it('rejects unknown components (whitelist = manifest tags)', () => { - const r = compile(`- `, manifest); - expect(r.ok).toBe(false); - expect(r.diagnostics.map((d) => d.code)).toContain('forbidden-tag'); - }); - - it('flags a missing required prop (completeness)', () => { - const r = compile(` `, manifest); - expect(r.ok).toBe(false); - expect(r.diagnostics).toContainEqual( - expect.objectContaining({ code: 'missing-required-prop' }), - ); - }); - - it('flags an illegal enum value and a coarse type mismatch', () => { - const r = compile(` `, manifest); - expect(r.diagnostics.map((d) => d.code)).toEqual( - expect.arrayContaining(['invalid-enum', 'type-mismatch']), - ); - }); - - it('rejects event handlers and raw-html injection', () => { - const r = compile(` `, manifest); - expect(r.diagnostics.filter((d) => d.code === 'forbidden-attr')).toHaveLength(2); - }); -}); - -describe('generateDts (the JSX type surface)', () => { - it('emits a JSX.IntrinsicElements augmentation from the manifest', () => { - const dts = generateDts(manifest); - expect(dts).toContain('"object-table": ObjectTableProps;'); - expect(dts).toContain('export interface ObjectTableProps extends SduiBaseProps'); - expect(dts).toContain('object: string;'); // required → not optional - expect(dts).toContain('pageSize?: number;'); // optional - expect(dts).toContain('direction?: "row" | "col";'); // enum → union - }); -}); diff --git a/ui/packages/sdui-parser/src/__tests__/containment-declared-slot-9910.test.ts b/ui/packages/sdui-parser/src/__tests__/containment-declared-slot-9910.test.ts deleted file mode 100644 index c5b5d6e1a52..00000000000 --- a/ui/packages/sdui-parser/src/__tests__/containment-declared-slot-9910.test.ts +++ /dev/null @@ -1,133 +0,0 @@ -/** - * ObjectUI - * Copyright (c) 2024-present ObjectStack Inc. - * - * This source code is licensed under the MIT license found in the - * LICENSE file in the root directory of this source tree. - */ - -/** - * Containment is decided by the declared `children` slot input, and by - * NOTHING else (objectui#9910, maintainer ruling 2026-09-24, Q1-A). - * - * ## The two facts this file separates - * - * `validateTree` used to read `comp.isContainer` for `not-a-container`. That - * flag is hand-kept and it means LAYOUT containment (objectui#6804): the - * react-page JSX scope skips it, and it was refused for a whole population of - * registrations that DO render `children` (label / description fallbacks, the - * sidebar chrome parts). After objectui#6771 converged those readers onto - * `children`, the flag put a FALSE warning on the one key they read. The - * ruling moved the declaration the tier reads to - * `{ name: 'children', type: 'slot' }` in `inputs`. - * - * So the manifest here is a 2×2: flag × slot. Every cell is asserted, because - * the two failure modes are OPPOSITE — a flag-only cell drawing nothing is the - * silently re-introduced fallback, and a slot-only cell drawing the warning is - * the objectui#9910 defect itself. The runtime half — that the slot is declared - * exactly where a renderer really puts the list on the page — is held by - * `packages/components/src/renderers/__tests__/container-declaration-ratchet.test.tsx` - * against the live registry; this file pins the TIER's reading of a manifest. - */ -import { describe, expect, it } from 'vitest'; -import { CHILD_LIST_KEY, acceptsChildren, manifestFromConfigs, validateTree } from '../index.js'; -import type { Diagnostic, Manifest, SchemaElement } from '../types.js'; - -const CONTAINMENT = 'not-a-container'; -const SLOT = { name: 'children', type: 'slot' } as const; - -const manifest: Manifest = manifestFromConfigs([ - // flag, no slot — a layout container that renders `items[].children`, never - // `schema.children` (the `page:tabs` shape) - { type: 'flag-only', namespace: 'ui', isContainer: true, inputs: [{ name: 'items', type: 'array' }] }, - // slot, no flag — a label-fallback reader (the `button` / `badge` shape) - { type: 'slot-only', namespace: 'ui', inputs: [{ name: 'label', type: 'string' }, SLOT] }, - // both — a layout container that renders the list (the `flex` shape) - { type: 'both', namespace: 'ui', isContainer: true, inputs: [{ name: 'gap', type: 'number' }, SLOT] }, - // neither — a leaf - { type: 'neither', namespace: 'ui', inputs: [{ name: 'content', type: 'string' }] }, - // the page kinds publish `children` typed `array`, not `slot` — the NAME is - // the declaration, so this row must read as accepting children too - { type: 'array-typed', namespace: 'ui', inputs: [{ name: 'children', type: 'array', of: 'object' }] }, - // the child every row nests, declared so it never draws `unknown-component` - { type: 'text', namespace: 'ui', inputs: [{ name: 'content', type: 'string' }] }, -] as unknown as Parameters [0]); - -const CHILD = { type: 'text', content: 'measured' }; -const codes = (node: unknown): string[] => - validateTree(node as SchemaElement, manifest).diagnostics.map((d: Diagnostic) => d.code); -const withChildren = (type: string) => ({ type, children: [CHILD] }); - -describe('objectui#9910 — the tier reads the declared `children` input, not the flag', () => { - it('exports the key by name, and the predicate reads exactly that name', () => { - expect(CHILD_LIST_KEY).toBe('children'); - expect(acceptsChildren({ inputs: [SLOT] })).toBe(true); - expect(acceptsChildren({ inputs: [{ name: 'children', type: 'array' }] })).toBe(true); - expect(acceptsChildren({ inputs: [{ name: 'body', type: 'slot' }] })).toBe(false); - expect(acceptsChildren({ inputs: [] })).toBe(false); - }); - - it('⛔ the flag is NOT a fallback: flag without slot draws `not-a-container`', () => { - // The hard line of the ruling. A registration that is a layout container - // but renders no authored child list must keep warning — the diagnostic - // on it is TRUE — and before objectui#9910 the flag silenced it. - expect(codes(withChildren('flag-only'))).toContain(CONTAINMENT); - }); - - it('the slot alone is sufficient: slot without flag draws nothing', () => { - // The objectui#9910 defect itself, gone: a `button`-shaped registration - // keeps the flag off (so react pages keep injecting it) and is still not - // warned on the one key it renders. - expect(codes(withChildren('slot-only'))).toEqual([]); - }); - - it('both declared draws nothing; neither declared draws the warning', () => { - expect(codes(withChildren('both'))).toEqual([]); - expect(codes(withChildren('neither'))).toContain(CONTAINMENT); - }); - - it('an input NAMED `children` counts whatever its coarse type — the page kinds publish `array`', () => { - expect(codes(withChildren('array-typed'))).toEqual([]); - }); - - it('a declared `children` slot is never type-checked or reported as a prop — the key is base', () => { - // `children` is in `BASE_PROPS`, so the prop walk skips it before the - // declared input is ever consulted: no `unknown-prop`, no `type-mismatch`, - // whichever coarse type the declaration carries. - for (const type of ['slot-only', 'both', 'array-typed', 'flag-only', 'neither']) { - const found = codes(withChildren(type)); - expect(found.filter((c) => c === 'unknown-prop' || c === 'type-mismatch')).toEqual([]); - } - // …and the reachability control: the nested child resolved everywhere. - for (const type of ['slot-only', 'both', 'array-typed', 'flag-only', 'neither']) { - expect(codes(withChildren(type))).not.toContain('unknown-component'); - } - }); - - it('the retired `body` spelling follows the SAME predicate', () => { - // `checkRetiredBodyDialect` is handed `acceptsChildren(comp)`, so the two - // spellings cannot disagree about which components take a list. - const under = (type: string) => - validateTree({ type, body: [CHILD] } as unknown as SchemaElement, manifest).diagnostics.filter((d) => - d.message.includes('"body"'), - ); - // slot declared ⇒ the list would be accepted under `children`, so `body` - // is answered as a retired key that names the replacement - expect(under('slot-only').map((d) => d.code)).toEqual(['unknown-prop']); - expect(under('slot-only')[0]!.message).toContain('"children"'); - // flag only ⇒ no list is accepted here, so `body` draws the containment - // sentence — the flag does not rescue the retired spelling either - expect(under('flag-only').map((d) => d.code)).toEqual([CONTAINMENT]); - expect(under('neither').map((d) => d.code)).toEqual([CONTAINMENT]); - }); - - it('the manifest still CARRIES `isContainer` for the consumers that read layout containment', () => { - // Q2-A keeps the field: `manifestFromConfigs` projects it unchanged, the - // react-page scope builder and the public layout ledger read it, and this - // tier ignores it. Asserted so a later "clean-up" that drops the projection - // is a visible decision rather than a side effect. - expect(manifest.components['flag-only']!.isContainer).toBe(true); - expect(manifest.components['both']!.isContainer).toBe(true); - expect(manifest.components['slot-only']!.isContainer).toBeUndefined(); - }); -}); diff --git a/ui/packages/sdui-parser/src/__tests__/dashboard-widget-options.test.ts b/ui/packages/sdui-parser/src/__tests__/dashboard-widget-options.test.ts deleted file mode 100644 index cf3114070a6..00000000000 --- a/ui/packages/sdui-parser/src/__tests__/dashboard-widget-options.test.ts +++ /dev/null @@ -1,231 +0,0 @@ -/** - * ObjectUI — the unconsumed-widget-option warning (objectui#5709) - * - * The 2026-08-23 maintainer ruling on objectui#5709: a dashboard widget - * `options` key riding `DashboardWidgetOptionsSchema.passthrough()` that no - * renderer consumes gets an authoring-time WARNING naming the consumed set. - * `invert` — the key the card was filed over — is the first pinned case, and - * it is pinned here AS A CASE of the general mechanism: the same fixture shape - * with a different dead key on a different widget type must draw the same - * diagnostic, or the mechanism is a special case wearing a general name. - * - * Severity is `warning` BY RULING (no gate weakening, no new red gates), so a - * dedicated assertion pins that no diagnostic this code emits is an error. - * - * The accepted-set expectations are DERIVED from - * `CONSUMED_WIDGET_OPTION_KEYS` — the same array the implementation prints — - * never restated, so a census update cannot desynchronize this file. The - * derivation is guarded against vacuity first (an empty census would warn on - * everything and make "names the consumed set" trivially true of the empty - * string); the census itself is re-measured against spec + renderer source in - * `dashboard-widget-options-census.test.ts` next door. - */ -import { describe, expect, it } from 'vitest'; -import { - CONSUMED_WIDGET_OPTION_KEYS, - UNCONSUMED_WIDGET_OPTION, - manifestFromConfigs, - validateTree, -} from '../index.js'; -import type { Diagnostic, Manifest, SchemaElement } from '../types.js'; - -/** - * A manifest carrying both widget-host blocks, with the inputs their real - * registrations declare (`packages/plugin-dashboard/src/index.tsx`), plus a - * non-host control block. - */ -const manifest: Manifest = manifestFromConfigs([ - { - type: 'dashboard', - namespace: 'view', - inputs: [ - { name: 'columns', type: 'number' }, - { name: 'gap', type: 'number' }, - { name: 'className', type: 'string' }, - ], - }, - { type: 'dashboard-grid', namespace: 'plugin-dashboard', inputs: [] }, - { type: 'card', namespace: 'ui', inputs: [] }, -]); - -/** The objectui#5709 fixture: the hotcrm gauge, verbatim in shape. */ -const slaGauge = { - id: 'sla_compliance_gauge', - title: 'SLA Compliance', - type: 'gauge', - dataset: 'case_metrics', - values: ['avg_sla_violated'], - options: { - format: '0%', - invert: true, - thresholds: [{ value: 0.95, color: 'success' }], - }, -}; - -const diagnose = (node: Record ` because the roster - * leaves it out; - * - `generateBlockList` sections the html tier under its own count instead - * of reading it as curated blocks; - * - `generateDts` emits the tags into `JSX.IntrinsicElements`, which is the - * authoring surface a `kind:'html'` page type-checks against. - */ - -import { describe, expect, it } from 'vitest'; -import { compile, generateBlockList, generateDts, manifestFromConfigs, type RegistryConfigLike } from '../index.js'; - -const configs: RegistryConfigLike[] = [ - { type: 'flex', namespace: 'ui', isContainer: true, inputs: [{ name: 'gap', type: 'number' }, { name: 'children', type: 'slot' }] }, - { type: 'my-widget', namespace: 'x', tier: 'public', inputs: [{ name: 'label', type: 'string' }] }, - { type: 'studio-admin', namespace: 'app-shell', tier: 'internal', inputs: [] }, - { type: 'p', namespace: 'ui', tier: 'html', inputs: [{ name: 'className', type: 'string' }, { name: 'children', type: 'slot' }] }, - { type: 'a', namespace: 'ui', tier: 'html', inputs: [{ name: 'className', type: 'string' }, { name: 'href', type: 'string' }, { name: 'children', type: 'slot' }] }, - { type: 'img', namespace: 'ui', tier: 'html', inputs: [{ name: 'src', type: 'string' }, { name: 'alt', type: 'string' }] }, - { type: 'main', namespace: 'ui', tier: 'html', isContainer: true, inputs: [{ name: 'className', type: 'string' }, { name: 'children', type: 'slot' }] }, -]; - -const manifest = manifestFromConfigs(configs); -/** What a consumer reads back off disk — `JSON.stringify` drops every `undefined`. */ -const published = JSON.parse(JSON.stringify(manifest)) as typeof manifest; - -describe('manifestFromConfigs carries the html-tier stamp, and only that stamp (objectui#10735)', () => { - it('writes `tier: html` on a stamped config', () => { - for (const tag of ['p', 'a', 'img', 'main']) { - expect(published.components[tag].tier, `${tag} lost its stamp`).toBe('html'); - } - }); - - it('publishes NO `tier` key for a curated, an opted-in or an internal config — byte-identical to before', () => { - for (const tag of ['flex', 'my-widget', 'studio-admin']) { - expect(Object.prototype.hasOwnProperty.call(published.components[tag], 'tier'), `${tag} grew a tier key`).toBe(false); - } - }); - - it('keeps every other field exactly as the registration declared it', () => { - expect(published.components.a.inputs.map((i) => i.name)).toEqual(['className', 'href', 'children']); - expect(published.components.main.isContainer).toBe(true); - expect(published.components.img.inputs.map((i) => i.name)).toEqual(['src', 'alt']); - }); - - it('`publicOnly` keeps the curated tier alone — the html tier is not `public`', () => { - expect(Object.keys(manifestFromConfigs(configs, { publicOnly: true }).components)).toEqual(['my-widget']); - }); -}); - -describe('compile reads the manifest as a whitelist — the stamp changes nothing for that reader', () => { - it('accepts an html-tier tag with its declared inputs and child slot', () => { - const r = compile('hi
r.name)} />`, - manifest, - ); - expect(r.diagnostics).toEqual([ - expect.objectContaining({ - severity: 'warning', - code: 'inert-expression', - tag: 'list-view', - message: expect.stringContaining('"columns"'), - }), - ]); - // The marker itself is unchanged — the tree still carries the deferred - // value; only the silence is gone. The message names what IS accepted. - expect(r.tree?.columns).toEqual({ $expr: 'rows.map((r) => r.name)' }); - expect(r.diagnostics[0].message).toMatch(/LITERALS only/); - // Warning, not error: the page still compiles (the objectui#5709 posture). - expect(r.ok).toBe(true); - }); - - it('a bare identifier draws the same warning', () => { - const r = compile(` `, manifest); - expect(r.diagnostics).toEqual([ - expect.objectContaining({ severity: 'warning', code: 'inert-expression' }), - ]); - }); - - it('an $expr on an object-typed input is covered too', () => { - const r = compile(` `, manifest); - expect(r.diagnostics).toEqual([ - expect.objectContaining({ severity: 'warning', code: 'inert-expression', tag: 'list-view' }), - ]); - }); - - it('strict-JSON spellings stay diagnostic-free — the warning cannot fire on a working page', () => { - for (const source of [ - ` `, - ` `, - ` `, - ` `, - ]) { - const r = compile(source, manifest); - expect(r.diagnostics).toEqual([]); - expect(r.ok).toBe(true); - } - }); - - it('an $expr on an UNKNOWN prop keeps drawing unknown-prop, not a double report', () => { - const r = compile(` `, manifest); - expect(r.diagnostics).toEqual([ - expect.objectContaining({ severity: 'warning', code: 'unknown-prop' }), - ]); - }); -}); diff --git a/ui/packages/sdui-parser/src/__tests__/input-type-union.test.ts b/ui/packages/sdui-parser/src/__tests__/input-type-union.test.ts deleted file mode 100644 index b8c56c26d0d..00000000000 --- a/ui/packages/sdui-parser/src/__tests__/input-type-union.test.ts +++ /dev/null @@ -1,233 +0,0 @@ -/** - * ObjectUI — `ManifestInput.type` as a union of arms (objectui#3832) - * - * The mechanism half of the card; the user-visible half (the five measured - * specimens, through the manifest the console really builds) lives in - * `apps/console/src/__tests__/component-input-union-specimens.test.ts`. - * - * Three facts are pinned here, and they are different facts: - * - * 1. ANY-ARM — a value passes when any declared arm accepts it, and is still - * reported when none does. The second half is the one that can rot silently: - * a `switch (input.type)` handed an array falls into its default branch and - * returns null, so a broken implementation looks exactly like a clean value. - * 2. BACKWARD COMPATIBILITY — a single-kind declaration behaves and serializes - * byte-identically to before. This is what makes the change an extension of - * `sdui.manifest.json` rather than a new version of it. - * 3. THE CONSUMERS — the serializer canonicalizes (collapse one arm, drop an - * off-vocabulary arm, dedupe) and the JSX codegen emits a TS union. A - * declaration the gate honours but the `.d.ts` contradicts would just move - * the author's false error one layer over. - */ -import { describe, expect, it } from 'vitest'; -import { - canonicalizeInputType, - compile, - generateDts, - inputTypeArms, - manifestFromConfigs, - validateTree, -} from '../index.js'; -import type { Manifest, SchemaElement } from '../types.js'; - -const one = (inputs: Parameters [0][number]['inputs']): Manifest => - manifestFromConfigs([{ type: 'probe', namespace: 'ui', inputs }]); - -const codes = (manifest: Manifest, node: Record prop "title" expected a string or an object', - ]); - }); - - it('reports one diagnostic per prop, not one per failed arm', () => { - expect(codes(manifest, { title: 42 })).toHaveLength(1); - }); - - it('reports at the STRICTEST arm severity when an enum arm is present', () => { - // An enum's closed list is the one fact this layer is certain about, so - // adding a second arm beside it must not turn its verdict into a dismissible - // warning. The code becomes `type-mismatch` (the fact is "fits none of the - // arms") while the message still carries the allowed values. - const withEnum = one([{ name: 'size', type: ['number', 'enum'], enum: ['sm', 'lg'] }]); - expect(codes(withEnum, { size: 12 })).toEqual([]); - expect(codes(withEnum, { size: 'lg' })).toEqual([]); - - const bad = validateTree( - { type: 'probe', size: 'enormous' } as SchemaElement, - withEnum, - ).diagnostics; - expect(bad).toHaveLength(1); - expect(bad[0]).toMatchObject({ severity: 'error', code: 'type-mismatch' }); - expect(bad[0].message).toContain('one of ["sm","lg"]'); - }); - - it('a `slot` arm keeps accepting everything', () => { - // Preserves the pre-union `default: return null` branch: a slot describes a - // child position, not a value, and those inputs never drew a diagnostic. - const slotty = one([{ name: 'footer', type: 'slot' }]); - expect(codes(slotty, { footer: 'anything' })).toEqual([]); - expect(codes(slotty, { footer: { deeply: ['nested'] } })).toEqual([]); - }); -}); - -describe('a single-kind declaration is unchanged (backward compatibility)', () => { - it('produces the same messages it always did', () => { - const manifest = one([ - { name: 's', type: 'string' }, - { name: 'n', type: 'number' }, - { name: 'b', type: 'boolean' }, - { name: 'a', type: 'array' }, - { name: 'o', type: 'object' }, - { name: 'c', type: 'color' }, - ]); - expect(messages(manifest, { s: 1 })).toEqual([' prop "s" expected a string']); - expect(messages(manifest, { n: 'x' })).toEqual([' prop "n" expected a number']); - expect(messages(manifest, { b: 'x' })).toEqual([' prop "b" expected a boolean']); - expect(messages(manifest, { a: {} })).toEqual([' prop "a" expected an array']); - expect(messages(manifest, { o: [] })).toEqual([' prop "o" expected an object']); - // `color` is a string with a narrower control — its message was, and stays, - // the string one. - expect(messages(manifest, { c: 1 })).toEqual([' prop "c" expected a string']); - }); - - it('keeps `invalid-enum` at error severity for a lone enum arm', () => { - // The one code that is NOT `type-mismatch`, and the severity a silent - // fallback would hide behind (objectui#3985). A lone enum arm must keep both. - const manifest = one([{ name: 'mode', type: 'enum', enum: ['a', 'b'] }]); - const d = validateTree({ type: 'probe', mode: 'c' } as SchemaElement, manifest).diagnostics; - expect(d).toHaveLength(1); - expect(d[0]).toMatchObject({ severity: 'error', code: 'invalid-enum' }); - expect(d[0].message).toBe(' prop "mode"="c" is not one of ["a","b"]'); - }); - - it('serializes to the bare string, so an existing manifest is byte-identical', () => { - const before = one([{ name: 'title', type: 'string' }]); - expect(before.components.probe.inputs[0].type).toBe('string'); - expect(JSON.stringify(before)).toContain('"type":"string"'); - }); -}); - -describe('canonicalizeInputType — what reaches the published manifest', () => { - it('collapses a one-element array to the bare kind', () => { - // So a union declaration that happens to have one arm cannot fork the - // published shape into two spellings of one meaning. - expect(canonicalizeInputType(['string'])).toBe('string'); - expect(one([{ name: 'x', type: ['string'] }]).components.probe.inputs[0].type).toBe('string'); - }); - - it('de-duplicates repeated arms', () => { - expect(canonicalizeInputType(['string', 'string'])).toBe('string'); - expect(canonicalizeInputType(['string', 'object', 'string'])).toEqual(['string', 'object']); - }); - - it('preserves arm order for a real union', () => { - expect(canonicalizeInputType(['object', 'string'])).toEqual(['object', 'string']); - }); - - it('coerces a lone off-vocabulary kind to `string`, as it always did', () => { - expect(canonicalizeInputType('i18nString')).toBe('string'); - expect(canonicalizeInputType(undefined)).toBe('string'); - }); - - it('DROPS an off-vocabulary arm from a union instead of coercing it', () => { - // Coercing would publish a `'string'` arm the author never declared — a - // widening invented by the serializer. The surviving arms carry the - // declaration, so the unknown one is dropped. - expect(canonicalizeInputType(['object', 'i18nString'])).toBe('object'); - expect(canonicalizeInputType(['number', 'nope', 'boolean'])).toEqual(['number', 'boolean']); - // …and if that empties the array, the lone-unknown fallback applies, because - // a manifest input must always carry a valid kind. - expect(canonicalizeInputType(['nope', 'alsoNope'])).toBe('string'); - expect(canonicalizeInputType([])).toBe('string'); - }); - - it('is what the gate reads — a dropped arm is not silently honoured', () => { - const manifest = one([{ name: 'title', type: ['object', 'i18nString'] as never }]); - expect(codes(manifest, { title: { en: 'x' } })).toEqual([]); - expect(codes(manifest, { title: 'x' })).toContain('type-mismatch'); - }); -}); - -describe('inputTypeArms', () => { - it('normalizes both declaration forms', () => { - expect(inputTypeArms('string')).toEqual(['string']); - expect(inputTypeArms(['string', 'number'])).toEqual(['string', 'number']); - expect(inputTypeArms(undefined)).toEqual([]); - }); -}); - -describe('generateDts emits the union it validates', () => { - it('emits a TypeScript union for a multi-arm input', () => { - const dts = generateDts( - one([ - { name: 'title', type: ['string', 'object'], required: true }, - { name: 'defaultValue', type: ['string', 'number'] }, - ]), - ); - expect(dts).toContain('title: string | Record `, manifest).diagnostics).toEqual([]); - expect( - compile(` `, manifest).diagnostics, - ).toEqual([]); - expect(compile(` `, manifest).diagnostics.map((d) => d.code)).toContain( - 'type-mismatch', - ); - }); -}); diff --git a/ui/packages/sdui-parser/src/__tests__/kanban-quick-add-8285.test.ts b/ui/packages/sdui-parser/src/__tests__/kanban-quick-add-8285.test.ts deleted file mode 100644 index ccce437b05c..00000000000 --- a/ui/packages/sdui-parser/src/__tests__/kanban-quick-add-8285.test.ts +++ /dev/null @@ -1,96 +0,0 @@ -/** - * ObjectUI — what this tier says about `quickAdd` on ` ` once the - * key is RETIRED (objectui#8285, ruling B of decision batch #91, 2026-09-08) - * - * ## What changed - * - * Until objectui#8285 closed, `quickAdd` was a key `@objectstack/spec` - * published on `object-kanban` and the board could not honour, so this package - * carried an interim `inert-quick-add` warning in place of the `unknown-prop` - * the prop walk would otherwise emit: "has no prop quickAdd" was FALSE against - * the published contract. The ruling scheduled that interim for deletion the - * day the spec's own refusal landed ("the spec refusal by name replaces that - * diagnostic once it lands"). - * - * It landed: `@objectstack/spec` 17.5.0 tombstones the key, both faces of - * `@object-ui/types`' `ObjectKanbanSchema` refuse it by name, and - * `ObjectKanban` no longer forwards it. So the interim module and its four - * exports are gone, and the walk's own answer is back. - * - * ## Why a bare `unknown-prop` is the accurate answer now - * - * "` ` has no prop quickAdd" is TRUE on every face after the - * retirement, and on this tier it is also the whole remedy: a constrained-JSX - * page cannot write the `onQuickAdd` function the control needs, so the only - * edit open to its author is to delete the key. That is the difference from the - * retired `body` dialect next door (`./body-dialect-6771.test.ts`), which keeps - * a replacement diagnostic because it has a replacement SPELLING to name - * (`children`); `quickAdd` has none on this tier. - * - * The live-registry half of this reading — the manifest a real page compiles - * against — is pinned in - * `packages/plugin-kanban/src/__tests__/quickAddRetiredNotForwarded-8285.test.tsx`. - */ -import { describe, expect, it } from 'vitest'; -import * as sduiParser from '../index.js'; -import { compile, manifestFromConfigs, validateTree } from '../index.js'; -import type { Diagnostic, Manifest } from '../types.js'; - -/** The `object-kanban` registration's shape: `quickAdd` is not among its inputs. */ -const manifest: Manifest = manifestFromConfigs([ - { - type: 'object-kanban', - namespace: 'plugin-kanban', - inputs: [ - { name: 'objectName', type: 'string', required: true }, - { name: 'groupBy', type: 'string' }, - ], - }, -]); - -const diagnose = (node: Record draws the walk\'s own `unknown-prop`', () => { - it.each([[true], [false], [{ $expr: 'rows.length > 0' }]])( - 'value %p — exactly one diagnostic, an `unknown-prop` warning naming the key', - (value) => { - const diagnostics = diagnose({ type: 'object-kanban', objectName: 'task', quickAdd: value }); - expect(diagnostics.map((d) => [d.severity, d.code, d.tag])).toEqual([ - ['warning', 'unknown-prop', 'object-kanban'], - ]); - expect(diagnostics[0].message).toContain('"quickAdd"'); - }, - ); - - it('the retired interim code is emitted for no value of the key', () => { - // `true` is the row that drew it before; `false` and the braced marker are - // the two it deliberately skipped. None of them may draw it now. - for (const value of [true, false, { $expr: 'x' }]) { - const codes = diagnose({ type: 'object-kanban', objectName: 'task', quickAdd: value }).map((d) => d.code); - expect(codes).not.toContain(RETIRED_CODE); - } - }); - - it('through the whole pipeline: source text compiles, with the warning and nothing harder', () => { - const result = compile(' ', manifest); - expect(result.diagnostics.map((d) => d.code)).toEqual(['unknown-prop']); - // A warning, as the interim was: the save gate's pass/fail does not move. - expect(result.ok).toBe(true); - // Non-vacuity for that `true`: the same pipeline does turn `ok` false. - expect(compile(' ', manifest).ok).toBe(false); - }); - - it('the barrel no longer publishes the interim\'s four exports', () => { - const exported = Object.keys(sduiParser); - for (const name of ['checkKanbanQuickAdd', 'INERT_QUICK_ADD', 'QUICK_ADD_HOST_TYPES', 'QUICK_ADD_KEY']) { - expect(exported).not.toContain(name); - } - // Control on the same instrument: the sibling retired-key check is still - // exported, so the four absences are a reading of this barrel. - expect(exported).toContain('checkRetiredBodyDialect'); - }); -}); diff --git a/ui/packages/sdui-parser/src/__tests__/literal-subset-6614.test.ts b/ui/packages/sdui-parser/src/__tests__/literal-subset-6614.test.ts deleted file mode 100644 index 433099b43cd..00000000000 --- a/ui/packages/sdui-parser/src/__tests__/literal-subset-6614.test.ts +++ /dev/null @@ -1,281 +0,0 @@ -/** - * objectui#6614 Q1-A — `interpretBrace` materializes the JS LITERAL SUBSET. - * - * Maintainer ruling, 2026-08-28 (live director session, batch #5 item 1), - * verbatim: 「6614 也同意」 ⇒ Q1-A · Q2-A · Q3-A, adopting the card's - * recommendation whole. This file pins Q1-A and ONLY Q1-A. - * - * WHY THE RULING EXISTS. The html tier is the untrusted-safe DATA tier — parsed, - * never executed (ADR-0080) — and it is the only safe carrier for runtime AI or - * tenant authoring. Before this change it accepted strict JSON inside braces - * while calling itself JSX, so `columns={['name','amount']}` — the spelling - * every JSX author and every AI author writes — compiled to the deferred - * `{ $expr }` marker that nothing downstream evaluates, and the author's whole - * data binding vanished at render (objectui#6598, reported from production - * after eight spellings were tried). That is a trap, not a contract. The ruling - * closes it by materializing the literal subset, and it keeps genuine - * expressions loudly refused. - * - * ⭐ WHY THE REFUSAL PINS BELOW MATTER AS MUCH AS THE POSITIVE ONES. A suite - * that only asserted the newly-legal spellings would pass just as well against - * a parser that started accepting EVERYTHING — including code — which is the - * one failure this widening must never ship. So every positive pin here has a - * refusal pin naming the first thing on the far side of the boundary. - * - * THE BOUNDARY, stated once. Exactly two widenings over JSON: - * 1. single-quoted strings (value position AND key position); - * 2. unquoted identifier object keys. - * Everything else JSON refuses is still refused: trailing commas, comments, - * holes, spreads, `undefined`/`NaN`/`Infinity`, `+1`/`.5`/`1.`/`0x1f`, template - * literals, identifiers, member access, calls, and every operator. The subset - * contains no identifier lookup and no operator, so there is nothing in it to - * execute — the widening moves habitual spellings onto the materialized side, - * it does not move the data/code boundary. - * - * ⛔ NOT IN SCOPE HERE, by the same ruling: Q2 (escalating `inert-expression` - * from warning to error — that lands at the SAVE GATE once the framework wires - * the registry manifest into `validate-jsx-pages`) and Q3 (base-prop `$expr` - * inertness, sequenced deliberately AFTER this change so no warning is added - * for spellings this change is about to legalise). - */ -import { describe, expect, it } from 'vitest'; -import { compile, interpretBrace, parseJsx } from '../index.js'; -import type { Manifest } from '../types.js'; - -const manifest: Manifest = { - components: { - 'list-view': { - type: 'list-view', - namespace: 'plugin-list', - inputs: [ - { name: 'objectName', type: 'string', required: true }, - { name: 'columns', type: 'array' }, - { name: 'options', type: 'object' }, - { name: 'title', type: 'string' }, - { name: 'pageSize', type: 'number' }, - { name: 'enabled', type: 'boolean' }, - ], - }, - }, -}; - -/** The braced attribute value, as it reaches the renderer. */ -const propOf = (braced: string, prop = 'columns'): unknown => - parseJsx(` `).tree?.[prop]; - -describe('#6614 Q1-A — the two ruled widenings materialize', () => { - it("the production spelling: a single-quoted array reaches the renderer as a real array", () => { - // objectui#6598's page, byte-for-byte. This is the assertion the whole card - // exists for: before the ruling this was `{ $expr: "['name','amount']" }`. - expect(propOf(`['name','amount']`)).toEqual(['name', 'amount']); - expect(interpretBrace(`['name','amount']`)).toEqual(['name', 'amount']); - }); - - it('a single-quoted string in value position materializes to the string itself', () => { - expect(propOf(`'Accounts'`, 'title')).toBe('Accounts'); - // No quotes survive into the value — the point is normalization, not a - // literal copy of the source text. - expect(interpretBrace(`'Accounts'`)).toBe('Accounts'); - }); - - it('unquoted identifier object keys materialize', () => { - expect(propOf(`{pageSize: 25}`, 'options')).toEqual({ pageSize: 25 }); - expect(propOf(`[{field:"name"},{field:"amount"}]`)).toEqual([ - { field: 'name' }, - { field: 'amount' }, - ]); - // `$` and `_` are identifier characters, and a digit is legal after the first. - expect(interpretBrace(`{_a: 1, $b: 2, c3: 3}`)).toEqual({ _a: 1, $b: 2, c3: 3 }); - }); - - it('a single-quoted KEY is covered — it is widening #1 in key position', () => { - expect(interpretBrace(`{'pageSize': 25}`)).toEqual({ pageSize: 25 }); - }); - - it('the two widenings compose, and nest', () => { - expect(interpretBrace(`{cols: ['name','amount'], page: {size: 25, deep: ['x']}}`)).toEqual({ - cols: ['name', 'amount'], - page: { size: 25, deep: ['x'] }, - }); - }); - - it('escapes inside a single-quoted string follow JSON, plus `\\u0027`', () => { - expect(interpretBrace(`'a\\'b'`)).toBe("a'b"); - expect(interpretBrace(`'tab\\there'`)).toBe('tab\there'); - expect(interpretBrace(`'\\u0041'`)).toBe('A'); - // A double quote needs no escape inside single quotes, and vice versa. - expect(interpretBrace(`'say "hi"'`)).toBe('say "hi"'); - }); - - it('the materialized spellings draw NO diagnostic — the page is simply correct now', () => { - for (const source of [ - ` `, - ` `, - ` `, - ` `, - ` `, - ]) { - const r = compile(source, manifest); - expect(r.diagnostics, source).toEqual([]); - expect(r.ok, source).toBe(true); - } - }); - - it('a materialized value is type-checked like any other — the widening does not skip checkType', () => { - // Single quotes get it PAST the marker; they do not get it past the - // manifest. A string where an array is declared is still a mismatch. - const r = compile(` `, manifest); - expect(r.diagnostics).toEqual([ - expect.objectContaining({ code: 'type-mismatch', tag: 'list-view' }), - ]); - }); -}); - -describe('#6614 Q1-A — the far side of the boundary is still refused', () => { - /** Every one of these must stay the deferred marker, byte-for-byte. */ - const REFUSED: Array<[label: string, braced: string]> = [ - ['a bare identifier', `columns`], - ['member access', `ctx.user.name`], - ['a function call', `getColumns()`], - ['a method call on a literal', `['a'].concat(b)`], - ['the card-quoted expression', `rows.map((r) => r.name)`], - ['an arrow function', `() => 1`], - ['arithmetic', `1 + 2`], - ['a literal that merely STARTS the expression', `['a'] + x`], - ['a ternary', `a ? b : c`], - ['logical short-circuit', `flag && ['a']`], - ['a template literal', '`col-${n}`'], - ['an array spread', `[...cols]`], - ['an object spread', `{...base, pageSize: 25}`], - ['a trailing comma in an array', `['a',]`], - ['a trailing comma in an object', `{a: 1,}`], - ['an array hole', `[,1]`], - ['a block comment', `/* cols */ ['a']`], - ['a line comment', `['a'] // cols`], - ['undefined', `undefined`], - ['NaN', `NaN`], - ['Infinity', `Infinity`], - ['a leading plus', `+1`], - ['a bare fractional point', `.5`], - ['a trailing decimal point', `1.`], - ['a hex number', `0x1f`], - ['an octal-ish number', `010`], - ['a non-JSON escape', `'\\x41'`], - ['an unterminated string', `['a`], - ['a computed key', `{[k]: 1}`], - ['a keyword glued to an identifier', `nullish`], - ['an empty brace', ``], - ]; - - it.each(REFUSED)('%s stays the deferred `{ $expr }` marker', (_label, braced) => { - expect(interpretBrace(braced)).toEqual({ $expr: braced.trim() }); - }); - - it('a refused value still draws the warning-severity `inert-expression` diagnostic', () => { - const r = compile( - ` r.name)} />`, - manifest, - ); - expect(r.diagnostics).toEqual([ - expect.objectContaining({ - severity: 'warning', - code: 'inert-expression', - tag: 'list-view', - message: expect.stringContaining('"columns"'), - }), - ]); - expect(r.tree?.columns).toEqual({ $expr: 'rows.map((r) => r.name)' }); - // ⛔ Q2 is NOT this change: the render-side severity stays `warning`, and - // the page still compiles. Escalation belongs at the save gate. - expect(r.ok).toBe(true); - }); - - it('the diagnostic no longer advises a spelling that now works', () => { - const r = compile(` `, manifest); - const message = r.diagnostics[0].message; - // The pre-#6614 message said "write it as JSON (double-quoted strings and - // keys)" and named `columns={['name','amount']}` as the WRONG form. That - // spelling is now correct, so the old advice would send an author to edit - // working source. Pin that it is gone. - expect(message).not.toMatch(/double-quoted/); - expect(message).toContain('LITERALS only'); - }); -}); - -describe('#6614 Q1-A — strict JSON is byte-identical to before', () => { - /** - * The invariance is structural, not incidental: `interpretBrace` still calls - * `JSON.parse` FIRST and untouched, so an input JSON accepts never reaches the - * new reader at all. This pins the property that structure guarantees. - */ - const STRICT_JSON = [ - `["name","amount"]`, - `[{"field":"name","label":"Full Name"}]`, - `{"pageSize":25}`, - `{}`, - `[]`, - `"plain string"`, - `25`, - `-0`, - `1e3`, - `-1.5e-3`, - `true`, - `false`, - `null`, - `{"nested":{"deep":[1,2,{"x":null}]}}`, - `"escaped \\" quote"`, - `"\\u00e9"`, - `{"__proto__":1}`, - `{"a":1,"a":2}`, - ]; - - it.each(STRICT_JSON)('%s parses exactly as JSON.parse does', (source) => { - expect(interpretBrace(source)).toEqual(JSON.parse(source)); - }); - - it('-0 keeps its sign, as JSON.parse gives it', () => { - expect(Object.is(interpretBrace(`-0`), -0)).toBe(true); - }); - - it('a strict-JSON page compiles with the same zero diagnostics it always did', () => { - for (const source of [ - ` `, - ` `, - ` `, - ` `, - ]) { - const r = compile(source, manifest); - expect(r.diagnostics, source).toEqual([]); - expect(r.ok, source).toBe(true); - } - }); -}); - -describe('#6614 Q1-A — the widening opens no execution or pollution lever', () => { - it('an authored `__proto__` key becomes an OWN property, never the prototype', () => { - // ⚠️ This is the one place where matching JS-literal semantics would be - // WRONG. A real JS object literal `{__proto__: {...}}` invokes the prototype - // setter; this tier exists to make untrusted source safe to parse, so the - // unquoted-key widening must follow `JSON.parse` (own data property) and not - // JS. A plain `out[key] = value` in the reader would fail this test. - const value = interpretBrace(`{__proto__: {polluted: true}}`) as Record `); - expect(r.diagnostics.map((d) => d.code)).toEqual(['forbidden-attr', 'forbidden-attr']); - }); -}); diff --git a/ui/packages/sdui-parser/src/__tests__/member-kind-8067.test.ts b/ui/packages/sdui-parser/src/__tests__/member-kind-8067.test.ts deleted file mode 100644 index 6471d36923f..00000000000 --- a/ui/packages/sdui-parser/src/__tests__/member-kind-8067.test.ts +++ /dev/null @@ -1,203 +0,0 @@ -/** - * ObjectUI — `ManifestInput.of`, the coarse MEMBER kind (objectui#8067) - * - * The mechanism half of the card. The contract half — every declared `of` in - * the repository compared against what `ComponentPropsMap[type]` accepts at the - * member position — lives in - * `apps/console/src/__tests__/registry-inputs-spec-parity.test.ts`. - * - * WHY THE KEY EXISTS. `type: 'array'` said a value was a list and stopped - * there, so a member that drifted from the contract was invisible to every - * layer that reads a declaration. `page:header.actions` is the measured cost: - * spec `z.array(z.string())` ("Action IDs"), a renderer reading the members as - * `ActionDef` OBJECTS, and the repo-wide parity gate green for the whole life of - * the drift because both sides had the key and neither could say what was - * inside it. - * - * WHAT IS PINNED HERE, and they are different facts: - * - * 1. THE READER EXISTS — a member no declared arm accepts is REPORTED. This is - * the fact objectui#5905 is the cautionary precedent for: five - * `ComponentInput` keys were declared and read by nothing, and every gate - * stayed green. A `of` that nothing reads is that defect with a new name. - * 2. BACKWARD COMPATIBILITY — an input that declares no `of` is validated, - * serialized and typed byte-identically to before the key existed. That is - * what makes this an extension of `sdui.manifest.json` rather than a new - * version of it. - * 3. THE COARSE CEILING HOLDS ONE LEVEL DOWN — `of` names a KIND, never a - * domain and never a member's KEYS, so `of: 'object'` clears every object - * whatever it contains. The maintainer ruling of 2026-08-17 quoted on - * `ComponentInput.type` ("SPEC IS THE SOLE JUDGE OF VALUES") is untouched. - * 4. THE OTHER CONSUMERS — the serializer canonicalizes `of` exactly as it - * canonicalizes `type`, and the JSX codegen narrows the emitted element - * type from it. A member kind the validator honours but the `.d.ts` - * contradicts would just move an author's false error one layer over. - */ -import { describe, expect, it } from 'vitest'; -import { generateDts, manifestFromConfigs, validateTree } from '../index.js'; -import type { Manifest, SchemaElement } from '../types.js'; - -const one = (inputs: Parameters [0][number]['inputs']): Manifest => - manifestFromConfigs([{ type: 'probe', namespace: 'ui', inputs }]); - -const diags = (manifest: Manifest, node: Record prop "actions" expected every member to be a string — [1], [2] are not', - ); - }); - - it('an empty container conforms — there is no member to refuse', () => { - expect(codes(manifest, { actions: [] })).toEqual([]); - }); - - it('reads the ARRAY form of `of` the same way it reads the array form of `type`', () => { - // The rot this pins: a reader that forgot `Array.isArray` would fall through - // and report NOTHING, which looks exactly like a clean value. - const union = one([{ name: 'items', type: 'array', of: ['string', 'object'] }]); - expect(codes(union, { items: ['a', { b: 1 }] })).toEqual([]); - expect(codes(union, { items: [42] })).toEqual(['member-type-mismatch']); - }); - - it('judges an OBJECT container by its VALUES — the map half of the key', () => { - const map = one([{ name: 'labels', type: 'object', of: 'string' }]); - expect(codes(map, { labels: { en: 'Account', 'zh-CN': '客户' } })).toEqual([]); - const [diagnostic] = diags(map, { labels: { en: 'Account', count: 3 } }); - expect(diagnostic.message).toBe( - ' prop "labels" expected every member to be a string — [count] is not', - ); - }); -}); - -describe('the container verdict comes first', () => { - const manifest = one([{ name: 'actions', type: 'array', of: 'string' }]); - - it('a wrong CONTAINER draws one diagnostic, not two', () => { - // One mistake, one report. A member walk over a value that is not even the - // declared container would name positions of a shape the author never wrote. - expect(codes(manifest, { actions: 'clone' })).toEqual(['type-mismatch']); - }); - - it('a value that satisfied a NON-container arm of a union is not member-judged', () => { - const union = one([{ name: 'actions', type: ['string', 'array'], of: 'string' }]); - expect(codes(union, { actions: 'clone' })).toEqual([]); - expect(codes(union, { actions: [42] })).toEqual(['member-type-mismatch']); - }); -}); - -describe('the coarse ceiling holds one level down', () => { - it('`of: \'object\'` clears every object, whatever keys it carries', () => { - // `of` is a KIND, never a member's KEYS. Which keys an element must have is - // spec's question and a per-block pin's, exactly as the value DOMAIN of a - // `number` arm is (`ComponentInput.type`, maintainer ruling 2026-08-17). - const manifest = one([{ name: 'sections', type: 'array', of: 'object' }]); - expect(codes(manifest, { sections: [{ anything: 'at all' }, {}] })).toEqual([]); - expect(codes(manifest, { sections: ['sales_info'] })).toEqual(['member-type-mismatch']); - }); - - it('an `enum` member arm raises its severity to error, as it does one level up', () => { - const manifest = one([ - { name: 'types', type: 'array', of: 'enum', enum: ['comment', 'task'] }, - ]); - expect(codes(manifest, { types: ['comment', 'task'] })).toEqual([]); - const [diagnostic] = diags(manifest, { types: ['comment', 'email'] }); - expect(diagnostic.code).toBe('member-type-mismatch'); - expect(diagnostic.severity).toBe('error'); - }); -}); - -describe('an input that declares no member kind is unchanged', () => { - // The backward-compatibility half. Every input published before this key - // existed says exactly this, so anything that moves here moves for all of - // them. - const manifest = one([{ name: 'actions', type: 'array' }]); - - it('draws no member diagnostic on any member', () => { - expect(codes(manifest, { actions: [42, {}, 'clone', null] })).toEqual([]); - }); - - it('publishes no `of` at all — the serialized entry is byte-identical', () => { - expect(JSON.stringify(manifest.components.probe.inputs[0])).toBe( - '{"name":"actions","type":"array"}', - ); - }); - - it('emits the unnarrowed element type', () => { - expect(generateDts(manifest)).toContain('actions?: unknown[];'); - }); -}); - -describe('the serializer canonicalizes `of` exactly as it canonicalizes `type`', () => { - it('collapses a one-element array to the bare kind', () => { - expect(one([{ name: 'a', type: 'array', of: ['string'] }]).components.probe.inputs[0].of).toBe( - 'string', - ); - }); - - it('drops an off-vocabulary arm rather than inventing `string` for it', () => { - expect( - one([{ name: 'a', type: 'array', of: ['string', 'nonsense'] }]).components.probe.inputs[0].of, - ).toBe('string'); - }); - - it('dedupes a repeated arm', () => { - expect( - one([{ name: 'a', type: 'array', of: ['string', 'object', 'string'] }]).components.probe - .inputs[0].of, - ).toEqual(['string', 'object']); - }); - - it('does NOT invent a member kind for an undeclared `of`', () => { - // `canonicalizeInputType`'s no-arms fallback is `'string'`, so routing an - // undefined through it would make every array in every manifest claim - // string members it was never told it had. - expect(one([{ name: 'a', type: 'array' }]).components.probe.inputs[0].of).toBeUndefined(); - }); -}); - -describe('the JSX authoring surface narrows with it', () => { - it('types the elements rather than emitting `unknown[]`', () => { - const dts = generateDts(one([{ name: 'actions', type: 'array', of: 'string' }])); - expect(dts).toContain('actions?: string[];'); - expect(dts).not.toContain('actions?: unknown[];'); - }); - - it('types an object map\'s values', () => { - expect(generateDts(one([{ name: 'labels', type: 'object', of: 'string' }]))).toContain( - 'labels?: Record [0]; - -const withSlots = manifestFromConfigs(CONFIGS, { slotsFor }); -const withoutSlots = manifestFromConfigs(CONFIGS); - -const UNKNOWN = { type: 'nope-11170' }; -const codes = (node: unknown, manifest = withSlots): string[] => - validateTree(node as SchemaElement, manifest).diagnostics.map((d: Diagnostic) => d.code); -const unknownCount = (node: unknown, manifest = withSlots) => - codes(node, manifest).filter((c) => c === 'unknown-component').length; - -describe('manifestFromConfigs projects the declaration it is handed (objectui#11170)', () => { - it('carries each entry’s non-retired slot paths, and no key at all without the option', () => { - expect(withSlots.components['dialog']!.slots).toEqual(['trigger', 'content', 'footer']); - expect(withSlots.components['tabs']!.slots).toEqual(['items[].content']); - // The retired `body` is left out of the authoring tier's projection. - expect(withSlots.components['page:card']!.slots).toEqual(['footer']); - // An entry with no slots publishes none (`undefined`, which `JSON.stringify` - // drops — the same contract `tier` and `of` keep), so the serialised entry - // is byte-identical to one built before the key existed. - expect(withSlots.components['text']!.slots).toBeUndefined(); - expect(JSON.stringify(withSlots.components['text'])).toBe(JSON.stringify(withoutSlots.components['text'])); - expect(JSON.stringify(withoutSlots)).not.toContain('"slots"'); - }); -}); - -describe('validateTree reaches slot-held nodes exactly where the entry declares a slot', () => { - it('a direct slot, one node or a list', () => { - expect(unknownCount({ type: 'dialog', content: UNKNOWN })).toBe(1); - expect(unknownCount({ type: 'dialog', content: [{ type: 'text' }, UNKNOWN], footer: UNKNOWN })).toBe(2); - // The same node under an undeclared key is not reached. - expect(unknownCount({ type: 'dialog', header: UNKNOWN })).toBe(0); - }); - - it('a panel list and a trailing `[]`', () => { - expect(unknownCount({ type: 'tabs', items: [{ value: 'a', content: UNKNOWN }, { value: 'b', content: [UNKNOWN, UNKNOWN] }] })).toBe(3); - expect(unknownCount({ type: 'carousel', items: [UNKNOWN, [UNKNOWN]] })).toBe(2); - expect(unknownCount({ type: 'report-viewer', report: { sections: [{ content: UNKNOWN }] } })).toBe(1); - }); - - it('nested: a slot under a child under a slot', () => { - const doc = { type: 'dialog', content: { type: 'tabs', items: [{ value: 'a', content: UNKNOWN }] } }; - expect(unknownCount(doc)).toBe(1); - }); - - it('a retired position is not walked by this tier; its refusal by name stands (objectui#6771)', () => { - const diagnostics = validateTree({ type: 'page:card', body: [UNKNOWN] } as unknown as SchemaElement, withSlots).diagnostics; - expect(diagnostics.filter((d) => d.code === 'unknown-component')).toEqual([]); - expect(diagnostics.map((d) => d.code)).toContain('unknown-prop'); - expect(diagnostics.find((d) => d.code === 'unknown-prop')?.message).toContain('retired by objectui#6771'); - }); - - it('a manifest without slots walks `children` alone — the pre-11170 reach, unchanged', () => { - expect(unknownCount({ type: 'dialog', content: UNKNOWN }, withoutSlots)).toBe(0); - expect(unknownCount({ type: 'dialog', children: [UNKNOWN] }, withoutSlots)).toBe(1); - }); - - it('an unknown component’s own slots are not consulted: one diagnostic, on it', () => { - expect(codes({ type: 'nope-outer', content: UNKNOWN })).toEqual(['unknown-component']); - }); - - it('a string in a slot is legal and draws nothing', () => { - expect(codes({ type: 'dialog', trigger: 'Open', content: ['plain', { type: 'text' }] })).toEqual([]); - }); -}); diff --git a/ui/packages/sdui-parser/src/__tests__/provenance.test.ts b/ui/packages/sdui-parser/src/__tests__/provenance.test.ts deleted file mode 100644 index d0908c3e4e7..00000000000 --- a/ui/packages/sdui-parser/src/__tests__/provenance.test.ts +++ /dev/null @@ -1,128 +0,0 @@ -/** - * html-tier provenance marking (objectui#4000). - * - * The parser stamps every element it emits, so a renderer can tell an html-tier - * node from a JSON-authored one and scope authoring advice to the surface the - * advice is actually about. What is pinned here is the marker's four load- - * bearing properties, each of which has a distinct failure mode: - * - * - it is SET on what the parser produces, at every depth; - * - it SURVIVES an object spread — `SchemaRenderer` hands renderers a shallow - * copy, so a marker that did not survive would restore the original bug in - * the render path only, silently; - * - it is INVISIBLE to JSON — so it cannot be persisted, and therefore cannot - * be replayed by an authored document that wants the exemption; - * - it is NOT set on JSON reached through a braced attribute — that JSON was - * hand-written, so the JSON surface's advice does apply to it. - */ - -import { describe, expect, it } from 'vitest'; -import { parseJsx } from '../parse.js'; -import { HTML_TIER_NODE, isHtmlTierNode, markHtmlTierNode } from '../provenance.js'; -import type { SchemaElement } from '../types.js'; - -describe('html-tier provenance (#4000)', () => { - it('marks every element the parser emits, at every depth', () => { - const { tree } = parseJsx(' deep'); - const root = tree as SchemaElement; - expect(isHtmlTierNode(root)).toBe(true); - - const child = root.children![0] as SchemaElement; - expect(isHtmlTierNode(child)).toBe(true); - const grandchild = child.children![0] as SchemaElement; - expect(isHtmlTierNode(grandchild)).toBe(true); - }); - - it('survives the shallow copy a renderer receives', () => { - // `SchemaRenderer` evaluates expressions against `{ ...schema }` and passes - // the COPY down. Object spread carries own enumerable symbol keys and drops - // non-enumerable ones — so this assertion, not the definition site, is what - // actually holds the marker's descriptor in place. - const { tree } = parseJsx(''); - const copy = { ...(tree as SchemaElement) }; - expect(isHtmlTierNode(copy)).toBe(true); - - // …and through a second hop, which is what nesting plus scoped styling does. - expect(isHtmlTierNode({ ...copy, className: 'a scoped' })).toBe(true); - }); - - it('is invisible to JSON, to Object.keys and to for...in', () => { - const { tree } = parseJsx(''); - const root = tree as SchemaElement; - - expect(JSON.parse(JSON.stringify(root))).toEqual({ type: 'div', className: 'a' }); - // ⚠️ Key ORDER, not key SET: `type` moved from first to last when the - // discriminator collision was closed (objectui#7235) and the node became - // `{ ...props, type: tag }`. The set, the values and the round-trip are - // unchanged — this line is the one visible consequence of that reversal, - // and it is here rather than adjusted away because an order pin that - // silently follows the implementation pins nothing. - expect(Object.keys(root)).toEqual(['className', 'type']); - const seen: string[] = []; - for (const k in root) seen.push(k); - expect(seen).toEqual(['className', 'type']); - - // The round-trip is the anti-forgery pin: a persisted tree comes back - // unmarked, so a saved (or AI-generated) document cannot carry the - // exemption back in with it. - expect(isHtmlTierNode(JSON.parse(JSON.stringify(root)))).toBe(false); - }); - - it('survives the reversed spread — the marking is applied AFTER every key', () => { - // objectui#7235 reversed `markHtmlTierNode({ type: tag, ...props })` into - // `markHtmlTierNode({ ...props, type: tag })`. The wrapper is objectui-only - // (objectstack's copy of this parser builds a bare object), so the reversal - // is the one edit in that port where the stamp could have been dropped — - // e.g. by moving the call inside the literal, or by spreading a marked - // object into a fresh unmarked one. Pinned at every depth and for the - // shapes the reversal actually moves: props present, props absent, and a - // container whose children were attached after the stamp. - const { tree } = parseJsx(''); - const root = tree as SchemaElement; - expect(isHtmlTierNode(root)).toBe(true); - - const smuggled = (root.body as SchemaElement[])[0]; - expect(smuggled.type).toBe('div'); - expect(isHtmlTierNode(smuggled)).toBe(false); - }); - - it('reads false for anything unmarked, and never throws on non-objects', () => { - expect(isHtmlTierNode({ type: 'div' })).toBe(false); - expect(isHtmlTierNode(null)).toBe(false); - expect(isHtmlTierNode(undefined)).toBe(false); - expect(isHtmlTierNode('div')).toBe(false); - expect(isHtmlTierNode(7)).toBe(false); - // A string-keyed lookalike is not provenance — there is no fallback read. - expect(isHtmlTierNode({ type: 'div', _provenance: 'html' })).toBe(false); - }); - - it('keys the marker in the global registry, so duplicate instances agree', () => { - // This package ships ESM and CJS and is consumed from several packages. Two - // module instances holding two local symbols would not compare equal, and - // the failure mode of that mismatch is the original bug returning with no - // error anywhere. A registry key cannot drift. - expect(HTML_TIER_NODE).toBe(Symbol.for('@object-ui/sdui-parser.html-tier-node')); - expect(isHtmlTierNode(markHtmlTierNode({ type: 'div' }))).toBe(true); - }); -}); diff --git a/ui/packages/sdui-parser/src/__tests__/tier.test.ts b/ui/packages/sdui-parser/src/__tests__/tier.test.ts deleted file mode 100644 index 70b524dbf47..00000000000 --- a/ui/packages/sdui-parser/src/__tests__/tier.test.ts +++ /dev/null @@ -1,49 +0,0 @@ -import { describe, expect, it } from 'vitest'; -import { assertFullyLoaded, generateBlockList, generateDts, manifestFromConfigs } from '../index.js'; - -const configs = [ - { type: 'object-table', namespace: 'plugin-grid', tier: 'public' as const, inputs: [ - { name: 'object', type: 'string', required: true, binding: 'object' as const }, { name: 'pageSize', type: 'number' } ] }, - { type: 'flex', namespace: 'ui', tier: 'public' as const, isContainer: true, inputs: [{ name: 'gap', type: 'number' }] }, - { type: 'studio-metadata-admin', namespace: 'app-shell', tier: 'internal' as const, inputs: [] }, - { type: 'debug-overlay', namespace: 'app-shell', inputs: [] }, -]; - -describe('M4: capability vs contract (tier)', () => { - it('publicOnly keeps only the curated tier', () => { - expect(Object.keys(manifestFromConfigs(configs, { publicOnly: true }).components).sort()) - .toEqual(['flex', 'object-table']); - }); - it('unfiltered keeps the full capability', () => { - expect(Object.keys(manifestFromConfigs(configs).components)).toHaveLength(4); - }); - it('generates the block list 清单 with bindings', () => { - const list = generateBlockList(manifestFromConfigs(configs, { publicOnly: true })); - expect(list).toContain('# SDUI public blocks (2)'); - expect(list).toContain('object:object'); - }); - it('codegen stays consistent with the public manifest', () => { - expect(generateDts(manifestFromConfigs(configs, { publicOnly: true }))) - .toContain('"object-table": ObjectTableProps;'); - }); -}); - -describe('assertFullyLoaded — generators must not emit lazy stubs (objectui#2953)', () => { - it('passes when every config is a loaded registration', () => { - expect(() => assertFullyLoaded(configs)).not.toThrow(); - }); - - it('names every stub, so the fix is "import these plugins"', () => { - const withStubs = [ - ...configs, - { type: 'object-kanban', namespace: 'plugin-kanban', lazy: true }, - { type: 'object-map', namespace: 'plugin-map', lazy: true }, - ]; - // The silent alternative is what this exists to prevent: both blocks reach - // the manifest with `inputs: []`, which reads as "takes no props" and turns - // every prop an author writes into an unknown-prop diagnostic. - expect(manifestFromConfigs(withStubs).components['object-kanban'].inputs).toEqual([]); - expect(() => assertFullyLoaded(withStubs)).toThrow(/object-kanban, object-map/); - expect(() => assertFullyLoaded(withStubs)).toThrow(/2 not-yet-loaded lazy block/); - }); -}); diff --git a/ui/packages/sdui-parser/src/__tests__/type-attribute-collision-7235.test.ts b/ui/packages/sdui-parser/src/__tests__/type-attribute-collision-7235.test.ts deleted file mode 100644 index 2a0c99aaec9..00000000000 --- a/ui/packages/sdui-parser/src/__tests__/type-attribute-collision-7235.test.ts +++ /dev/null @@ -1,169 +0,0 @@ -/** - * html tier: an authored `type=` attribute collides with the envelope's own - * discriminator, and is REFUSED at parse time (objectui#7235 — the port of - * objectstack#13957, maintainer ruling 2026-09-01, ADR-0080 amendment). - * - * The two outcomes this replaces are pinned side by side on purpose, because - * they are the reason the refusal is at parse rather than at the warning layer: - * one of them produced NO diagnostic at all, and the other produced a loud one - * pointing somewhere else. A test that only asserted "an error is raised" would - * pass on the second case before this change. - * - * ⚠️ This copy is the RENDERER's (and the console's live edit preview); the - * save gate runs objectstack's. Until this landed the two differed in accepted - * grammar, so an author got no diagnostic while typing and a refusal on save. - */ -import { describe, expect, it } from 'vitest'; -import { compile, manifestFromConfigs } from '../index.js'; -import { parseJsx } from '../parse.js'; -import { isHtmlTierNode } from '../provenance.js'; -import type { SchemaElement } from '../types.js'; - -const manifest = manifestFromConfigs([ - { type: 'flex', namespace: 'ui', isContainer: true, inputs: [ - { name: 'direction', type: 'enum', enum: ['row', 'col'] }, - { name: 'gap', type: 'number' }, - { name: 'children', type: 'slot' }, - ] }, - { type: 'grid', namespace: 'ui', isContainer: true, inputs: [{ name: 'columns', type: 'number' }, { name: 'children', type: 'slot' }] }, - { type: 'object-chart', namespace: 'plugin-charts', isContainer: false, inputs: [ - { name: 'objectName', type: 'string', binding: 'object' }, - ] }, -]); - -/** The refusal, as the author sees it: one diagnostic naming BOTH names. */ -const refusals = (source: string) => - compile(source, manifest).diagnostics.filter((d) => d.code === 'forbidden-attr'); - -describe('an authored `type` attribute is refused (the discriminator collision)', () => { - it('refuses when the value names ANOTHER REGISTERED type — the previously SILENT case', () => { - const r = compile(' ', manifest); - - // Before this change: `grid` resolved in the manifest, every check passed, - // and the page rendered a grid where the author wrote a flex — zero - // diagnostics of any severity. - expect(r.ok).toBe(false); - expect(r.diagnostics).toContainEqual( - expect.objectContaining({ severity: 'error', code: 'forbidden-attr', tag: 'flex' }), - ); - - // ONE diagnostic, naming BOTH the tag and the attribute (the ruled shape). - const [only, ...rest] = refusals(' '); - expect(rest).toEqual([]); - expect(only.message).toContain('"type"'); - expect(only.message).toContain(' '); - - // …AND the tree still builds as the tag the author wrote. Asserting only - // the diagnostic would leave the other half of this defect in place: the - // silent redirect is the node carrying `grid` as its discriminator, and a - // loud diagnostic beside a redirected node is still a redirected node. - expect(r.tree?.type).toBe('flex'); - expect(r.tree).not.toHaveProperty('type', 'grid'); - }); - - it('refuses when the value names NOTHING registered — the previously MISDIRECTED case', () => { - // ` ` is the shape a react-tier author carries - // across: on that tier `type` is the chart family. Before this change the - // only diagnostic was `unknown-component` naming `"bar"`, which reads as a - // missing plugin rather than as an attribute that should not be there. - const source = ' '; - const r = compile(source, manifest); - - expect(r.ok).toBe(false); - expect(refusals(source)).toHaveLength(1); - expect(r.diagnostics.map((d) => d.code)).not.toContain('unknown-component'); - // The diagnostic names the ATTRIBUTE, never the value the author gave it. - expect(refusals(source)[0].message).toContain('"type"'); - expect(refusals(source)[0].message).not.toContain('"bar"'); - expect(r.tree?.type).toBe('object-chart'); - }); - - it('refuses a BARE `type` attribute too — the check is on the name, not the value', () => { - expect(refusals(' ')).toHaveLength(1); - expect(refusals(' ')).toHaveLength(1); - }); - - it('refuses it on a NESTED element, not only on the root', () => { - const found = refusals(' '); - }); - - it('leaves a clean element alone — no regression', () => { - const r = compile(' '); - - expect(tree?.type).toBe('flex'); - expect(diagnostics.map((d) => d.code)).toContain('forbidden-attr'); - }); - - it('and does not let the refused value land under its own name either', () => { - const { tree } = parseJsx(' '); - expect(Object.values(tree ?? {})).not.toContain('grid'); - // Nor under the `__forbidden_ ` sentinel the OTHER refusals park in - // `props` — that sentinel draws an `unknown-prop` naming a key nobody - // wrote, which is the second diagnostic the ruled shape refuses to emit. - expect(Object.keys(tree ?? {})).not.toContain('__forbidden_type'); - }); - - it('every other prop still survives the reordered spread', () => { - const { tree } = parseJsx(' ` has no prop body" is TRUE — but it is the answer that sent authors - * the wrong way in the first place. Every `body` node in this repository's own - * docs, examples and READMEs was migrated in the same change, and an author - * carrying the old spelling in from anywhere else needs the replacement NAMED, - * not merely the key refused. The two codes below are the ruling's own words: - * the tier teaches `children` only, and a `body` child list under a - * non-container draws the same `not-a-container` the `children` spelling draws. - * - * SCOPE — asked INSIDE the `!input` branch, because its claim is about a key - * nobody declares, so a - * component that publishes its own `body` input keeps its declared type check - * untouched. Re-derived against the registry rather than recalled: exactly one - * registration in the tree declares an input named `body`, and it is - * `record:alert` (`plugin-detail`, `register('alert', …, { namespace: 'record' })`), - * whose `body` takes an inline translation map and is not this spelling. - * Control on the same sweep: `name: 'children'` fires seven times. - */ - -import type { Diagnostic, ParsedSchemaNode } from './types.js'; - -/** The child-list spelling objectui#6771 retired. `children` replaced it. */ -export const RETIRED_CHILD_LIST_KEY = 'body'; - -const isPlainObject = (v: unknown): v is Record ` when `widget.dataset` is - * set; `DashboardGridLayout.tsx` mirrors the fork, objectui#4614). On that — - * the only spec-legal — path, the renderer-consumed `options` keys are exactly - * the five the spec DECLARES, all read as direct `options. ` accesses in - * `packages/plugin-dashboard/src/DatasetWidget.tsx`: - * - * dateGranularity, sortBy, sortOrder, limit (query-affecting, framework#3588) - * stageOrder (funnel/pyramid stage order) - * - * and nothing else. ⛔ Not `description`: it was the metric-card sub-caption - * (objectui#4032 item 4, objectui#7293), read by `DatasetWidget.tsx`'s metric - * branch and a resolver both dashboard surfaces called, and fed by the - * server's `translateDashboard` overlay of the `widgets.{id}.subCaption` - * translation. The spec never declared it. objectui#11389 (ruling C, which - * reverses objectstack#5428 item 4) retires it at both ends: objectstack - * first, in `@objectstack/spec` 17.7.0 (the overlay is gone and the - * translation key is a tombstone), then the readers here. So an authored - * `options.description` reaches no renderer and draws this warning like any - * other unconsumed key. A widget keeps one authored description, - * `widget.description`, the card-header subtitle, which is not an `options` - * key and is not judged here. - * - * Notably NOT consumed on the path a widget really renders through: - * `thresholds` and `format`. Both were widely believed to work; both draw this - * warning, which is the point. They are NOT the same kind of claim, and since - * the 2026-08-25 maintainer ruling (batch adjudication close-out, decision B1 — - * a closure claim must be BOUNDED or DERIVABLE, and a claim written in two - * places is single-sourced) they are written separately (objectui#6186): - * - * `thresholds` — zero read sites repo-wide. This paragraph is the CANONICAL - * statement of that closure claim. `content/docs/plugins/plugin-dashboard.mdx` - * used to assert it a second time in its own words; two copies of one - * closure claim drift apart independently and neither knows when the other - * stopped being true, so the page now POINTS here rather than restating it. - * Single-sourcing is what makes this copy load-bearing, so it is DERIVED - * rather than trusted: - * `scripts/__tests__/unconsumed-widget-option-claim-6186.test.ts` re-scans - * every JS/TS file git tracks for an access to a key of that name and fails - * if one appears. Land a renderer that reads it and this module goes red in - * the same run. - * `format` — not read ON THE DATASET-BOUND PATH; the value is formatted with - * the MEASURE's own metadata (`measureField(...).format`, from the dataset - * definition), not from the widget's bag. Deliberately a BOUNDED claim and - * not a repo-wide one: `format` is a live key in other vocabularies, so a - * repo-wide scan would red on a TRUE claim — and an assertion that reds on - * legitimate code gets deleted by the next person who hits it, which puts - * the claim back where it started. Leg 2 of - * `__tests__/dashboard-widget-options-census.test.ts` derives exactly this - * bound: the DatasetWidget read set is the declared set, and neither - * `format` nor `thresholds` is in it. That absence is asserted in its OWN - * right rather than riding on an equality whose right-hand side can grow. - * - * ## Scope — where the warning deliberately does NOT fire - * - * - Widgets WITHOUT `dataset`: the legacy inline forms (`options.data` - * arrays, `provider: 'object'` bags) consume a much larger, spread-shaped - * key set (`{ ...options }` into `metric` / `object-metric` / - * `data-table` / …), whose true reach is each child component's prop - * surface. That form is spec-illegal today (`dataset` is required) and its - * census would be the unmaintainable one; skipping it keeps every warning - * this module emits a statement about the path the widget actually renders - * through. - * - Widgets in the legacy COMPONENT format (`widget.component`): `options` - * is not part of that contract. - * - Widgets carrying the spec's own escape hatch - * `suppressWarnings: ['unconsumed-widget-option']` — the spec models - * per-widget diagnostic suppression (`DashboardWidgetSchema`), so an - * author with a genuine out-of-band consumer can say so in metadata. - * - * ## Maintenance — how this list stays true - * - * `__tests__/dashboard-widget-options-census.test.ts` re-runs the census on - * every test run: it re-derives the five declared keys from the installed - * `@objectstack/spec`, re-extracts the `options. ` reads from - * `DatasetWidget.tsx` source text (and fails loudly if that file gains a - * consumption shape the extractor cannot see — a spread, a destructuring, a - * computed access), re-checks that the retired sub-caption key has no read - * site left in `plugin-dashboard`, and trips on any NEW - * file in `packages/*\/src` or `apps/*\/src` that starts reading - * `widget.options`. A renderer change that adds or removes a consumed key - * fails that test until this list is updated — the cost of keeping this - * warning honest is editing ONE array below plus re-reading the census notes. - */ -import type { Diagnostic, SchemaElement } from './types.js'; - -/** The diagnostic `code` — also the id `suppressWarnings` suppresses. */ -export const UNCONSUMED_WIDGET_OPTION = 'unconsumed-widget-option'; - -/** - * Component types that host a dashboard `widgets` array. Both resolve to the - * surfaces measured by the census above (`DashboardRenderer`, - * `DashboardGridLayout`), which share one dispatch (`widgetDispatch.ts`). - */ -export const DASHBOARD_WIDGET_HOST_TYPES: ReadonlySet = new Set([ - 'dashboard', - 'dashboard-grid', -]); - -/** - * The accepted set: every `options` key with a renderer read site on the - * dataset-bound path, which is exactly the set the spec declares. - * Alphabetical; the warning message prints it verbatim. Derivation and - * evidence: file header. - */ -export const CONSUMED_WIDGET_OPTION_KEYS: readonly string[] = [ - 'dateGranularity', - 'limit', - 'sortBy', - 'sortOrder', - 'stageOrder', -]; - -const CONSUMED = new Set (CONSUMED_WIDGET_OPTION_KEYS); - -const isPlainObject = (v: unknown): v is Record ; - /** - * The binding marker — exactly `'object'` (`9e37d9b39`). - * - * `'field'` was declared beside it from the first draft of ADR-0080 §6.3 - * and never written: every `binding:` literal in `packages/`, `apps/` - * and `examples/` is `'object'` (7 of 7, measured 2026-09-06 and - * re-measured at the retiring PR's merge-base), and nothing on either - * side of the manifest resolved a field binding. Retired under ADR-0049 - * enforce-or-remove by the maintainer ruling of 2026-09-07 (decision - * batch #69): a config that spells the arm is a `tsc` error here rather - * than an entry the server would never resolve. - * - * The retirement then reached the two faces the ruling did not name - * (objectui#8315): `ManifestInput.binding` and - * `ManifestValidationResult.bindings[].kind` in `types.ts` read `'object'` - * too, so the published package no longer narrows on one face and stays - * wide on the other. The argument for keeping the manifest face wide — - * producer → reader is a subset relation — is answered at - * `ManifestInput.binding`, which is where a later reader lands. - * - * Only the framework writes the key: `InjectedComponentInput` in - * `@object-ui/types`, spliced by `Registry.register`. `ComponentInput` - * itself has no `binding` member, deliberately. - */ - binding?: 'object'; - description?: string; - }>; - /** - * True when the registry entry is a pending lazy stub — registered, but its - * plugin module has not been imported, so it carries metadata and no - * `inputs`. See {@link assertFullyLoaded}. - */ - lazy?: boolean; -} - -/** - * Build-time guard for the manifest generators. - * - * A manifest is the contract's frozen form: the parser's tag whitelist and the - * save gate's prop validator both read it. So it has to be generated from - * FULLY LOADED registrations. A `lazy: true` entry means the generator never - * imported that plugin, and the block would be written out with empty - * `inputs` — indistinguishable from a block that legitimately takes no props, - * which turns every prop an author writes on it into an `unknown-prop` - * diagnostic. Wrong quietly, in the artifact everything downstream trusts. - * - * The generators keep their own eager import list, so this is what catches it - * drifting behind the app's registration list (objectui#2953 was the same - * class of bug one layer down). - */ -export function assertFullyLoaded(configs: RegistryConfigLike[]): void { - const stubs = configs.filter((c) => c.lazy).map((c) => c.type).sort(); - if (stubs.length === 0) return; - throw new Error( - `Manifest generation saw ${stubs.length} not-yet-loaded lazy block(s): ${stubs.join(', ')}.\n` + - `A manifest must describe loaded registrations — these would be written out with no \`inputs\`, ` + - `so every prop an author passes them would be reported as unknown.\n` + - `Add an eager \`import\` of each block's plugin to the generator entry.`, - ); -} - -/* The arm vocabulary and the two projections over it now live in - * `input-type.ts` — `manifestFromConfigs` below, `validateTree` and the codegen - * all read `ManifestInput.type` and must agree on how, since it holds one arm - * or an array of them (objectui#3832). */ - -/** - * Project registry configs into the SDUI manifest. - * - * ⚠️ Every field here is copied from what the registration **declared**. In - * particular `inputs` is `config.inputs` verbatim — this function does not, and - * cannot, observe whether the renderer behind the block reads any of them. - * - * Worth stating because of what consumes the output. The framework's - * `check:react-blocks-declaration-parity` diffs this against the spec's zod - * schemas, and while that check was named `check:react-conformance` it was read - * — by its own file header — as confirming the components "ACTUALLY implement" - * the spec's props. It never could: both sides of that diff are declarations, - * and this is the side this file produces. Four blocks published an `objectName` - * no renderer read and sailed through it green (objectstack#4413; corrected in - * objectstack#4472). Evidence about the render path has to come from the render - * path — see `apps/console/src/__tests__/public-block-binding-reach.test.tsx`. - * - * `opts.slotsFor` is the one exception to "copied from the registration", and - * it is a DECLARATION too (objectui#11170): hand it `nodeSlotsFor` from - * `@object-ui/types` and every entry carries `slots`, the node-slot positions - * that type's renderer reads besides `children`, so `validateTree` judges the - * nodes under them. This package has no runtime dependency and so cannot - * import the declaration itself; the producers that build a live manifest - * (`getJsxManifest` in `@object-ui/components`' page renderer, the console's - * manifest generator) pass it. A RETIRED position is left out here: this is - * the authoring tier, and the spec's own authoring walks skip the tombstoned - * spellings for the same reason. Without the option no `slots` key is written, - * so every manifest built before the option existed serialises byte-identically. - */ -export function manifestFromConfigs( - configs: RegistryConfigLike[], - opts: { - only?: Set ; - publicOnly?: boolean; - slotsFor?: (type: string) => readonly NodeSlotDeclarationLike[]; - } = {}, -): Manifest { - const components: Manifest['components'] = {}; - for (const c of configs) { - if (opts.only && !opts.only.has(c.type)) continue; - if (opts.publicOnly && c.tier !== 'public') continue; - const slots = opts.slotsFor - ? opts.slotsFor(c.type).filter((s) => !s.retired).map((s) => s.path) - : undefined; - components[c.type] = { - type: c.type, - namespace: c.namespace, - isContainer: c.isContainer, - // `undefined` is dropped by `JSON.stringify`, so a manifest built with - // no resolver — or an entry with no slots — serialises exactly as before - // this key existed. - slots: slots && slots.length > 0 ? slots : undefined, - // The html tier's stamp, and ONLY that stamp (objectui#10735): a - // registration's `'public'` / `'internal'` is registry mechanics the - // manifest never carried, and `undefined` is dropped by `JSON.stringify`, - // so every curated entry serialises exactly as before this key existed. - tier: c.tier === 'html' ? 'html' : undefined, - inputs: (c.inputs ?? []).map((i) => ({ - name: i.name, - type: canonicalizeInputType(i.type), - // Undefined stays undefined rather than going through - // `canonicalizeInputType`, whose no-arms fallback is `'string'`: an - // input that declares no member kind must publish NO `of`, or every - // array in every manifest would suddenly claim string members it was - // never told it had. `JSON.stringify` drops the undefined key, so the - // published artifact is byte-identical for every input that does not - // declare one (objectui#8067). - of: i.of === undefined ? undefined : canonicalizeInputType(i.of), - required: i.required, - enum: i.enum, - binding: i.binding, - description: i.description, - })), - }; - } - return { components }; -} diff --git a/ui/packages/sdui-parser/src/input-type.ts b/ui/packages/sdui-parser/src/input-type.ts deleted file mode 100644 index abd1c44e819..00000000000 --- a/ui/packages/sdui-parser/src/input-type.ts +++ /dev/null @@ -1,75 +0,0 @@ -/** - * ObjectUI — the arms of a manifest input's coarse type (objectui#3832) - * - * `ManifestInput.type` carries ONE coarse kind, or an ARRAY of kinds when the - * key's contract is a union. Every reader of that field needs the same two - * decisions made the same way — how to see the arms, and which single form to - * publish — so they live here once instead of at each call site. A reader that - * forgets is not loud: `switch (input.type)` handed an array falls through to - * the default branch and reports NOTHING, which looks exactly like a value that - * validated cleanly. - */ - -import type { ManifestInput, ManifestInputType } from './types.js'; - -/** The eleven coarse kinds, as a runtime set for guarding untyped input. */ -export const MANIFEST_INPUT_TYPES: ReadonlySet = new Set ([ - 'string', - 'number', - 'boolean', - 'enum', - 'array', - 'object', - 'color', - 'date', - 'code', - 'file', - 'slot', -]); - -/** - * The declared arms of an input's coarse type, always as an array. - * - * Exported (not merely internal) so a third-party manifest consumer — a - * designer panel, a codegen, a validator of its own — reads the arms through - * the same accessor this package's own gate does, rather than re-deriving the - * `Array.isArray` branch and getting it subtly wrong on the union form. - */ -export function inputTypeArms( - type: ManifestInput['type'] | undefined, -): ManifestInputType[] { - if (type === undefined) return []; - return Array.isArray(type) ? type : [type]; -} - -/** - * Project a DECLARED type (which may come from an untyped registry config) into - * the canonical published form: a bare string for one arm, an array for a real - * union. - * - * Two deliberate asymmetries between the single and array forms: - * - * - A single unrecognized kind still becomes `'string'`. That coercion predates - * the union work and is kept exactly: with one arm there is no other - * information to fall back on, and a manifest whose `type` is off-vocabulary - * would make every consumer's switch silently inert. - * - An unrecognized arm INSIDE an array is DROPPED, not coerced. Promoting it - * to `'string'` would publish an arm the author never declared — a widening - * invented by the serializer — and the surviving arms already carry the - * declaration. If dropping empties the array, the single-arm fallback applies - * so the output is always a valid manifest. - * - * Collapsing one arm to the bare string is what keeps this a backward-compatible - * extension of `sdui.manifest.json`: every input declared today serializes to - * the byte-identical entry it does now, and arrays appear only where a union was - * really declared. - */ -export function canonicalizeInputType(type: unknown): ManifestInputType | ManifestInputType[] { - const arms = (Array.isArray(type) ? type : [type]).filter( - (arm): arm is ManifestInputType => typeof arm === 'string' && MANIFEST_INPUT_TYPES.has(arm), - ); - const distinct = [...new Set(arms)]; - if (distinct.length === 0) return 'string'; - if (distinct.length === 1) return distinct[0]; - return distinct; -} diff --git a/ui/packages/sdui-parser/src/parse.ts b/ui/packages/sdui-parser/src/parse.ts deleted file mode 100644 index 0431c73da96..00000000000 --- a/ui/packages/sdui-parser/src/parse.ts +++ /dev/null @@ -1,605 +0,0 @@ -/** - * ObjectUI — SDUI JSX-source parser (ADR-0080) - * - * A small recursive-descent parser for a CONSTRAINED JSX subset. It is - * deliberately not a full JS/JSX parser: a bounded grammar is the point - * (Markdoc model) — it shrinks the attack surface and the expressible-but-wrong - * space. Output is an SDUI node tree (`ParsedSchemaNode`). Nothing is executed. - * - * Grammar (informal): - * document := element (exactly one root) - * element := openTag child-star closeTag, or a self-closing tag - * attr := name '=' (string | braced), or a bare name meaning true - * child := element | text | jsx-block-comment - * tag := [A-Za-z][A-Za-z0-9:_-]star (matches registry keys) - */ - -import type { Diagnostic, ParseOptions, ParseResult, SchemaElement, ParsedSchemaNode } from './types.js'; -import { markHtmlTierNode } from './provenance.js'; - -/** Event handlers and raw-HTML injection are never allowed (parse ≠ execute). */ -const EVENT_ATTR = /^on[A-Z]/; -const FORBIDDEN_ATTRS = new Set(['dangerouslySetInnerHTML', 'ref', 'key']); - -/** - * The envelope's own discriminator, which on THIS tier the tag name sets. - * - * An authored `type=` attribute is a NAME COLLISION with it, and the parser - * refuses it at parse time (maintainer ruling 2026-09-01, recorded as an - * append-only amendment on ADR-0080 — 「响亮拒绝」, quoted verbatim there; - * objectui#7235 ports it to this copy, objectstack#13957 landed the other). - * One diagnostic naming BOTH the tag and the attribute replaces two bad - * outcomes: - * - * - the value named another REGISTERED type (` `) — the tree - * carried `type:'grid'`, `validateTree` found `grid` in the manifest, every - * check passed, and the page rendered a grid where the author wrote a flex. - * ZERO diagnostics. On the one tier whose whole premise is that unreviewed - * and AI-authored source is safe to accept. - * - the value named NOTHING registered (` `, the shape - * a react-tier author carries across) — loud, but `unknown-component` - * naming `"bar"` reads as a missing plugin, never as a bad prop. - * - * ⛔ NOT rescued as `specType` the way the react tier rescues it (objectui#2880): - * that is consumer-side tolerance, and it would spread an alias concept to a - * second tier. ⛔ NOT a warning grace period either — the same ruling declined - * a staged rollout. ⛔ And NOT fixable at the warning layer: `type` is in - * `validate.ts`'s `BASE_PROPS` deliberately (it is correct for every other - * member), so removing it there would make every legitimate node warn. The - * refusal belongs here, at parse. - * - * ⚠️ The code is the EXISTING `forbidden-attr`, not a new one, and that is - * load-bearing rather than lazy: objectstack's `scripts/check-sdui-lockstep.mjs` - * holds ITS copy's diagnostic-code set equal to THIS one's at the pinned - * revision, so a code minted on one side only IS the dialect split that gate - * exists to catch (objectstack#12719). `forbidden-attr` already carries this - * shape — an attribute this tier refuses, named beside its element — and both - * copies stamp it. - * - * ⚠️ This copy is the RENDERER's (and the console's live edit preview); the - * save gate runs objectstack's. Until this landed the two differed in accepted - * grammar: a page objectstack refused still compiled silently while its author - * was typing. - */ -const DISCRIMINATOR_ATTR = 'type'; - -export function parseJsx(source: string, options: ParseOptions = {}): ParseResult { - return new Parser(source, options).parseDocument(); -} - -const isNameStart = (c: string) => /[A-Za-z]/.test(c); -const isNameChar = (c: string) => /[A-Za-z0-9:_-]/.test(c); - -class Parser { - private pos = 0; - private readonly diagnostics: Diagnostic[] = []; - - constructor(private readonly src: string, private readonly opts: ParseOptions) {} - - parseDocument(): ParseResult { - this.skipTrivia(); - if (this.peek() !== '<') { - this.error('no-root', 'Expected a single root element'); - return { tree: null, diagnostics: this.diagnostics }; - } - const tree = this.parseElement(); - this.skipTrivia(); - if (tree && this.pos < this.src.length) { - this.error('multiple-roots', 'A page must have exactly one root element', this.pos); - } - return { tree, diagnostics: this.diagnostics }; - } - - private parseElement(): SchemaElement | null { - const start = this.pos; - if (!this.eat('<')) { - this.error('expected-element', 'Expected "<"', start); - return null; - } - const tag = this.readName(); - if (!tag) { - this.error('bad-tag', 'Expected a tag name after "<"', start); - return null; - } - if (this.opts.allowedTags && !this.opts.allowedTags.has(tag)) { - this.error('forbidden-tag', `<${tag}> is not an allowed component`, start, tag); - } - - const props: Record ` - // sentinel the other refusals park in `props` reaches `validateTree`, - // which knows no such prop and adds `unknown-prop` naming a key nobody - // wrote — loud, and pointing at the wrong thing, which is the species of - // diagnostic this whole change exists to remove. The existing sentinel - // behaviour is left exactly as it was for the attributes that already had - // it (`ref`, `key`, `dangerouslySetInnerHTML`, `on*`). - if (!attr.drop) props[attr.name] = attr.value; - } - - this.skipWs(); - let children: ParsedSchemaNode[] | undefined; - if (this.eat('/')) { - if (!this.eat('>')) this.error('bad-self-close', `Malformed self-closing <${tag}>`, this.pos, tag); - } else if (this.eat('>')) { - children = this.parseChildren(tag); - } else { - this.error('unterminated-open-tag', `Unterminated <${tag}> open tag`, start, tag); - } - - // Stamp html-tier provenance at the point of production (objectui#4000). - // Renderers whose type carries authoring advice aimed at the JSON surface - // read this to tell "the author wrote a tag in OUR tier, and there is no - // other spelling available to them" apart from "the author wrote this type - // in JSON, where the advice applies". Symbol-keyed, so it is invisible to - // JSON, to the DOM, and to anything an authored document could forge — see - // provenance.ts. Values reached through a braced attribute are NOT marked: - // that JSON was written by hand, and the JSON surface's advice does apply. - // DEFENSE IN DEPTH (ruled together with the refusal above). `props` used to - // be spread AFTER `type: tag`, so an authored `type` attribute overwrote the - // discriminator the tag established and nothing downstream restored it — - // `compile()` returns this tree as-is and `validateTree` then looks up - // `manifest.components[node.type]`, i.e. the value the author wrote, not the - // tag they wrote. The refusal makes that overwrite unreachable; the order - // here makes it impossible. ⚠️ Reversing the order ALONE would have been a - // regression of its own — the authored value would then be dropped in - // silence, trading one silence for another. It is correct only BECAUSE the - // attribute is refused loudly one function up. - // - // ⚠️ The `markHtmlTierNode` wrapper is objectui-only and survives the - // reversal: it stamps the object the spread produced, so the marker is - // applied after every key is in place regardless of their order. Pinned in - // provenance.test.ts, because this is the one edit that could drop it. - const node: SchemaElement = markHtmlTierNode({ ...props, type: tag }); - if (children && children.length) node.children = children; - return node; - } - - private parseAttr(elStart: number, tag: string): { name: string; value: unknown; drop?: boolean } | null { - const name = this.readName(); - if (!name) { - this.error('bad-attr', `Malformed attribute on <${tag}>`, this.pos, tag); - // skip one char to avoid an infinite loop on garbage - this.pos++; - return null; - } - this.skipWs(); - let value: unknown = true; // bare attribute => boolean true - if (this.eat('=')) { - this.skipWs(); - value = this.parseAttrValue(tag); - } - if (name === DISCRIMINATOR_ATTR) { - // ONE diagnostic naming both the tag and the attribute — see - // DISCRIMINATOR_ATTR above for why it replaces both prior outcomes. - this.error( - 'forbidden-attr', - `Attribute "${DISCRIMINATOR_ATTR}" is not allowed on <${tag}> — on this tier the tag name IS the ` - + `component, so <${tag}> already means type "${tag}". Delete the attribute, or write the tag of the ` - + 'component you meant.', - elStart, - tag, - ); - return { name, value: undefined, drop: true }; - } - if (EVENT_ATTR.test(name) || FORBIDDEN_ATTRS.has(name)) { - this.error('forbidden-attr', `Attribute "${name}" is not allowed on <${tag}>`, elStart, tag); - return { name: `__forbidden_${name}`, value: undefined }; - } - return { name, value }; - } - - private parseAttrValue(tag: string): unknown { - const c = this.peek(); - if (c === '"' || c === "'") return this.readString(c); - if (c === '{') return interpretBrace(this.readBraced()); - this.error('bad-attr-value', `Expected an attribute value on <${tag}>`, this.pos, tag); - return undefined; - } - - private parseChildren(parentTag: string): ParsedSchemaNode[] { - const children: ParsedSchemaNode[] = []; - for (;;) { - if (this.pos >= this.src.length) { - this.error('unclosed-element', `Unclosed <${parentTag}>`, this.pos, parentTag); - break; - } - // closing tag - if (this.src.startsWith(''); - if (close !== parentTag) { - this.error('mismatched-tag', `Expected but found `, this.pos, parentTag); - } - break; - } - // JSX comment {/* ... */} - if (this.src.startsWith('{/*', this.pos)) { - const end = this.src.indexOf('*/}', this.pos); - if (end === -1) { - this.error('unclosed-comment', 'Unclosed comment', this.pos); - this.pos = this.src.length; - } else { - this.pos = end + 3; - } - continue; - } - // nested element - if (this.peek() === '<') { - const el = this.parseElement(); - if (el) children.push(el); - continue; - } - // expression child {expr} — out of grammar for v1: skip with a warning - if (this.peek() === '{') { - const start = this.pos; - this.readBraced(); - this.error( - 'expression-child', - 'Inline {expression} children are not supported yet — bind via a component prop', - start, - ); - continue; - } - // text - // - // HTML collapses a whitespace run to ONE space; it does not delete it. A - // bare `.trim()` here deleted the space that separates a text run from an - // adjacent sibling element, so `A x page` compiled to - // `A`/`page` and rendered as `Axpage` (objectui#5661). The rule: collapse - // the run, then keep a single leading space only when a sibling precedes - // the run, and a single trailing space only when a sibling element - // follows it. At the parent's own start/end the edge space is still - // dropped, so ` hi
` stays `hi`. A whitespace-only run survives - // as one space only when it sits BETWEEN siblings — that is the bounded - // over-generosity of this rule inside block containers like `- `,
- // pinned in the tests.
- const text = this.readTextRun();
- const collapsed = text.replace(/\s+/g, ' ');
- const core = collapsed.trim();
- const afterSibling = children.length > 0;
- const beforeElement = this.peek() === '<' && !this.src.startsWith(' = {
- '"': '"',
- '\\': '\\',
- '/': '/',
- b: '\b',
- f: '\f',
- n: '\n',
- r: '\r',
- t: '\t',
-};
-
-function readLiteral(src: string): unknown {
- const reader = new LiteralReader(src);
- const value = reader.value();
- if (value === NOT_LITERAL) return NOT_LITERAL;
- reader.ws();
- // Trailing anything means the input was an expression that merely STARTS with
- // a literal (`['a'] + x`, `1 + 2`). Refuse the whole input.
- return reader.done() ? value : NOT_LITERAL;
-}
-
-class LiteralReader {
- private pos = 0;
-
- constructor(private readonly src: string) {}
-
- done(): boolean {
- return this.pos >= this.src.length;
- }
-
- ws(): void {
- while (this.pos < this.src.length && LITERAL_WS.test(this.src[this.pos])) this.pos++;
- }
-
- value(): unknown {
- this.ws();
- const c = this.src[this.pos];
- if (c === undefined) return NOT_LITERAL;
- if (c === '"' || c === "'") return this.string(c);
- if (c === '[') return this.array();
- if (c === '{') return this.object();
- if (this.keyword('true')) return true;
- if (this.keyword('false')) return false;
- if (this.keyword('null')) return null;
- return this.number();
- }
-
- /** A keyword only when it is not the prefix of a longer identifier. */
- private keyword(word: string): boolean {
- if (!this.src.startsWith(word, this.pos)) return false;
- const after = this.src[this.pos + word.length];
- if (after !== undefined && IDENT_CHAR.test(after)) return false;
- this.pos += word.length;
- return true;
- }
-
- private number(): unknown {
- const m = NUMBER.exec(this.src.slice(this.pos));
- if (!m) return NOT_LITERAL;
- this.pos += m[0].length;
- return Number(m[0]);
- }
-
- private string(quote: string): unknown {
- this.pos++; // opening quote
- let out = '';
- for (;;) {
- const c = this.src[this.pos];
- if (c === undefined) return NOT_LITERAL; // unterminated
- if (c === quote) {
- this.pos++;
- return out;
- }
- if (c === '\\') {
- const esc = this.src[this.pos + 1];
- if (esc === undefined) return NOT_LITERAL;
- if (esc === 'u') {
- const hex = this.src.slice(this.pos + 2, this.pos + 6);
- if (!/^[0-9a-fA-F]{4}$/.test(hex)) return NOT_LITERAL;
- out += String.fromCharCode(parseInt(hex, 16));
- this.pos += 6;
- continue;
- }
- // `\'` is legal inside a single-quoted string only — JSON's set otherwise.
- if (esc === "'" && quote === "'") {
- out += "'";
- this.pos += 2;
- continue;
- }
- const simple = SIMPLE_ESCAPE[esc];
- if (simple === undefined) return NOT_LITERAL; // `\x41`, `\0`, line continuation
- out += simple;
- this.pos += 2;
- continue;
- }
- // JSON forbids raw control characters inside a string; so does this.
- if (c < ' ') return NOT_LITERAL;
- out += c;
- this.pos++;
- }
- }
-
- private array(): unknown {
- this.pos++; // '['
- const out: unknown[] = [];
- this.ws();
- if (this.src[this.pos] === ']') {
- this.pos++;
- return out;
- }
- for (;;) {
- const item = this.value();
- if (item === NOT_LITERAL) return NOT_LITERAL;
- out.push(item);
- this.ws();
- const c = this.src[this.pos];
- // A trailing comma leaves `value()` facing `]`, which it refuses — so
- // `['a',]` is NOT in the subset. Only two widenings were ruled.
- if (c === ',') {
- this.pos++;
- continue;
- }
- if (c === ']') {
- this.pos++;
- return out;
- }
- return NOT_LITERAL;
- }
- }
-
- private object(): unknown {
- this.pos++; // '{'
- const out: Record
(node: T): T { - (node as Record ; -} - -export interface ParseResult { - /** the compiled tree, or null when the source has no valid root */ - tree: SchemaElement | null; - diagnostics: Diagnostic[]; -} - -/* ------------------------------------------------------------------ * - * Manifest — the serialized public-tier contract from the registry. - * Produced by serializing `ComponentRegistry.getAllConfigs()` (ADR-0080 §3/§6). - * ------------------------------------------------------------------ */ - -export type ManifestInputType = - | 'string' - | 'number' - | 'boolean' - | 'enum' - | 'array' - | 'object' - | 'color' - | 'date' - | 'code' - | 'file' - | 'slot'; - -export interface ManifestInput { - name: string; - /** - * The input's coarse type: ONE kind, or an ARRAY of kinds when the key's - * contract is a union (objectui#3832). - * - * A value passes {@link validateTree}'s coarse check when ANY arm accepts it, - * and is reported when none does — the array widens what is legal, it does - * not switch the check off. - * - * The single-kind form is unchanged and stays the canonical spelling for a - * one-arm key: `manifestFromConfigs` collapses a one-element array back to - * the bare string, so a manifest gains arrays only where a union was really - * declared and every already-published entry serializes byte-identically. - */ - type: ManifestInputType | ManifestInputType[]; - /** - * The coarse kind of the input's MEMBERS — array elements, or the values of - * an object used as a map — as ONE kind or an ARRAY of kinds for a member - * contract that is a union (objectui#8067). - * - * Absent means "not declared", which is what every input published before - * this key existed says: {@link validateTree} checks no member and the - * codegen emits the unnarrowed element type, exactly as before. So a - * manifest gains this key only where a member kind was really declared, and - * every already-published entry serializes byte-identically. - * - * Read the arms through `inputTypeArms(input.of)` — the same accessor - * `type`'s arms go through, since the two fields carry the same shape and a - * reader that forgets the array form is silently inert on it. - */ - of?: ManifestInputType | ManifestInputType[]; - required?: boolean; - /** allowed values for `enum` inputs */ - enum?: Array ; - /** - * Marks a data-binding input the server must resolve (ADR-0080 §6.3): - * `binding: 'object'` says the input NAMES an object, so the server-side - * binding check knows what to resolve it against. Unrelated to - * `type: 'object'`, the coarse control kind — a record-shaped value and an - * object-naming input are two different facts. - * - * ## The vocabulary is exactly `'object'` — `'field'` is retired on this face too - * - * `'field'` stood beside it from the first draft of ADR-0080 and was never - * written. It was retired on the serializer's INPUT boundary - * (`RegistryConfigLike` in `index.ts`) under ADR-0049 enforce-or-remove by - * the maintainer ruling of 2026-09-07 (decision batch #69), and on THIS - * face by objectui#8315 — the residue that ruling did not name, which left - * one published package narrow on one face and wide on the other. - * - * ⚠️ The argument for leaving this face wide was ANSWERED, not overlooked. - * It runs: producer → reader is a subset relation, so a reader accepting a - * value no producer emits is permissive rather than wrong. Three measured - * facts decided against it (objectui#8315): - * - * 1. **This is not a pure reader face.** `manifestFromConfigs` RETURNS a - * `Manifest`, so `ManifestInput` is also this package's OUTPUT type, - * and this key is fed straight from the already-narrowed boundary. A - * union wider than the producer's is imprecision on the way out, not - * permissiveness on the way in. - * 2. **Its sibling is a pure producer face.** - * `ManifestValidationResult.bindings[].kind` is written by - * `validateTree` by copying this key, so the subset relation runs the - * other way there — see that declaration. The two are COUPLED by that - * assignment: narrowing one alone needs a cast at the only conversion - * site, which is the lenient fallback AGENTS.md #0.1 bans. So "both - * narrow" and "both wide" were the only self-consistent states, and - * only one of them can be justified on the producer face. - * 3. **The permissiveness protected nothing.** `binding: 'field'` has - * zero writers here and zero in the objectstack copy of this package - * (measured 2026-09-09 on both heads, each with a firing - * `binding: 'object'` control), and the only manifest producer in - * either tree is `manifestFromConfigs`, whose input face is narrow. - * - * The reopen route is the ruling's own: a MEASURED need for field bindings - * is filed as a widening with the vocabulary decided then — not - * pre-declared here for a producer that does not exist. - */ - binding?: 'object'; - description?: string; -} - -export interface ManifestComponent { - type: string; - /** plugin namespace — provenance that drives `requires` */ - namespace?: string; - /** - * The declared authoring surface. An input named `children` (type `slot`) - * is ALSO the containment declaration: `validateTree` draws - * `not-a-container` on a child list under any component whose `inputs` - * carry no such entry (objectui#9910; `acceptsChildren` in `validate.ts`). - */ - inputs: ManifestInput[]; - /** - * The NODE SLOTS this component's renderer reads besides `children` - * (objectui#11170): positions in the key-path grammar `@object-ui/types`' - * `NODE_SLOT_DECLARATIONS` states — `trigger`, `items[].content`, - * `regions[].components`. `validateTree` descends each one the way it - * descends `children`, so a slot-held node is judged too. Projected from - * that one declaration by `manifestFromConfigs`'s `slotsFor` option; the - * authoring tier leaves the declaration's RETIRED positions out, as the - * spec's own authoring walks do. ⛔ This tier keeps no slot list of its own: - * a manifest built without the option carries none, and the walk then - * follows `children` alone. - */ - slots?: readonly string[]; - /** - * LAYOUT containment (objectui#6804, objectui#9910 Q2-A): the flag the - * react-page JSX scope builder skips and the public layout ledger lists. - * ⛔ Not "accepts children" — this tier's containment check does not read it. - */ - isContainer?: boolean; - /** - * The authoring tier this entry belongs to (objectui#10735). - * - * Absent = the curated PUBLIC tier (ADR-0080 §4), the JSON-surface - * AI-authoring vocabulary. `'html'` = one of the intrinsic HTML elements a - * `kind:'html'` page may author (ADR-0081 §2), declared by the registry's - * `HTML_TIER_INTRINSICS` roster and carried here so the ONE flat `components` - * map can serve both of its readers: a whitelist reader (`compile`, the - * objectstack gate) takes every key and needs no change; a reader that means - * the curated vocabulary — the `kind:'react'` scope, the block list, a census - * of curated blocks — filters this key out. - * - * ⛔ Not the registration's `tier` copied through. `manifestFromConfigs` - * writes exactly `'html'` or nothing, so every entry published before this - * key existed serialises byte-identically. - */ - tier?: 'html'; -} - -export interface Manifest { - /** keyed by component `type` */ - components: Record Validation `**. `ValidationResult` is exported twice by the spec — `kernel` and - * `contracts`, both `{ valid, errors?: [{ field, message, code? }], warnings? }` - * for PLUGIN MANIFEST validation — and `@object-ui/core` took - * `SchemaNodeValidationResult` under the same convention in batch 4 - * (objectui#3188). Three results, three subjects: a plugin, a schema node, and - * this one, which carries no `valid` flag at all — it returns `diagnostics` - * (severity lives per entry), the `requires` set the compiled page needs, and - * the binding sites the server must resolve. Nothing here is assignable to - * anything there in either direction. - */ -export interface ManifestValidationResult { - diagnostics: Diagnostic[]; - /** unique plugin namespaces referenced — the page's `requires` */ - requires: string[]; - /** - * Binding sites the server must resolve against object schema. - * - * `kind` is a PRODUCER face, not a reader face: `validateTree` writes it, - * copying {@link ManifestInput.binding} at the one site that builds this - * array. So the subset relation that licenses a permissive READER runs the - * other way here — a wider union accepts nothing extra, it obliges every - * consumer to handle an arm this package cannot emit. That is why the - * retired `'field'` arm (`9e37d9b39` on the input boundary, objectui#8315 - * here) is gone from this end as well; the measurements are on - * {@link ManifestInput.binding}. - */ - bindings: Array<{ tag: string; input: string; kind: 'object'; value: unknown }>; -} diff --git a/ui/packages/sdui-parser/src/validate.ts b/ui/packages/sdui-parser/src/validate.ts deleted file mode 100644 index de9579c0f40..00000000000 --- a/ui/packages/sdui-parser/src/validate.ts +++ /dev/null @@ -1,535 +0,0 @@ -/** - * ObjectUI — SDUI tree validation against the registry manifest (ADR-0080 §3/§6) - * - * Shallow, author-time validation: unknown component, unknown/missing prop, - * wrong coarse type, illegal enum value, and containment — a child list under - * a component whose registration declares no `children` input draws - * `not-a-container` (objectui#9910; see `acceptsChildren`). Collects - * `requires` (plugin provenance) and binding sites the SERVER must resolve - * against object schema (we cannot resolve objects/fields here — that check is - * framework-side by design). - * - * The walk descends `children` on every node and, for a component the - * manifest knows, the NODE SLOTS its entry carries (`ManifestComponent.slots`, - * objectui#11170) — the positions besides `children` through which that - * renderer hands nodes back to `SchemaRenderer`, projected from the one - * declaration in `@object-ui/types` by `manifestFromConfigs`. ⛔ No slot list - * lives here. - */ - -import type { - Diagnostic, - Manifest, - ManifestComponent, - ManifestInput, - ManifestInputType, - SchemaElement, - ParsedSchemaNode, - ManifestValidationResult, -} from './types.js'; -import { inputTypeArms } from './input-type.js'; -import { checkDashboardWidgetOptions } from './dashboard-widget-options.js'; -import { checkRetiredBodyDialect } from './body-dialect.js'; -import { checkRetiredVisibilityDialect } from './retired-visibility-dialects.js'; - -/** - * The protocol's ONE child-list key — `BaseSchema.children` — and therefore the - * name of the `inputs` entry a registration declares when its renderer puts - * that list on the page: `{ name: 'children', type: 'slot' }` (objectui#9910). - */ -export const CHILD_LIST_KEY = 'children'; - -/** - * Does this component ACCEPT an authored child list? (objectui#9910) - * - * Read from exactly ONE declaration: an input named {@link CHILD_LIST_KEY} in - * the component's `inputs`. That is the shape ten registrations already - * carried when the maintainer ruled it the containment contract - * (2026-09-24, objectui#9910 Q1-A "declare-and-pin"), and it is held in both - * directions by the runtime census in - * `packages/components/src/renderers/__tests__/container-declaration-ratchet.test.tsx`: - * a renderer that puts `schema.children` on the page without declaring the - * input is red, and a declaration whose renderer never renders the list is - * red too. - * - * ⛔ `isContainer` is NOT consulted and is NOT a fallback. It used to decide - * this branch and it lied both ways: a hand-kept flag drifted from the code - * (objectui#3900 / `7c9b044f4` / #6764 / #6779 found the same drift four times), - * and after objectui#6771 converged a dozen registrations onto `children` - * the flag put a FALSE `not-a-container` on the one key they read - * (objectui#9910). The flag now means LAYOUT containment only — the - * react-page JSX scope and the public layout ledger read it; this tier does - * not (objectui#6804, objectui#9910 Q2-A). - */ -export function acceptsChildren(comp: Pick => - new Set(SDUI_BASE_PROPS.filter((prop) => prop.scope === scope).map((prop) => prop.name)); - -/** The `'every-node'` members of {@link SDUI_BASE_PROPS}: never "unknown prop". */ -const BASE_PROPS = basePropNames('every-node'); - -/** The `'where-undeclared'` members of {@link SDUI_BASE_PROPS}. */ -const WHERE_UNDECLARED_BASE_PROPS = basePropNames('where-undeclared'); - -const isExpr = (v: unknown): boolean => - typeof v === 'object' && v !== null && '$expr' in (v as Record (); - const bindings: ManifestValidationResult['bindings'] = []; - - const visit = (node: ParsedSchemaNode): void => { - if (typeof node === 'string') return; - const comp = manifest.components[node.type]; - if (!comp) { - diagnostics.push({ - severity: 'error', - code: 'unknown-component', - message: `<${node.type}> is not a known component`, - tag: node.type, - }); - } else { - if (comp.namespace) requires.add(comp.namespace); - const byName = new Map(comp.inputs.map((i) => [i.name, i])); - - // required present? - for (const input of comp.inputs) { - if (input.required && !(input.name in node)) { - diagnostics.push({ - severity: 'error', - code: 'missing-required-prop', - message: `<${node.type}> is missing required prop "${input.name}"`, - tag: node.type, - }); - } - } - - // each provided prop - for (const [key, value] of Object.entries(node)) { - if (BASE_PROPS.has(key)) continue; - // A declaration outranks a `'where-undeclared'` base prop - // (objectui#11044): skipped only when this type declares no input of - // that name, so a declared one keeps its type check below. - if (WHERE_UNDECLARED_BASE_PROPS.has(key) && !byName.has(key)) continue; - const input = byName.get(key); - if (!input) { - // The retired `body` child-list dialect gets its replacement named - // rather than the bare "has no prop" every typo gets - // (objectui#6771). Asked INSIDE this branch, so a component that - // declares its own `body` input keeps its declared type check — - // mechanism in `./body-dialect.ts`. Its containment verdict is the - // SAME predicate the `children` branch below reads — the declared - // `children` input, never `isContainer` (objectui#9910) — so the two - // spellings cannot disagree about which components take a list. - // The retired node-level visibility dialects (`visibleOn` / - // `hiddenOn` / `disabledOn`) get their canonical key named the same - // way — mechanism in `./retired-visibility-dialects.ts`. - const retiredBody = checkRetiredBodyDialect(node.type, key, value, acceptsChildren(comp)); - const retiredDialect = retiredBody ?? checkRetiredVisibilityDialect(node.type, key); - diagnostics.push( - retiredDialect ?? { - severity: 'warning', - code: 'unknown-prop', - message: `<${node.type}> has no prop "${key}"`, - tag: node.type, - }, - ); - continue; - } - if (input.binding) { - bindings.push({ tag: node.type, input: key, kind: input.binding, value }); - } - if (isExpr(value)) { - // A braced value that failed JSON materialization compiled to the - // parser's deferred `{ $expr }` marker — and NOTHING downstream - // evaluates that marker: this tier parses, never executes - // (ADR-0080), and no renderer consumes `$expr`. The value therefore - // reaches the renderer as an opaque object, every defensive - // non-array/non-object read degrades it to "not declared", and the - // author's binding silently vanishes (objectui#6598: eight `columns` - // spellings on a data block, all eaten without a single diagnostic — - // rows rendered, zero data columns). ADR-0078 prohibits exactly this - // parsed-but-silently-inert state, so name it at compile time, with - // the fix in the message. - // - // The message must name the CURRENT accepted grammar, and objectui#6614 - // (Q1-A, ruled 2026-08-28) moved it: `interpretBrace` now materializes - // the JS literal subset, so single-quoted strings and unquoted - // identifier keys REACH the renderer and can no longer draw this - // warning. The old wording ("write it as JSON, double-quoted") named a - // now-legal spelling as the illegal one — advice that would have sent - // an author to edit working source. What is left on this side of the - // boundary is a genuine expression, so that is what the message names. - // - // Warning, not error, per the `8d58f46b4` precedent for inert - // authored keys. ⛔ Escalation to error is objectui#6614 Q2 and is - // deliberately NOT part of this change: it belongs at the SAVE GATE, - // once the framework wires the registry manifest into - // `validate-jsx-pages` (objectstack#12719 records that gap). - diagnostics.push({ - severity: 'warning', - code: 'inert-expression', - message: - `<${node.type}> prop "${key}" is a braced expression this tier never evaluates — ` + - `the value will be silently ignored at render. This tier materializes LITERALS only ` + - `(strings, numbers, booleans, null, arrays, objects; quotes may be single or double, ` + - `object keys may be unquoted), e.g. columns={['name','amount']} works — ` + - `columns={rows.map((r) => r.name)} cannot`, - tag: node.type, - }); - } else { - const typeDiag = checkType(node.type, input, value); - if (typeDiag) { - diagnostics.push(typeDiag); - } else { - // Members only once the CONTAINER kind was accepted. Reporting a - // member of a value that is not even the declared container is two - // diagnostics for one mistake, and the second one names positions - // of a shape the author did not write (objectui#8067). - const memberDiag = checkMemberTypes(node.type, input, value); - if (memberDiag) diagnostics.push(memberDiag); - } - } - } - - // containment — decided by the declared `children` input and by NOTHING - // else (objectui#9910 Q1-A). ⛔ No `isContainer` fallback: see - // `acceptsChildren` for why the flag stopped deciding this. - if (node.children?.length && !acceptsChildren(comp)) { - diagnostics.push({ - severity: 'warning', - code: 'not-a-container', - message: `<${node.type}> does not accept children`, - tag: node.type, - }); - } - - // Dashboard widgets: an `options` key riding the spec's `.passthrough()` - // that no renderer consumes is legal, silent and inert — warn, naming - // the consumed set (the 2026-08-23 ruling; census + scope in - // `./dashboard-widget-options.ts`). Like `not-a-container`, this runs - // only for a component the manifest knows: an unresolved tag already - // drew `unknown-component`, and deep diagnostics on it would be noise. - diagnostics.push(...checkDashboardWidgetOptions(node)); - } - - if (node.children) node.children.forEach(visit); - // The node slots this component's renderer reads besides `children` - // (objectui#11170), as its manifest entry declares them. An unknown - // component has no entry and so no slots: its `unknown-component` above is - // the answer, and nothing under it is judged. - for (const path of comp?.slots ?? []) { - for (const element of slotElements(node, path)) visit(element); - } - }; - - if (tree) visit(tree); - return { diagnostics, requires: [...requires], bindings }; -} - -/** The values an `enum` arm admits, flattened from either declaration form. */ -const enumValues = (input: ManifestInput): unknown[] => - (input.enum ?? []).map((e) => (typeof e === 'object' ? e.value : e)); - -/** - * Does ONE coarse arm accept this value? - * - * An arm outside the vocabulary — and `'slot'`, which describes a child - * position rather than a value — accepts everything, preserving the old - * `default: return null` branch: those inputs never drew a diagnostic and must - * not start now. - */ -function armAccepts(arm: ManifestInputType, input: ManifestInput, value: unknown): boolean { - switch (arm) { - case 'number': - return typeof value === 'number'; - case 'boolean': - return typeof value === 'boolean'; - case 'string': - case 'color': - case 'date': - case 'code': - case 'file': - return typeof value === 'string'; - case 'array': - return Array.isArray(value); - case 'object': - return typeof value === 'object' && value !== null && !Array.isArray(value); - case 'enum': - return enumValues(input).includes(value as never); - default: - return true; - } -} - -/** How one arm is named in a diagnostic message. */ -function armExpectation(arm: ManifestInputType, input: ManifestInput): string { - switch (arm) { - case 'number': - return 'a number'; - case 'boolean': - return 'a boolean'; - case 'array': - return 'an array'; - case 'object': - return 'an object'; - case 'enum': - return `one of ${JSON.stringify(enumValues(input))}`; - default: - return 'a string'; - } -} - -/** - * The member positions of a container value, as `[position, member]` pairs, or - * `null` when the value has no member position to speak of. - * - * Arrays index by position and objects by key, which is exactly the pair - * `ComponentInput.of` describes: array ELEMENTS, and the VALUES of an object - * used as a map. A scalar returns `null` rather than an empty list, so a value - * that only satisfied a non-container arm of a union declaration - * (`type: ['string', 'array'], of: 'string'`) is not reported as an empty - * container that trivially conforms — it is simply not the arm `of` describes. - */ -function memberEntries(value: unknown): Array<[string, unknown]> | null { - if (Array.isArray(value)) return value.map((member, index) => [String(index), member]); - if (typeof value === 'object' && value !== null) return Object.entries(value); - return null; -} - -/** - * Coarse MEMBER check, over the arms `of` declares (objectui#8067). - * - * The same question `checkType` asks, one level down and with the same answer - * shape: ANY declared arm accepting a member clears it, a member no arm accepts - * is reported, and an input that declares no `of` is checked exactly as it was - * before the key existed — this function returns immediately on an empty arm - * list, so nothing published today changes severity or gains a diagnostic. - * - * ONE diagnostic per prop, naming every offending position, rather than one per - * member: a page that passes an array of the wrong member kind is one mistake - * made once, and N copies of it is the noise this repo treats as the thing that - * trains authors to dismiss real reports. - * - * Severity mirrors `checkType`'s rule for the same reason — `error` when an - * `enum` arm is present, because a closed list is the one fact this layer can - * be certain about; `warning` otherwise, since the coarse kind is a KIND claim - * and `os validate` / `os build` remain the judge of values. - */ -function checkMemberTypes(tag: string, input: ManifestInput, value: unknown): Diagnostic | null { - const arms = inputTypeArms(input.of); - if (arms.length === 0) return null; - const entries = memberEntries(value); - if (entries === null) return null; - const offenders = entries.filter( - ([, member]) => !arms.some((arm) => armAccepts(arm, input, member)), - ); - if (offenders.length === 0) return null; - const expectation = arms.map((arm) => armExpectation(arm, input)).join(' or '); - return { - severity: arms.includes('enum') ? 'error' : 'warning', - code: 'member-type-mismatch', - message: `<${tag}> prop "${input.name}" expected every member to be ${expectation}` + - ` — ${offenders.map(([position]) => `[${position}]`).join(', ')} ` + - `${offenders.length === 1 ? 'is' : 'are'} not`, - tag, - }; -} - -/** - * Coarse type check, over the arms an input declares (objectui#3832). - * - * ANY arm accepting the value clears the prop — that is what lets a key whose - * contract is a union (`string | number`, or a string plus an inline - * translation map) be declared honestly instead of picking one arm and having - * this function report the other arm's legal values. - * - * When NO arm accepts it the prop is still reported; a union widens what counts - * as legal, it does not turn the check off. Two properties of the reporting are - * deliberate: - * - * - A single-arm input produces the byte-identical diagnostic it always did, - * `invalid-enum` included. This change adds a form; it does not restate the - * old one. - * - A multi-arm input produces ONE diagnostic naming every arm, at the - * STRICTEST arm's severity — `error` when an `enum` arm is present, because - * an enum's closed list is the one fact this layer can be certain about, and - * a value outside it should not become dismissible merely because a second - * arm was added next to it. Its code is `type-mismatch` (not `invalid-enum`) - * since the reported fact is "fits none of the declared arms", and the - * message carries the allowed values so the author still sees the list. - */ -function checkType(tag: string, input: ManifestInput, value: unknown): Diagnostic | null { - const arms = inputTypeArms(input.type); - if (arms.length === 0) return null; - if (arms.some((arm) => armAccepts(arm, input, value))) return null; - - if (arms.length === 1 && arms[0] === 'enum') { - return { - severity: 'error', - code: 'invalid-enum', - message: `<${tag}> prop "${input.name}"=${JSON.stringify(value)} is not one of ${JSON.stringify(enumValues(input))}`, - tag, - }; - } - - return { - severity: arms.includes('enum') ? 'error' : 'warning', - code: 'type-mismatch', - message: `<${tag}> prop "${input.name}" expected ${arms - .map((arm) => armExpectation(arm, input)) - .join(' or ')}`, - tag, - }; -} diff --git a/ui/packages/sdui-parser/tsconfig.json b/ui/packages/sdui-parser/tsconfig.json deleted file mode 100644 index 27f58e966be..00000000000 --- a/ui/packages/sdui-parser/tsconfig.json +++ /dev/null @@ -1,33 +0,0 @@ -{ - "extends": "../../tsconfig.json", - "compilerOptions": { - "outDir": "dist", - "rootDir": "src", - "noEmit": false, - "declaration": true, - // The incremental build RECORD, pinned OUTSIDE the published build output. - // Left unpinned, TypeScript derives it from `outDir`/`rootDir`: a package with - // no `rootDir` gets `dist/tsconfig.tsbuildinfo` -- inside what `files: ["dist", - // ...]` publishes -- and `pnpm check:published-dist` then reds on a byte-identical - // tree as soon as anything runs `tsc` (objectui#9189). Pinned in every composite - // package so the location is a decision, not a side effect of an unrelated option. - "tsBuildInfoFile": "./tsconfig.tsbuildinfo", - "composite": true, - "lib": ["ES2020"] - }, - "include": ["src"], - // Tooling is excluded by DIRECTORY, not just by file NAME. A helper under - // `__tests__/` that is not itself called `*.test.ts` is otherwise a program - // input, and an EMITTING program writes it into the published `dist` - // (objectui#4006 / #4836 / #6943 -- the same defect three times, each found - // by hand). Enforced repo-wide by `pnpm check:published-tsconfig-exclude` - // (objectui#7212), which derives these directory names from `TOOLING_FILE` - // in scripts/check-phantom-dependencies.mjs. - "exclude": [ - "**/__tests__/**", - "**/__mocks__/**", - "**/__benchmarks__/**", - "src/**/*.test.ts", - "src/**/*.test.tsx" - ] -} diff --git a/ui/packages/sdui-parser/tsconfig.test.json b/ui/packages/sdui-parser/tsconfig.test.json deleted file mode 100644 index 0b2cce7e024..00000000000 --- a/ui/packages/sdui-parser/tsconfig.test.json +++ /dev/null @@ -1,30 +0,0 @@ -{ - // Type-checks this package's TESTS, which `tsconfig.json` excludes. - // See `packages/types/tsconfig.test.json` for why that exclusion was a hole: - // the build correctly keeps tests out of `dist`, but nothing else compiled - // them, so a test could assert a contract the compiler never checked. - // - // Wiring this up is what revealed that `render.test.tsx` imported - // `@object-ui/core` and `@object-ui/react` with neither declared in - // package.json — phantom dependencies that only resolved through the ROOT - // tsconfig's `paths` alias and vitest. Both are devDependencies now, so the - // test resolves them the way a consumer would. - "extends": "../../tsconfig.json", - "compilerOptions": { - // objectui#8691: test programs only. One notch above the package build's - // ES2020, mirroring packages/app-shell. The package SOURCE tsconfig is - // untouched, so what this package SHIPS still compiles at the ES2020 - // baseline; nothing here is emitted. - "lib": ["ES2022", "DOM", "DOM.Iterable"], - "noEmit": true, - // The package build emits `dist`; this project emits nothing. - "composite": false, - // Drop the root tsconfig's source-tree `paths` so `@object-ui/*` and - // `@objectstack/spec` resolve through the workspace dependency's built - // `.d.ts` instead of pulling sibling sources in as program inputs (TS6059). - // This is also what makes the phantom-dependency check above meaningful: - // with the alias in place, an undeclared workspace import still compiles. - "paths": {} - }, - "include": ["src/**/*.test.ts", "src/**/*.test.tsx"] -} diff --git a/ui/packages/sdui-parser/verify.ts b/ui/packages/sdui-parser/verify.ts deleted file mode 100644 index d345e40642b..00000000000 --- a/ui/packages/sdui-parser/verify.ts +++ /dev/null @@ -1,70 +0,0 @@ -/* Standalone functional verification (run with tsx — no vitest infra needed). */ -import assert from 'node:assert/strict'; -import { compile, generateDts, manifestFromConfigs } from './src/index.ts'; - -const manifest = manifestFromConfigs([ - { type: 'flex', namespace: 'ui', isContainer: true, inputs: [ - { name: 'direction', type: 'enum', enum: ['row', 'col'] }, - { name: 'gap', type: 'number' }, - { name: 'wrap', type: 'boolean' }, - { name: 'children', type: 'slot' }, - ] }, - { type: 'card', namespace: 'ui', isContainer: true, inputs: [{ name: 'title', type: 'string' }, { name: 'children', type: 'slot' }] }, - { type: 'object-table', namespace: 'plugin-grid', isContainer: false, inputs: [ - { name: 'object', type: 'string', required: true, binding: 'object' }, - { name: 'columns', type: 'array' }, - { name: 'pageSize', type: 'number' }, - ] }, -]); - -const check = (_name: string, fn: () => void) => { - fn(); -}; - -check('compiles valid JSX → tree + requires + bindings', () => { - const r = compile( - ` - `, - manifest, - ); - assert.equal(r.ok, true); - assert.deepEqual(r.diagnostics, []); - assert.equal(r.tree?.type, 'flex'); - assert.equal((r.tree as any).gap, 4); - assert.equal((r.tree as any).wrap, true); - assert.deepEqual(r.requires.sort(), ['plugin-grid', 'ui']); - assert.deepEqual(r.bindings, [{ tag: 'object-table', input: 'object', kind: 'object', value: 'account' }]); -}); - -check('rejects unknown component via whitelist', () => { - const r = compile(`- `, manifest); - assert.equal(r.ok, false); - assert.ok(r.diagnostics.some((d) => d.code === 'forbidden-tag')); -}); - -check('flags missing required prop', () => { - const r = compile(` `, manifest); - assert.equal(r.ok, false); - assert.ok(r.diagnostics.some((d) => d.code === 'missing-required-prop')); -}); - -check('flags illegal enum + coarse type mismatch', () => { - const r = compile(` `, manifest); - const codes = r.diagnostics.map((d) => d.code); - assert.ok(codes.includes('invalid-enum')); - assert.ok(codes.includes('type-mismatch')); -}); - -check('rejects event handlers + raw-html injection', () => { - const r = compile(` `, manifest); - assert.equal(r.diagnostics.filter((d) => d.code === 'forbidden-attr').length, 2); -}); - -check('codegen emits a JSX.IntrinsicElements augmentation', () => { - const dts = generateDts(manifest); - assert.ok(dts.includes('"object-table": ObjectTableProps;')); - assert.ok(dts.includes('object: string;')); - assert.ok(dts.includes('pageSize?: number;')); - assert.ok(dts.includes('direction?: "row" | "col";')); -}); diff --git a/ui/packages/types/src/__tests__/component-input-retired-keys-7493.test.ts b/ui/packages/types/src/__tests__/component-input-retired-keys-7493.test.ts index a23cb10d110..5aa178b7751 100644 --- a/ui/packages/types/src/__tests__/component-input-retired-keys-7493.test.ts +++ b/ui/packages/types/src/__tests__/component-input-retired-keys-7493.test.ts @@ -66,6 +66,8 @@ import type { ComponentInput, ComponentMeta } from '../base'; import { ComponentInputSchema, ComponentMetaSchema } from '../zod/base.zod'; const ROOT = resolve(__dirname, '../../../..'); +/** The monorepo root: the serializer lives in `@objectstack/sdui-parser` there (objectstack#25712 item 3). */ +const MONOREPO_ROOT = resolve(__dirname, '../../../../..'); /** The three retired keys, each with the value the registrations used to write. */ const RETIRED = { @@ -296,7 +298,7 @@ describe('the `ComponentInput` census after the retirement', () => { describe('the publication path: `manifestFromConfigs` forwards every live key', () => { it('reads the serializer source and finds the seven, and none of the three', () => { - const src = readFileSync(resolve(ROOT, 'packages/sdui-parser/src/index.ts'), 'utf8'); + const src = readFileSync(resolve(MONOREPO_ROOT, 'packages/sdui-parser/src/index.ts'), 'utf8'); const fn = src.slice(src.indexOf('export function manifestFromConfigs(')); const forwarded = /inputs: \(c\.inputs \?\? \[\]\)\.map\(\(i\) => \(\{([\s\S]*?)\}\)\)/.exec(fn)?.[1] ?? ''; expect(forwarded.length, 'the serializer no longer maps inputs where this pin reads it').toBeGreaterThan(0); diff --git a/ui/packages/types/src/__tests__/content-channel-parser-tier-clause-10928.test.ts b/ui/packages/types/src/__tests__/content-channel-parser-tier-clause-10928.test.ts index a7790544677..9395b99be60 100644 --- a/ui/packages/types/src/__tests__/content-channel-parser-tier-clause-10928.test.ts +++ b/ui/packages/types/src/__tests__/content-channel-parser-tier-clause-10928.test.ts @@ -15,7 +15,7 @@ * rendered NOTHING. They used to go on "no error, no warning, no element". The * render half of that is true — `SchemaRenderer` strips both keys out of the * props bag it spreads and no renderer reads them. The warning half was false: - * the parser tier's `validateTree` (`@object-ui/sdui-parser`) warns + * the parser tier's `validateTree` (`@objectstack/sdui-parser`) warns * `not-a-container` for a child list under a registration that declares no * `children` input (objectui#9910), and it answers a `body` child list with the * same code (`checkRetiredBodyDialect`, objectui#6771). A reads-neither @@ -28,7 +28,7 @@ * ## Why this file pins the prose, and where the parser half is pinned * * `@object-ui/types` declares no workspace dependency, and its tests import - * none: `@object-ui/sdui-parser` is not importable here without declaring it, + * none: `@objectstack/sdui-parser` is not importable here without declaring it, * which a prose pin does not justify. The behaviour the clause describes is * held where the parser and the registry live, and those pins are named here * so a change to either side has a place to look: diff --git a/ui/packages/types/src/__tests__/silence-clause-parser-tier-closure-10981.test.ts b/ui/packages/types/src/__tests__/silence-clause-parser-tier-closure-10981.test.ts index 4266f4b3394..339e72d4578 100644 --- a/ui/packages/types/src/__tests__/silence-clause-parser-tier-closure-10981.test.ts +++ b/ui/packages/types/src/__tests__/silence-clause-parser-tier-closure-10981.test.ts @@ -12,7 +12,7 @@ * (`unknown-prop`). * * Four more sites in this package said an authored value drew no error and no - * warning. The parser tier's `validateTree` (`@object-ui/sdui-parser`) + * warning. The parser tier's `validateTree` (`@objectstack/sdui-parser`) * answered each of them when objectui#10981 landed, with the code the * registration's declared inputs decide (one has moved since — the `bind` row): * @@ -37,7 +37,7 @@ * ## Why this file pins the prose, and where the parser half lives * * `@object-ui/types` declares no workspace dependency and its tests import - * none, so `@object-ui/sdui-parser` is not importable here (the same reason as + * none, so `@objectstack/sdui-parser` is not importable here (the same reason as * the objectui#10928 and objectui#10959 pins). The four readings behind these * clauses — every key spelling and value shape each sentence describes, over * the live registry, with a render leg — are on objectui#10981's pull request: diff --git a/ui/packages/types/src/__tests__/unknown-prop-parser-tier-clause-10959.test.ts b/ui/packages/types/src/__tests__/unknown-prop-parser-tier-clause-10959.test.ts index b080e3cce7c..5cd21661ca9 100644 --- a/ui/packages/types/src/__tests__/unknown-prop-parser-tier-clause-10959.test.ts +++ b/ui/packages/types/src/__tests__/unknown-prop-parser-tier-clause-10959.test.ts @@ -23,7 +23,7 @@ * * The render half is true: the value changed nothing on the page and logged * nothing. The warning half was false. The parser tier's `validateTree` - * (`@object-ui/sdui-parser`) answers a key its registration does not declare + * (`@objectstack/sdui-parser`) answers a key its registration does not declare * with `unknown-prop`, and `header-bar` declares only `crumbs`, `search`, * `actions` and `rightContent`. It answers `body` the same way on these nine, * whatever its shape, because each of them declares the `children` input: @@ -42,7 +42,7 @@ * ## Why this file pins the prose, and where the parser half lives * * `@object-ui/types` declares no workspace dependency and its tests import - * none, so `@object-ui/sdui-parser` is not importable here without declaring + * none, so `@objectstack/sdui-parser` is not importable here without declaring * it (the same reason as objectui#10928's pin). The `body` half of the parser * behaviour is pinned in `packages/sdui-parser`: "the retired `body` spelling * follows the SAME predicate" in `containment-declared-slot-9910.test.ts`, and diff --git a/ui/packages/types/src/node-slots.ts b/ui/packages/types/src/node-slots.ts index 6798a9abf02..5100798a6b2 100644 --- a/ui/packages/types/src/node-slots.ts +++ b/ui/packages/types/src/node-slots.ts @@ -21,7 +21,7 @@ * declared them, so the three walks that judge a document — the `objectui * check` unevaluated-expression gate (`findUnbindableTextExpressions` in * `@object-ui/cli`), `validateChildren` in `@object-ui/core`'s schema - * validator and `validateTree` in `@object-ui/sdui-parser` — stopped at + * validator and `validateTree` in `@objectstack/sdui-parser` — stopped at * `children` and never reached a node under a slot: a `${…}` on such a node's * `title` reached the user as literal text, unrefused. * @@ -38,7 +38,7 @@ * spelling (objectui#6771) and stays retired: it appears below ONLY on the * types whose renderer was measured still reading it for stored documents, * marked `retired`, and the parser tier's refusal of the spelling by name - * (`RETIRED_CHILD_LIST_KEY` in `@object-ui/sdui-parser`) is unchanged. + * (`RETIRED_CHILD_LIST_KEY` in `@objectstack/sdui-parser`) is unchanged. * * ## Where each row comes from * diff --git a/ui/packages/types/src/zod/layout.zod.ts b/ui/packages/types/src/zod/layout.zod.ts index a3297804db6..e1efc70a41f 100644 --- a/ui/packages/types/src/zod/layout.zod.ts +++ b/ui/packages/types/src/zod/layout.zod.ts @@ -614,7 +614,7 @@ const FLEX_FLAT_PROP = * bag, and as code composes it. A stored flat `flex` node keeps rendering, * because `SchemaRenderer` reads both spellings and the narrowing is on the * authoring faces only; a node compiled from the `kind: 'html'` JSX tier - * (`@object-ui/sdui-parser`) never passes through this face. + * (`@objectstack/sdui-parser`) never passes through this face. */ export const FlexBlockSchema = BaseSchema.extend({ type: z.literal('flex'), diff --git a/ui/packages/vscode-extension/src/__tests__/body-dialect-children-arm-7181.test.ts b/ui/packages/vscode-extension/src/__tests__/body-dialect-children-arm-7181.test.ts index 8a3f662cddd..ef9a516c2f5 100644 --- a/ui/packages/vscode-extension/src/__tests__/body-dialect-children-arm-7181.test.ts +++ b/ui/packages/vscode-extension/src/__tests__/body-dialect-children-arm-7181.test.ts @@ -59,7 +59,7 @@ * dropped that second arm — the past tense is load-bearing, because a reader * replaying this sentence against `@object-ui/core` today finds one spelling), * and the manifest - * tier's `BASE_PROPS` in `@object-ui/sdui-parser` (which carries `children` and + * tier's `BASE_PROPS` in `@objectstack/sdui-parser` (which carries `children` and * does NOT carry `body`). Both readers in this package guarded their child-list * recursion on `schema.body` ALONE. * @@ -525,7 +525,8 @@ describe('the two spellings of the retired key cannot drift (objectui#6771)', () it('the extension and `sdui-parser` name the same key', () => { const parserSource = readFileSync( - resolve(HERE, '../../../sdui-parser/src/body-dialect.ts'), + // The one parser: the monorepo root's `packages/sdui-parser` (#25712 item 3). + resolve(HERE, '../../../../../packages/sdui-parser/src/body-dialect.ts'), 'utf8' ); diff --git a/ui/scripts/__tests__/check-dist-completeness.test.ts b/ui/scripts/__tests__/check-dist-completeness.test.ts index c317fec3581..9b533c9e6a7 100644 --- a/ui/scripts/__tests__/check-dist-completeness.test.ts +++ b/ui/scripts/__tests__/check-dist-completeness.test.ts @@ -269,7 +269,7 @@ describe('this repository', () => { const tscPackages = discoverTscPackages(repoRoot) as Array<{ name: string; dir: string }>; it('finds the tsc-built packages', () => { - expect(tscPackages.length).toBeGreaterThanOrEqual(12); + expect(tscPackages.length).toBeGreaterThanOrEqual(11); }); it.each(tscPackages.map((p) => [p.name, p.dir] as const))( diff --git a/ui/scripts/__tests__/package-files-exist.test.ts b/ui/scripts/__tests__/package-files-exist.test.ts index 308a64caef9..dd382071c31 100644 --- a/ui/scripts/__tests__/package-files-exist.test.ts +++ b/ui/scripts/__tests__/package-files-exist.test.ts @@ -442,20 +442,21 @@ describe('published packages that declare a license ship its text (objectui#3696 // Same anti-vacuity floor as the guard above, sitting just under the 39 // measured on main@3e601773e. A predicate that quietly matches nothing — // a renamed `license` field, a lost workspace root, a `private` default - // flipped — would otherwise report success over an empty set. - expect(owingPackages.length).toBeGreaterThanOrEqual(38); - - // The two packages objectui#3696 fixed must be in scope BY NAME. If either - // drops out of the population, this guard has stopped watching the exact - // spot that motivated it, and the pin below would pass on a package nobody - // is checking any more. + // flipped — would otherwise report success over an empty set. Lowered by + // one when `@object-ui/sdui-parser` was retired for the root + // `@objectstack/sdui-parser` (objectstack#25712 item 3): 37 measured then. + expect(owingPackages.length).toBeGreaterThanOrEqual(37); + + // The package objectui#3696 fixed must be in scope BY NAME. If it drops + // out of the population, this guard has stopped watching the exact spot + // that motivated it, and the pin below would pass on a package nobody is + // checking any more. (The second, `@object-ui/sdui-parser`, was retired + // for `@objectstack/sdui-parser` by objectstack#25712 item 3, which carries + // its MIT notice at the repo root.) const names = owingPackages.map((p) => p.name); expect(names, '@object-ui/react-runtime must still be required to ship license text').toContain( '@object-ui/react-runtime', ); - expect(names, '@object-ui/sdui-parser must still be required to ship license text').toContain( - '@object-ui/sdui-parser', - ); }); it('every package that declares a license has the text on disk', () => { @@ -521,14 +522,13 @@ describe('published packages that declare a license ship its text (objectui#3696 ).toEqual([]); }); - it('pins the three packages fixed in objectui#3696 / objectui#3702', () => { + it('pins the packages fixed in objectui#3696 / objectui#3702', () => { // The general assertion covers these, but naming them means a revert points // straight at the issue that explains why the files have to be there — // and, unlike the general assertion, this cannot be satisfied by adding a // baseline line. const fixed: Record