@ai-matrx/content-ir 0.10.1 → 0.10.3

package/CHANGELOG.md

@@ -1,5 +1,57 @@
 # Changelog
 
+## 0.10.3 — 2026-08-31
+
+**Bug fix — inline objects nest to any depth, on the streaming path too.**
+`validateObjectAgainstFields` always recursed without limit, but
+`resolveParentFieldSchema` looked a field up only through KIND-typed parents.
+A second-level `inline_object` was therefore invisible mid-stream: it
+registered no inline context and closed as an untyped object
+(`Object is missing "__kind"`), degrading the whole instance to
+`kindState: "raw"` — for a shape the kind's own schema declares. Found
+declaring the true `lulu_print_job` shape after 0.10.2
+(`costs.shipping_cost`); the same seam also gates `json`-any opacity and
+`record` members nested inside an inline object.
+
+Field lookup now resolves through an inline-object parent's field map first.
+Guard: `__tests__/kind-parser.test.ts` § "inline objects nest to any depth"
+(three-deep nesting resolves; chunking-invariant so the streaming path is
+covered; a wrong type deep inside still degrades), proven failing on the
+unfixed parser with three `Object is missing "__kind"` raws.
+
+### Consumer action
+
+None required — this only widens what validates. A mirror schema that flattened
+a nested shape to `json` to survive can now declare the real `inline_object`.
+
+## 0.10.2 — 2026-08-30
+
+**Bug fix — `nullable` is a FIELD law, not a scalar law.** `validateFinalFieldValue`
+consulted `nullable` only on scalar-shaped fields and `json[]`. Every other branch
+(`object`, `inline_object`, `record`, `array`, `string[]`/`number[]`/`boolean[]`)
+opened with a shape check that reads `null` as a type violation and returned an error
+before `nullable` was ever looked at — so a field a kind legitimately declares
+nullable, whose value is genuinely `null`, failed validation and degraded the WHOLE
+instance to `kindState: "raw"`, rendering through the `generic_structured` fallback.
+Reproduced live on `lulu_print_job` (`costs: null`, `estimated_shipping_dates: null`).
+
+`nullable` now short-circuits at the top of `validateFinalFieldValue` for every field
+type, and the same law was applied to the streaming placement path
+(`validateValueAgainstField`), where a `null` arrives as a scalar token and every
+shape check would equally have rejected it — the sibling of the same defect. Messages
+for non-nullable nulls are unchanged. Guard: three cases in
+`__tests__/kind-parser.test.ts` (all five shapes null on a nullable field stays typed;
+chunking-invariant so the streaming path is covered; a null on a NON-nullable field
+still degrades), proven failing on the unfixed parser before the fix landed.
+
+### Consumer action
+
+None required — this only widens what validates. Kinds that were declared `json` with
+a comment to work around this bug (matrx-frontend `features/content-ir/kinds/print-kinds.ts`)
+can go back to their true `object` / `inline_object` / `record` type with
+`nullable: true`, and the ~23 existing sites already declaring `nullable: true` on an
+object-shaped field stop being latent bugs.
+
 ## 0.10.0 — 2026-08-30
 
 **Non-breaking.** Every existing `@ai-matrx/content-ir` import keeps working

package/dist/core.cjs

@@ -1654,9 +1654,10 @@ var KindStreamParser = class {
   }
   validateFinalFieldValue(fieldSchema, value, fieldName, objectKind) {
     if (fieldSchema.type === "json") return null;
+    if (value === null && fieldSchema.nullable === true) return null;
     if (fieldSchema.type === "json[]") {
       if (value === null) {
-        return fieldSchema.nullable ? null : `Field "${fieldName}" on kind "${objectKind}" cannot be null.`;
+        return `Field "${fieldName}" on kind "${objectKind}" cannot be null.`;
       }
       if (!Array.isArray(value)) {
         return `Field "${fieldName}" on kind "${objectKind}" must be an array.`;
@@ -1753,6 +1754,7 @@ var KindStreamParser = class {
     if (fieldSchema.type === "json") {
       return null;
     }
+    if (value === null && fieldSchema.nullable === true) return null;
     if (fieldSchema.type === "array" || fieldSchema.type === "json[]") {
       return valueKind === "array" ? null : `Field "${fieldName}" must be an array.`;
     }
@@ -1881,6 +1883,8 @@ var KindStreamParser = class {
     const fieldKey = this.fieldKeyFromPath(path);
     if (!fieldKey) return void 0;
     const parentPath = path.slice(0, -1);
+    const inlineFields = this.inlineSchemas.get(this.pathKey(parentPath));
+    if (inlineFields) return inlineFields[fieldKey];
     const parentKind = this.getObjectKindForPath(parentPath);
     if (!parentKind) return void 0;
     return this.lookupSchema(parentKind)?.fields[fieldKey];