@object-ui/sdui-parser 17.5.0 → 17.7.0

package/dist/index.js

@@ -7,10 +7,15 @@
  */
 export * from './types.js';
 export { parseJsx, interpretBrace } from './parse.js';
-export { validateTree } from './validate.js';
+export { HTML_TIER_NODE, isHtmlTierNode, markHtmlTierNode } from './provenance.js';
+export { validateTree, acceptsChildren, CHILD_LIST_KEY, SDUI_BASE_PROPS } from './validate.js';
+export { checkDashboardWidgetOptions, CONSUMED_WIDGET_OPTION_KEYS, DASHBOARD_WIDGET_HOST_TYPES, UNCONSUMED_WIDGET_OPTION, } from './dashboard-widget-options.js';
 export { generateDts, propsName, generateBlockList } from './codegen.js';
+export { inputTypeArms, canonicalizeInputType, MANIFEST_INPUT_TYPES } from './input-type.js';
+export { checkRetiredBodyDialect, RETIRED_CHILD_LIST_KEY } from './body-dialect.js';
 import { parseJsx } from './parse.js';
 import { validateTree } from './validate.js';
+import { canonicalizeInputType } from './input-type.js';
 /**
  * The authoritative pipeline: parse (with the manifest's tags as the whitelist)
  * → validate against the manifest → derive `requires` + binding sites.
@@ -52,19 +57,10 @@ export function assertFullyLoaded(configs) {
         `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.`);
 }
-const INPUT_TYPES = new Set([
-    'string',
-    'number',
-    'boolean',
-    'enum',
-    'array',
-    'object',
-    'color',
-    'date',
-    'code',
-    'file',
-    'slot',
-]);
+/* 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.
  *
@@ -93,9 +89,22 @@ export function manifestFromConfigs(configs, opts = {}) {
             type: c.type,
             namespace: c.namespace,
             isContainer: c.isContainer,
+            // 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: (INPUT_TYPES.has(i.type) ? i.type : 'string'),
+                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,

package/dist/input-type.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 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 declare const MANIFEST_INPUT_TYPES: ReadonlySet<string>;
+/**
+ * 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 declare function inputTypeArms(type: ManifestInput['type'] | undefined): ManifestInputType[];
+/**
+ * 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 declare function canonicalizeInputType(type: unknown): ManifestInputType | ManifestInputType[];

package/dist/input-type.js

@@ -0,0 +1,69 @@
+/**
+ * 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.
+ */
+/** The eleven coarse kinds, as a runtime set for guarding untyped input. */
+export const MANIFEST_INPUT_TYPES = 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) {
+    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) {
+    const arms = (Array.isArray(type) ? type : [type]).filter((arm) => 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;
+}

package/dist/parse.d.ts

@@ -17,8 +17,17 @@ import type { ParseOptions, ParseResult } from './types.js';
 export declare function parseJsx(source: string, options?: ParseOptions): ParseResult;
 /**
  * Interpret a braced attribute value `{...}`.
- * JSON-literal values (numbers, booleans, null, strings, arrays, objects with
- * quoted keys) are materialized. Anything else is kept as a deferred expression
- * marker `{ $expr }` — typed and validated later, NEVER evaluated here.
+ *
+ * Strict-JSON values are materialized by `JSON.parse`, exactly as they always
+ * were. Beyond that, the JS **literal subset** below is materialized too
+ * (objectui#6614 Q1-A, maintainer ruling 2026-08-28). Anything left over — a
+ * genuine expression — is kept as the deferred marker `{ $expr }`: typed and
+ * validated later, drawing `inert-expression`, and NEVER evaluated here.
+ *
+ * ORDER IS LOAD-BEARING. `JSON.parse` runs FIRST and is untouched, so every
+ * input JSON accepts takes byte-identically the path it took before the literal
+ * subset existed. The reader below only ever sees strings `JSON.parse` has
+ * already thrown on, which makes strict-JSON invariance a property of the
+ * structure rather than of a test.
  */
 export declare function interpretBrace(raw: string): unknown;

package/dist/parse.js

@@ -13,9 +13,51 @@
  *   child    := element | text | jsx-block-comment
  *   tag      := [A-Za-z][A-Za-z0-9:_-]star      (matches registry keys)
  */
+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 (`<flex type="grid">`) — 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 (`<object-chart type="bar">`, 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, options = {}) {
     return new Parser(source, options).parseDocument();
 }
@@ -84,7 +126,16 @@ class Parser {
             const attr = this.parseAttr(start, tag);
             if (!attr)
                 break;
-            props[attr.name] = attr.value;
+            // `drop` is set only for the refused discriminator attribute, and only so
+            // that ONE diagnostic is what the author gets. The `__forbidden_<name>`
+            // 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;
@@ -98,7 +149,30 @@ class Parser {
         else {
             this.error('unterminated-open-tag', `Unterminated <${tag}> open tag`, start, tag);
         }
-        const node = { type: tag, ...props };
+        // 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 = markHtmlTierNode({ ...props, type: tag });
         if (children && children.length)
             node.children = children;
         return node;
@@ -117,6 +191,14 @@ class Parser {
             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 };
@@ -178,10 +260,31 @@ class Parser {
                 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 <strong>x</strong> 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 `<p>  hi  </p>` 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 `<ul>`,
+            // pinned in the tests.
             const text = this.readTextRun();
-            const trimmed = text.replace(/\s+/g, ' ').trim();
-            if (trimmed)
-                children.push(trimmed);
+            const collapsed = text.replace(/\s+/g, ' ');
+            const core = collapsed.trim();
+            const afterSibling = children.length > 0;
+            const beforeElement = this.peek() === '<' && !this.src.startsWith('</', this.pos);
+            if (core) {
+                const lead = afterSibling && collapsed.startsWith(' ') ? ' ' : '';
+                const trail = beforeElement && collapsed.endsWith(' ') ? ' ' : '';
+                children.push(`${lead}${core}${trail}`);
+            }
+            else if (collapsed && afterSibling && beforeElement) {
+                children.push(' ');
+            }
         }
         return children;
     }
@@ -271,9 +374,18 @@ class Parser {
 }
 /**
  * Interpret a braced attribute value `{...}`.
- * JSON-literal values (numbers, booleans, null, strings, arrays, objects with
- * quoted keys) are materialized. Anything else is kept as a deferred expression
- * marker `{ $expr }` — typed and validated later, NEVER evaluated here.
+ *
+ * Strict-JSON values are materialized by `JSON.parse`, exactly as they always
+ * were. Beyond that, the JS **literal subset** below is materialized too
+ * (objectui#6614 Q1-A, maintainer ruling 2026-08-28). Anything left over — a
+ * genuine expression — is kept as the deferred marker `{ $expr }`: typed and
+ * validated later, drawing `inert-expression`, and NEVER evaluated here.
+ *
+ * ORDER IS LOAD-BEARING. `JSON.parse` runs FIRST and is untouched, so every
+ * input JSON accepts takes byte-identically the path it took before the literal
+ * subset existed. The reader below only ever sees strings `JSON.parse` has
+ * already thrown on, which makes strict-JSON invariance a property of the
+ * structure rather than of a test.
  */
 export function interpretBrace(raw) {
     const trimmed = raw.trim();
@@ -281,6 +393,242 @@ export function interpretBrace(raw) {
         return JSON.parse(trimmed);
     }
     catch {
-        return { $expr: trimmed };
+        const literal = readLiteral(trimmed);
+        return literal === NOT_LITERAL ? { $expr: trimmed } : literal;
+    }
+}
+/* ---------------------- the JS literal subset (#6614) ---------------------- */
+/**
+ * EXACTLY TWO widenings over JSON, and nothing else:
+ *
+ *   1. **single-quoted strings** — `{'name'}`, `{['name','amount']}`, and in
+ *      key position `{{'pageSize': 25}}`;
+ *   2. **unquoted identifier object keys** — `{{pageSize: 25}}`.
+ *
+ * Everything else JSON refuses is still refused and still becomes `{ $expr }`:
+ * 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.
+ *
+ * That list is deliberately short. This is a VALUE grammar, not an evaluator:
+ * it contains no identifier lookup and no operator, so there is nothing here to
+ * execute (ADR-0080 — this tier parses, never executes). The widening moves the
+ * spellings an author writes by habit onto the materialized side; it does not
+ * move the boundary between data and code.
+ */
+const NOT_LITERAL = Symbol('not-a-literal');
+/** JSON's whitespace set, not JS's — narrower, and one less thing to diverge. */
+const LITERAL_WS = /[ \t\n\r]/;
+const IDENT_START = /[A-Za-z_$]/;
+const IDENT_CHAR = /[A-Za-z0-9_$]/;
+/** JSON's number grammar verbatim: no leading `+`, no `.5`, no `1.`, no hex. */
+const NUMBER = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/;
+/** JSON's escape set. `\'` is added for single-quoted strings only. */
+const SIMPLE_ESCAPE = {
+    '"': '"',
+    '\\': '\\',
+    '/': '/',
+    b: '\b',
+    f: '\f',
+    n: '\n',
+    r: '\r',
+    t: '\t',
+};
+function readLiteral(src) {
+    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 {
+    constructor(src) {
+        Object.defineProperty(this, "src", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: src
+        });
+        Object.defineProperty(this, "pos", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    done() {
+        return this.pos >= this.src.length;
+    }
+    ws() {
+        while (this.pos < this.src.length && LITERAL_WS.test(this.src[this.pos]))
+            this.pos++;
+    }
+    value() {
+        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. */
+    keyword(word) {
+        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;
+    }
+    number() {
+        const m = NUMBER.exec(this.src.slice(this.pos));
+        if (!m)
+            return NOT_LITERAL;
+        this.pos += m[0].length;
+        return Number(m[0]);
+    }
+    string(quote) {
+        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++;
+        }
+    }
+    array() {
+        this.pos++; // '['
+        const out = [];
+        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;
+        }
+    }
+    object() {
+        this.pos++; // '{'
+        const out = {};
+        this.ws();
+        if (this.src[this.pos] === '}') {
+            this.pos++;
+            return out;
+        }
+        for (;;) {
+            this.ws();
+            const key = this.key();
+            if (key === NOT_LITERAL)
+                return NOT_LITERAL;
+            this.ws();
+            if (this.src[this.pos] !== ':')
+                return NOT_LITERAL;
+            this.pos++;
+            const item = this.value();
+            if (item === NOT_LITERAL)
+                return NOT_LITERAL;
+            // ⚠️ Plain `out[key] = item` would hand an authored `__proto__` key the
+            // prototype SETTER. `JSON.parse` creates an ordinary own data property,
+            // and this path must too: the whole point of this tier is that untrusted
+            // source is safe to parse, so a widening must not open a
+            // prototype-pollution lever the strict-JSON path never had.
+            Object.defineProperty(out, key, {
+                value: item,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+            this.ws();
+            const c = this.src[this.pos];
+            if (c === ',') {
+                this.pos++;
+                continue;
+            }
+            if (c === '}') {
+                this.pos++;
+                return out;
+            }
+            return NOT_LITERAL;
+        }
+    }
+    /** A quoted string, or a bare identifier — the second ruled widening. */
+    key() {
+        const c = this.src[this.pos];
+        if (c === '"' || c === "'")
+            return this.string(c);
+        if (c !== undefined && IDENT_START.test(c)) {
+            const start = this.pos;
+            this.pos++;
+            while (this.pos < this.src.length && IDENT_CHAR.test(this.src[this.pos]))
+                this.pos++;
+            return this.src.slice(start, this.pos);
+        }
+        return NOT_LITERAL;
     }
 }