@ai-matrx/content-ir 0.7.0 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## 0.9.0 — 2026-08-29
+
+- **A nested `__kind` object now registers the CHILD's schema, not just a ref
+  to it.** Arrays of `__kind` items have always drafted their item kind; an
+  object-VALUED field declaring a `__kind` returned
+  `{type:"object", kind}` and dropped the child's fields on the floor.
+
+  The consequence was not a missing child — it was a broken PARENT. The parser
+  had a field predicting `mx_child` with no schema registered for it, so the
+  child degraded, the parent failed validation, and the parent fell to
+  `broken-instance` and lost its component over a child the very same schema
+  had fully described one line above.
+
+  Found by matrx-frontend's new render matrix (every recognition path × every
+  shape archetype) on its first run.
+
+## 0.8.0 — 2026-08-29
+
+- **A field is never DROPPED — it widens to `json`.** Every field-map loop in
+  the JSON Schema → KindSchema direction now goes through
+  `convertFieldOrWiden`. A construct the vocabulary cannot name precisely — a
+  2-D array (`rows: [[...]]`), an array of untyped objects, a mixed `anyOf`, an
+  unresolvable `$ref` — becomes `json` with a warning instead of disappearing
+  from the kind.
+
+  WHY THIS IS NOT A DETAIL: a dropped field does not merely lose type
+  information, it inverts the outcome. The field is absent from the field map,
+  so a real payload's value for it becomes unknown-key residue; if the schema
+  marked it required, validation FAILS; the node goes `raw`; and the render
+  route correctly refuses it a component. Dropping one field could cost a kind
+  its entire component. `json` is always a true statement about such a field.
+
+  A recovery also downgrades whatever the failed attempt logged at `error`
+  severity to `warning`, so a host that screams on errors does not scream
+  about kinds that render perfectly.
+
+- Live-corpus result: all **502** active kinds now derive a complete field map
+  from `emitted_json_schema` alone (was 62 with a stored field list, and 466
+  before this change). 28 carry at least one widened field, and each one names
+  itself in the problems list so the schema can be tightened later.
+
 ## 0.7.0 — 2026-08-29
 
 - **`kindSchemaFromJsonSchema` — the registry-facing door for deriving a

package/dist/index.cjs

@@ -3213,14 +3213,13 @@ function registerDeclaredKindDraft(declaredKind, objectNode, path, ctx) {
   for (const [propName, propNode] of Object.entries(objectNode.properties)) {
     if (!isRecord4(propNode)) continue;
     if (propName === KIND_KEY) continue;
-    const converted = convertProperty(
+    fields[propName] = convertFieldOrWiden(
       propName,
       propNode,
       memberRequired.has(propName),
       `${path}.${propName}`,
       ctx
     );
-    if (converted) fields[propName] = converted;
   }
   ctx.blockSchemas.push({
     slug: declaredKind,
@@ -3228,6 +3227,21 @@ function registerDeclaredKindDraft(declaredKind, objectNode, path, ctx) {
     fields
   });
 }
+function convertFieldOrWiden(fieldName, node, required, path, ctx) {
+  const before = ctx.problems.length;
+  const converted = convertProperty(fieldName, node, required, path, ctx);
+  if (converted) return converted;
+  for (let i = before; i < ctx.problems.length; i++) {
+    const problem = ctx.problems[i];
+    if (problem && problem.severity === "error") problem.severity = "warning";
+  }
+  ctx.problems.push({
+    severity: "warning",
+    path,
+    message: `Field "${fieldName}" has no exact field type \u2014 carried as any JSON value (json) rather than dropped from the kind.`
+  });
+  return { ...requiredNullableFlags(required), type: "json" };
+}
 function convertProperty(fieldName, node, required, path, ctx) {
   const core = convertPropertyCore(fieldName, node, required, path, ctx);
   const field = core === null ? null : attachNodeMetadata(node, core);
@@ -3618,16 +3632,13 @@ function convertPropertyCore(fieldName, node, required, path, ctx) {
       for (const [propName, propNode] of Object.entries(itemNode.properties)) {
         if (!isRecord4(propNode)) continue;
         if (propName === KIND_KEY) continue;
-        const converted = convertProperty(
+        itemFields[propName] = convertFieldOrWiden(
           propName,
           propNode,
           itemRequired.has(propName),
           `${path}[].${propName}`,
           ctx
         );
-        if (converted) {
-          itemFields[propName] = converted;
-        }
       }
       const alreadyHasBlockKind = propNameIsBlockKind(itemNode.properties) || itemRequired.has(KIND_KEY);
       ctx.arrayBindings.push({
@@ -3672,19 +3683,24 @@ function convertPropertyCore(fieldName, node, required, path, ctx) {
       for (const [propName, propNode] of Object.entries(node.properties)) {
         if (!isRecord4(propNode)) continue;
         if (propName === KIND_KEY) continue;
-        const converted = convertProperty(
+        nestedFields[propName] = convertFieldOrWiden(
           propName,
           propNode,
           nestedRequired.has(propName),
           `${path}.${propName}`,
           ctx
         );
-        if (converted) {
-          nestedFields[propName] = converted;
-        }
       }
       const referencedKind = readBlockKindFromProperties(node.properties);
       if (referencedKind) {
+        if (!ctx.refsInProgress.has(referencedKind)) {
+          ctx.refsInProgress.add(referencedKind);
+          try {
+            registerDeclaredKindDraft(referencedKind, node, path, ctx);
+          } finally {
+            ctx.refsInProgress.delete(referencedKind);
+          }
+        }
         return {
           ...requiredNullableFlags(required, nullable),
           type: "object",
@@ -3866,16 +3882,13 @@ function convertAiSchemaToBlockFields(schemaName, rootSchema, strict) {
   for (const [fieldName, fieldNode] of Object.entries(properties)) {
     if (!isRecord4(fieldNode)) continue;
     if (fieldName === KIND_KEY) continue;
-    const converted = convertProperty(
+    convertedFields[fieldName] = convertFieldOrWiden(
       fieldName,
       fieldNode,
       required.has(fieldName),
       fieldName,
       ctx
     );
-    if (converted) {
-      convertedFields[fieldName] = converted;
-    }
   }
   const rootHasKind = propNameIsBlockKind(properties) || required.has(KIND_KEY);
   if (!rootHasKind) {