@@ -0,0 +1,14 @@
+---
+"@objectstack/sdui-parser": minor
+---
+
+The save gate now stamps `inert-quick-add` and `member-type-mismatch`, the two diagnostics that existed only in objectui's copy of this parser — so a page no longer saves clean here and renders with a different verdict there (#17645).
+
+The two copies of this parser owe each other one thing: byte agreement on the accepted grammar and on diagnostic codes. This copy runs the **save gate** and objectui's runs the **renderer**, so a code on one side only is a dialect — the author gets one reading when they save and another when the page draws, which is surface-dependent and therefore reaches them as intermittent. Measured at the ported revision: objectui stamped 26 codes, this copy stamped 24, and the missing two were exactly these.
+
+- **`inert-quick-add`** (warning) — `quickAdd` on `<object-kanban>` reaches no control. The Quick Add button is gated on **both** `quickAdd` and an `onQuickAdd` handler, and `onQuickAdd` takes a function, which no page on this tier can write (this tier parses, it never executes) and which the board substitutes none of its own for. It **replaces** the `unknown-prop` this copy used to emit for the key, which was false against the contract: `ComponentPropsMap['object-kanban']` publishes `quickAdd`, so an author who checked the spec found the warning contradicted and kept a key that will never do anything. Asked ahead of the declaration lookup on purpose — the claim is about the render path, so declaring the key must not silently disarm it. A falsy value and an unevaluated braced expression are deliberately untouched.
+- **`member-type-mismatch`** (warning; `error` when an `enum` arm is present) — the coarse type check one level down, over the member kind an input declares. This brings the `ManifestInput.of` key and its three readers with it: the validator, the serializer's canonicalization, and the codegen's element type. `of: 'string'` on an array input now types the members `string[]` in the generated `.d.ts` instead of `unknown[]`, and a member no declared arm accepts draws **one** diagnostic naming every offending position rather than one per member.
+
+**Nothing published changes shape for an input that declares no `of`.** The key is absent-means-undeclared: the validator checks no member, the codegen emits the unnarrowed element type, and `manifestFromConfigs` publishes no `of` at all, so an entry written before the key existed serializes byte-identically. Measured on the tracked `sdui.manifest.json`: 0 of 339 inputs declare `of`, and the artefact regenerates to the same sha256 across this change.
+
+⚠️ **Both new codes are diagnostics, not a new red gate.** Each is a warning, so `compile().ok` — the save gate's pass/fail — is unchanged, and a page that saves today still saves. Escalating an inert authored key to `error` is a separate question and belongs at the save gate, not here.
@@ -108,6 +108,19 @@ describe('an authored `quickAdd` is diagnosed on the ObjectKanban tags', () => {
     expect(HOST_TAGS).toEqual(['object-kanban']);
   });
 
+  it('the stamped literal equals the exported constant', () => {
+    // objectui stamps `code: INERT_QUICK_ADD`; this copy stamps the inline
+    // literal, because `check:dispatcher-error-vocabulary` cannot reduce a
+    // kebab-case constant at a `code:` position (the divergence is documented
+    // at the stamp, and is the same one `unconsumed-widget-option` carries).
+    // This row is what keeps the two spellings from drifting apart — and the
+    // lockstep gate resolves the identifier through this constant, so both
+    // copies still agree on the same code.
+    expect(INERT_QUICK_ADD).toBe('inert-quick-add');
+    const [diagnostic] = diagnose({ type: 'object-kanban', objectName: 'task', quickAdd: true });
+    expect(diagnostic.code).toBe(INERT_QUICK_ADD);
+  });
+
   it.each(HOST_TAGS)('<%s> — an authored `quickAdd: true` draws exactly one warning', (tag) => {
     const diagnostics = diagnose({ type: tag, objectName: 'task', quickAdd: true });
     expect(diagnostics).toHaveLength(1);
 
@@ -149,7 +149,23 @@ export function checkKanbanQuickAdd(tag: string, key: string, value: unknown): D
   if (!value) return null;
   return {
     severity: 'warning',
-    code: INERT_QUICK_ADD,
+    // DIVERGENCE FROM OBJECTUI, and the only one below this file's header:
+    // objectui writes `code: INERT_QUICK_ADD` here. This repo runs
+    // `check:dispatcher-error-vocabulary`, whose `objlitconst` shape reads the
+    // SCREAMING_SNAKE constant NAME at a `code:` position and then must reduce
+    // it to a literal — and its literal grammar is `[A-Za-z][A-Za-z0-9_]*`,
+    // which a KEBAB-case value cannot satisfy. So the constant form is reported
+    // as an unresolvable code constant, and that finding cannot be declared
+    // away. `inert-quick-add` is a parser DIAGNOSTIC code, not an ADR-0112 wire
+    // code, and an inline quoted literal is the form both vocabulary gates
+    // already accept for the sibling diagnostic codes in `validate.ts` and for
+    // `unconsumed-widget-option` next door. The emitted VALUE is unchanged, and
+    // the test next door pins it equal to `INERT_QUICK_ADD` so the two
+    // spellings cannot drift apart. ⛔ This does NOT weaken the lockstep: that
+    // gate resolves an identifier at a code position through the package's own
+    // module-level constants, so both spellings reduce to the same code and the
+    // two copies still agree on all 26.
+    code: 'inert-quick-add',
     message:
       `<${tag}> prop "${QUICK_ADD_KEY}" reaches no control — the Quick Add button is gated on ` +
       `BOTH "${QUICK_ADD_KEY}" and an "onQuickAdd" handler, and this block supplies neither half ` +