@ai-matrx/content-ir 0.1.1 → 0.2.0

package/dist/index.cjs

@@ -0,0 +1,4484 @@
+'use strict';
+
+var Ajv = require('ajv');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
+
+// core/ir-types.ts
+var IR_VERSION = 1;
+var IR_ENVELOPE_KEY = "__ir";
+function irPathKey(path) {
+  return path.map((segment) => String(segment)).join(".");
+}
+function irPathsEqual(left, right) {
+  if (left.length !== right.length) return false;
+  for (let i = 0; i < left.length; i++) {
+    if (left[i] !== right[i]) return false;
+  }
+  return true;
+}
+function irPathIsUnderOrEqual(path, prefix) {
+  if (path.length < prefix.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (path[i] !== prefix[i]) return false;
+  }
+  return true;
+}
+function irPathLabel(path) {
+  if (path.length === 0) return "root";
+  const parts = [];
+  for (const segment of path) {
+    if (typeof segment === "number") {
+      parts[parts.length - 1] += `[${segment}]`;
+    } else {
+      parts.push(String(segment));
+    }
+  }
+  return parts.join(".");
+}
+function isEmptyResidue(residue) {
+  return (residue.extra === null || Object.keys(residue.extra).length === 0) && (residue.optionalMissing === null || residue.optionalMissing.length === 0) && (residue.notices === null || residue.notices.length === 0);
+}
+
+// core/kind-schema.types.ts
+var KIND_KEY = "__kind";
+function readObjectKind(value) {
+  const kind = value[KIND_KEY];
+  return typeof kind === "string" ? kind : null;
+}
+function isScalarArrayType(type) {
+  return type === "string[]" || type === "number[]" || type === "boolean[]";
+}
+function scalarArrayItemType(type) {
+  if (type === "number[]") return "number";
+  if (type === "boolean[]") return "boolean";
+  return "string";
+}
+function isJsonAnyField(field) {
+  return field.type === "json" || field.type === "json[]";
+}
+
+// core/discriminator.ts
+var JSON_DISCRIMINATOR = {
+  format: "json",
+  key: KIND_KEY
+};
+function xmlDiscriminator(tag) {
+  return { format: "xml", tag };
+}
+function fenceDiscriminator(language) {
+  return { format: "fence", language };
+}
+
+// core/ir-tree.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeWithoutLoss(prior, incoming) {
+  if (!isRecord(prior)) return { value: incoming, rescued: [] };
+  if (!isRecord(incoming)) {
+    if (incoming !== null && incoming !== void 0) {
+      return { value: incoming, rescued: [] };
+    }
+    return { value: prior, rescued: Object.keys(prior) };
+  }
+  const rescued = Object.keys(prior).filter((key) => !(key in incoming));
+  if (rescued.length === 0) return { value: incoming, rescued };
+  return { value: { ...prior, ...incoming }, rescued };
+}
+var IrTree = class {
+  nodes = /* @__PURE__ */ new Map();
+  rawPaths = /* @__PURE__ */ new Map();
+  // pathKey → reason
+  dirty = /* @__PURE__ */ new Set();
+  /**
+   * KIND PRESERVATION (streaming db/cloud kinds): pathKey → identified kind
+   * for nodes whose kind is KNOWN (kind_identified / pending_schema) but that
+   * have no snapshot node yet because the schema is still cold-fetching.
+   * Without this, the envelope reports `kind: ""` for the whole pending
+   * window and the render seam can only show raw JSON.
+   */
+  identifiedKinds = /* @__PURE__ */ new Map();
+  /** pathKeys currently waiting on a schema cold fetch. */
+  pendingSchemaPaths = /* @__PURE__ */ new Set();
+  /**
+   * Early top-level scalar fields (title, loading_message, …) captured for
+   * identified-but-schema-pending nodes — the loading-component fuel. Scalars
+   * only (no live parser references can escape through here). Superseded the
+   * moment a real snapshot node exists.
+   */
+  earlyFields = /* @__PURE__ */ new Map();
+  /**
+   * pathKey → identified kind preserved through a SCHEMA-AVAILABILITY raw
+   * fallback (parser stamped `kind` on the raw_object event). Structural raws
+   * (missing __kind, duplicate key, validation failure) never land here.
+   */
+  rawKinds = /* @__PURE__ */ new Map();
+  regionStatus = "streaming";
+  errorReason = null;
+  rootRawValue = null;
+  /** Notices for degrades that tried to erase already-published data. */
+  rescueNotices = [];
+  completedKind = "";
+  get status() {
+    return this.regionStatus;
+  }
+  applyEvent(event) {
+    switch (event.type) {
+      case "kind_identified": {
+        this.identifiedKinds.set(irPathKey(event.path), event.kind);
+        this.dirty.add(irPathKey(event.path));
+        return;
+      }
+      case "pending_schema": {
+        const pathKey = irPathKey(event.path);
+        this.identifiedKinds.set(pathKey, event.kind);
+        this.pendingSchemaPaths.add(pathKey);
+        this.dirty.add(pathKey);
+        return;
+      }
+      case "field": {
+        const parentKey = irPathKey(event.path.slice(0, -1));
+        if (this.nodes.has(parentKey)) return;
+        if (!this.identifiedKinds.has(parentKey)) return;
+        const v = event.value;
+        if (v !== null && typeof v === "object") return;
+        const bucket = this.earlyFields.get(parentKey) ?? {};
+        bucket[event.key] = v;
+        this.earlyFields.set(parentKey, bucket);
+        this.dirty.add(parentKey);
+        return;
+      }
+      case "block_snapshot": {
+        const pathKey = irPathKey(event.path);
+        this.pendingSchemaPaths.delete(pathKey);
+        this.earlyFields.delete(pathKey);
+        this.upsertNode(event.path, {
+          kind: event.kind,
+          value: event.value,
+          residue: event.residue,
+          complete: event.complete
+        });
+        return;
+      }
+      case "raw_object": {
+        const pathKey = irPathKey(event.path);
+        this.pendingSchemaPaths.delete(pathKey);
+        this.earlyFields.delete(pathKey);
+        if (event.kind) this.rawKinds.set(pathKey, event.kind);
+        this.markRaw(event.path, event.reason, event.value);
+        return;
+      }
+      case "complete": {
+        this.regionStatus = this.errorReason ? "error" : "complete";
+        this.completedKind = event.kind;
+        if (this.rawPaths.has("") && isRecord(event.value)) {
+          const merged = mergeWithoutLoss(this.rootRawValue, event.value);
+          this.recordRescue("", "complete", merged.rescued);
+          if (isRecord(merged.value)) this.rootRawValue = merged.value;
+        }
+        this.dirty.add("");
+        return;
+      }
+      case "error": {
+        this.errorReason = event.reason;
+        this.regionStatus = "error";
+        this.dirty.add("");
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  getNode(pathKey) {
+    return this.nodes.get(pathKey) ?? null;
+  }
+  listNodes() {
+    return [...this.nodes.values()];
+  }
+  isRawPath(pathKey) {
+    return this.rawPaths.has(pathKey);
+  }
+  /** Dirty pathKeys since the last drain — the flush/notify unit. */
+  drainDirty() {
+    const drained = [...this.dirty];
+    this.dirty.clear();
+    return drained;
+  }
+  hasDirty() {
+    return this.dirty.size > 0;
+  }
+  // -------------------------------------------------------------------------
+  upsertNode(path, payload) {
+    const pathKey = irPathKey(path);
+    if (this.rawPaths.has(pathKey)) return;
+    const stabilized = this.stabilizeValue(
+      payload.value,
+      path,
+      pathKey
+    );
+    const prior = this.nodes.get(pathKey);
+    const node = {
+      kind: payload.kind,
+      kindState: payload.complete ? "resolved" : prior?.kindState ?? "resolved",
+      path,
+      pathKey,
+      value: stabilized,
+      residue: payload.residue,
+      complete: payload.complete,
+      version: (prior?.version ?? 0) + 1
+    };
+    this.nodes.set(pathKey, node);
+    this.dirty.add(pathKey);
+    this.propagateToAncestors(path, node.value);
+  }
+  /**
+   * Substitute kind-node children with their current tree values so sibling
+   * identities are stable; deep-copy everything else so no live parser
+   * reference ever escapes.
+   */
+  stabilizeValue(value, path, applyingPathKey) {
+    if (Array.isArray(value)) {
+      return value.map(
+        (item, index) => this.stabilizeValue(item, [...path, index], applyingPathKey)
+      );
+    }
+    if (isRecord(value)) {
+      const pathKey = irPathKey(path);
+      if (pathKey !== applyingPathKey) {
+        const childNode = this.nodes.get(pathKey);
+        if (childNode) return childNode.value;
+      }
+      const out = {};
+      for (const [key, child] of Object.entries(value)) {
+        out[key] = this.stabilizeValue(child, [...path, key], applyingPathKey);
+      }
+      return out;
+    }
+    return value;
+  }
+  /**
+   * COW spine rebuild: replace the child's slot in each ancestor kind-node's
+   * value, shallow-copying only the containers along the way. Siblings keep
+   * identity; every ancestor gets a new value identity + version bump.
+   */
+  propagateToAncestors(childPath, childValue) {
+    let currentPath = childPath;
+    let currentValue = childValue;
+    while (currentPath.length > 0) {
+      const ancestor = this.findNearestAncestorNode(currentPath);
+      if (!ancestor) return;
+      const relative = currentPath.slice(ancestor.path.length);
+      const rebuilt = this.cloneAlong(ancestor.value, relative, currentValue);
+      if (rebuilt === ancestor.value) return;
+      const updated = {
+        ...ancestor,
+        value: rebuilt,
+        version: ancestor.version + 1
+      };
+      this.nodes.set(ancestor.pathKey, updated);
+      this.dirty.add(ancestor.pathKey);
+      currentPath = ancestor.path;
+      currentValue = updated.value;
+    }
+  }
+  findNearestAncestorNode(path) {
+    for (let len = path.length - 1; len >= 0; len--) {
+      const node = this.nodes.get(irPathKey(path.slice(0, len)));
+      if (node) return node;
+    }
+    return null;
+  }
+  cloneAlong(container, relative, leaf) {
+    if (relative.length === 0) return leaf;
+    const [head, ...rest] = relative;
+    if (Array.isArray(container)) {
+      const index = typeof head === "number" ? head : Number(head);
+      const copy = container.slice();
+      while (copy.length <= index) copy.push(void 0);
+      copy[index] = this.cloneAlong(container[index], rest, leaf);
+      return copy;
+    }
+    if (isRecord(container)) {
+      const key = String(head);
+      return {
+        ...container,
+        [key]: this.cloneAlong(container[key], rest, leaf)
+      };
+    }
+    const built = typeof head === "number" ? this.cloneAlong([], relative, leaf) : this.cloneAlong({}, relative, leaf);
+    return built;
+  }
+  markRaw(path, reason, value) {
+    const pathKey = irPathKey(path);
+    const prior = path.length === 0 ? this.nodes.get("")?.value ?? this.rootRawValue : this.nodes.get(pathKey)?.value;
+    const merged = mergeWithoutLoss(prior, value);
+    this.recordRescue(pathKey, reason, merged.rescued);
+    this.rawPaths.set(pathKey, reason);
+    this.nodes.delete(pathKey);
+    this.dirty.add(pathKey);
+    if (path.length === 0) {
+      if (isRecord(merged.value)) this.rootRawValue = merged.value;
+      return;
+    }
+    this.propagateToAncestors(path, merged.value);
+  }
+  /**
+   * A rescue means a degrade tried to erase data a user could already see —
+   * an upstream defect. It rides the envelope as a notice so it surfaces in the
+   * Error Inspector instead of being silently absorbed (`core/` is a pure
+   * kernel: no console, no capture — the notice IS the alarm).
+   */
+  recordRescue(pathKey, reason, rescued) {
+    if (rescued.length === 0) return;
+    this.rescueNotices.push({
+      code: "degrade_data_rescued",
+      message: `degrade (${reason}) at path "${pathKey || "<root>"}" would have dropped: ${rescued.join(", ")}`
+    });
+  }
+  /**
+   * Assemble the canonical envelope. ONE code path for stream + one-shot.
+   * Callers supply the fingerprint (one-shot hashes the source; live sessions
+   * keep an incremental hasher so no per-flush re-hash happens).
+   */
+  buildEnvelope(fingerprint) {
+    const rootNode = this.nodes.get("");
+    const rootRawReason = this.rawPaths.get("") ?? null;
+    const notices = [];
+    if (this.errorReason) {
+      notices.push({ code: "parse_error", message: this.errorReason });
+    }
+    if (rootRawReason) {
+      notices.push({ code: "raw_fallback", message: rootRawReason });
+    }
+    notices.push(...this.rescueNotices);
+    const baseResidue = rootNode?.residue ?? null;
+    let residue = baseResidue;
+    if (notices.length > 0) {
+      residue = {
+        extra: baseResidue?.extra ?? null,
+        optionalMissing: baseResidue?.optionalMissing ?? null,
+        notices: [...baseResidue?.notices ?? [], ...notices]
+      };
+    }
+    const isRaw = rootRawReason !== null;
+    const identifiedKind = this.identifiedKinds.get("") ?? "";
+    const rootKind = isRaw ? this.rawKinds.get("") ?? "" : rootNode?.kind ?? (this.completedKind || identifiedKind);
+    const root = {
+      role: "structured",
+      kind: rootKind,
+      kindState: isRaw ? "raw" : rootNode ? rootNode.kindState : this.pendingSchemaPaths.has("") ? "pending_schema" : this.regionStatus === "streaming" ? identifiedKind ? "pending_schema" : "pending_kind" : "raw",
+      discriminator: JSON_DISCRIMINATOR,
+      path: [],
+      status: this.regionStatus,
+      value: rootNode?.value ?? this.rootRawValue ?? // Copy: the early-fields bucket keeps mutating as fields arrive; the
+      // envelope must be freezable (Redux dev-mode immutability).
+      (this.earlyFields.has("") ? { ...this.earlyFields.get("") } : {}),
+      residue
+    };
+    const nodeIndex = {};
+    for (const node of this.nodes.values()) {
+      if (node.pathKey === "") continue;
+      nodeIndex[node.pathKey] = {
+        kind: node.kind,
+        kindState: node.kindState,
+        status: node.complete ? "complete" : "streaming",
+        ...node.residue ? { residue: node.residue } : {}
+      };
+    }
+    for (const [pathKey] of this.rawPaths) {
+      if (pathKey === "") continue;
+      nodeIndex[pathKey] = { kind: "", kindState: "raw", status: "complete" };
+    }
+    return {
+      v: IR_VERSION,
+      engine: "fe-kind-parser",
+      fingerprint,
+      root,
+      ...Object.keys(nodeIndex).length > 0 ? { nodeIndex } : {}
+    };
+  }
+};
+
+// core/json-tokenizer.ts
+var JsonStreamTokenizer = class {
+  constructor(onToken) {
+    this.onToken = onToken;
+  }
+  onToken;
+  mode = "normal";
+  pos = 0;
+  stringBuffer = "";
+  primitiveBuffer = "";
+  unicodeBuffer = "";
+  tokenStart = 0;
+  get position() {
+    return this.pos;
+  }
+  push(chunk) {
+    for (let i = 0; i < chunk.length; i++) {
+      const ch = chunk[i];
+      const at = this.pos;
+      this.pos += 1;
+      if (ch === void 0) continue;
+      if (this.mode === "primitive") {
+        if (this.isDelimiter(ch)) {
+          this.emitPrimitive();
+          this.handleNormalChar(ch, at);
+        } else {
+          this.primitiveBuffer += ch;
+        }
+        continue;
+      }
+      if (this.mode === "string") {
+        if (ch === '"') {
+          this.onToken({
+            type: "string",
+            value: this.stringBuffer,
+            at: this.tokenStart
+          });
+          this.stringBuffer = "";
+          this.mode = "normal";
+          continue;
+        }
+        if (ch === "\\") {
+          this.mode = "escape";
+          continue;
+        }
+        if (ch === "\n" || ch === "\r") {
+          throw new Error(`Invalid unescaped newline in JSON string at ${at}`);
+        }
+        this.stringBuffer += ch;
+        continue;
+      }
+      if (this.mode === "escape") {
+        if (ch === "u") {
+          this.unicodeBuffer = "";
+          this.mode = "unicode";
+          continue;
+        }
+        const escaped = {
+          '"': '"',
+          "\\": "\\",
+          "/": "/",
+          b: "\b",
+          f: "\f",
+          n: "\n",
+          r: "\r",
+          t: "	"
+        };
+        if (!(ch in escaped)) {
+          throw new Error(`Invalid JSON escape sequence at ${at}`);
+        }
+        this.stringBuffer += escaped[ch];
+        this.mode = "string";
+        continue;
+      }
+      if (this.mode === "unicode") {
+        if (!/[0-9a-fA-F]/.test(ch)) {
+          throw new Error(`Invalid unicode escape at ${at}`);
+        }
+        this.unicodeBuffer += ch;
+        if (this.unicodeBuffer.length === 4) {
+          this.stringBuffer += String.fromCharCode(
+            parseInt(this.unicodeBuffer, 16)
+          );
+          this.unicodeBuffer = "";
+          this.mode = "string";
+        }
+        continue;
+      }
+      this.handleNormalChar(ch, at);
+    }
+  }
+  end() {
+    if (this.mode === "primitive") {
+      this.emitPrimitive();
+      return;
+    }
+    if (this.mode !== "normal") {
+      throw new Error(
+        `Stream ended while parsing JSON ${this.mode} at ${this.pos}`
+      );
+    }
+  }
+  handleNormalChar(ch, at) {
+    if (/\s/.test(ch)) return;
+    if (ch === "{" || ch === "}" || ch === "[" || ch === "]" || ch === ":" || ch === ",") {
+      this.onToken({ type: "punct", value: ch, at });
+      return;
+    }
+    if (ch === '"') {
+      this.mode = "string";
+      this.stringBuffer = "";
+      this.tokenStart = at;
+      return;
+    }
+    if (/[-0-9tfn]/.test(ch)) {
+      this.mode = "primitive";
+      this.primitiveBuffer = ch;
+      this.tokenStart = at;
+      return;
+    }
+    throw new Error(`Unexpected character "${ch}" at ${at}`);
+  }
+  emitPrimitive() {
+    const raw = this.primitiveBuffer;
+    const at = this.tokenStart;
+    this.primitiveBuffer = "";
+    this.mode = "normal";
+    let value;
+    try {
+      value = JSON.parse(raw);
+    } catch {
+      throw new Error(`Invalid JSON primitive "${raw}" at ${at}`);
+    }
+    if (typeof value === "number") {
+      this.onToken({ type: "number", value, at });
+      return;
+    }
+    if (typeof value === "boolean") {
+      this.onToken({ type: "boolean", value, at });
+      return;
+    }
+    if (value === null) {
+      this.onToken({ type: "null", value, at });
+      return;
+    }
+    throw new Error(`Unsupported JSON primitive "${raw}" at ${at}`);
+  }
+  isDelimiter(ch) {
+    return /\s/.test(ch) || ch === "{" || ch === "}" || ch === "[" || ch === "]" || ch === ":" || ch === ",";
+  }
+};
+
+// core/kind-snapshot.ts
+function emptyValueForFieldSchema(field) {
+  if (field.nullable) return null;
+  switch (field.type) {
+    case "string":
+      return "";
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "json":
+      return null;
+    case "string[]":
+    case "number[]":
+    case "boolean[]":
+    case "json[]":
+    case "array":
+      return [];
+    case "object":
+    case "inline_object":
+    case "record":
+      return {};
+    case "enum":
+      return "";
+    case "union":
+      if (field.scalars.includes("string")) return "";
+      if (field.scalars.includes("number")) return 0;
+      if (field.scalars.includes("boolean")) return false;
+      return {};
+    default:
+      return null;
+  }
+}
+function buildCompliantKindSnapshot(schema, partial) {
+  const value = {
+    [KIND_KEY]: schema.kind
+  };
+  const optionalMissing = [];
+  for (const [fieldName, fieldSchema] of Object.entries(schema.fields)) {
+    if (fieldName in partial && partial[fieldName] !== void 0) {
+      value[fieldName] = partial[fieldName];
+    } else if (fieldSchema.required) {
+      value[fieldName] = emptyValueForFieldSchema(fieldSchema);
+    } else {
+      optionalMissing.push(fieldName);
+    }
+  }
+  let extra = null;
+  for (const [fieldName, fieldValue] of Object.entries(partial)) {
+    if (fieldName === KIND_KEY) continue;
+    if (fieldName in schema.fields) continue;
+    if (extra === null) extra = {};
+    extra[fieldName] = fieldValue;
+  }
+  const residue = {
+    extra,
+    optionalMissing: optionalMissing.length > 0 ? optionalMissing : null,
+    notices: null
+  };
+  return { value, residue: isEmptyResidue(residue) ? null : residue };
+}
+function mergeResidueIntoValue(value, residue) {
+  if (!residue?.extra) return value;
+  return { ...value, ...residue.extra };
+}
+
+// core/kind-parser.ts
+var jsonRootKeyLookup = null;
+function setJsonRootKeyLookup(lookup) {
+  jsonRootKeyLookup = lookup;
+}
+function isSchemaResolver(source) {
+  return typeof source.get === "function";
+}
+function safeCopy(value) {
+  try {
+    return structuredClone(value);
+  } catch {
+    return value;
+  }
+}
+var KindStreamParser = class {
+  constructor(options) {
+    this.options = options;
+    this.resolver = isSchemaResolver(options.schemas) ? options.schemas : {
+      get: (kind) => options.schemas[kind]
+    };
+    this.tokenizer = new JsonStreamTokenizer(
+      (token) => this.handleToken(token)
+    );
+  }
+  options;
+  resolver;
+  stack = [];
+  objectKinds = /* @__PURE__ */ new Map();
+  inlineSchemas = /* @__PURE__ */ new Map();
+  recordSchemas = /* @__PURE__ */ new Map();
+  rawObjectPaths = /* @__PURE__ */ new Set();
+  /**
+   * Subtrees whose value domain is "any JSON" by schema (`json` / `json[]`
+   * fields, `record` with `values:"json"` members). OPAQUE by contract: no
+   * kind identification, no pending_kind, no raw_object degradation — unknown
+   * structure here is the declared shape, not a failure. Propagates to every
+   * descendant compound.
+   */
+  opaquePaths = /* @__PURE__ */ new Set();
+  deferredFields = /* @__PURE__ */ new Map();
+  awaitingKindPaths = /* @__PURE__ */ new Set();
+  /** Paths whose kind came from parent-schema prediction, unconfirmed so far. */
+  speculativeKinds = /* @__PURE__ */ new Set();
+  /**
+   * Kind named by the root object's FIRST key through the `json_root_key`
+   * surface registry — a candidate, adopted only at root finalize.
+   */
+  rootSurfaceKind = null;
+  /** kind → paths (by key) waiting for the resolver's cold fetch. */
+  pendingSchemaPaths = /* @__PURE__ */ new Map();
+  /** Pending-schema paths whose object already closed. */
+  closedPendingPaths = /* @__PURE__ */ new Set();
+  /** Schemas delivered via notifySchemaArrived (overlay over the resolver). */
+  arrivedSchemas = /* @__PURE__ */ new Map();
+  tokenizer;
+  root;
+  rootKind = "";
+  rootDone = false;
+  failed = false;
+  push(chunk) {
+    if (this.failed || this.rootDone) return;
+    try {
+      this.tokenizer.push(chunk);
+    } catch (error) {
+      this.fail(
+        error instanceof Error ? error.message : String(error),
+        this.tokenizer.position
+      );
+    }
+  }
+  end() {
+    if (this.failed) return;
+    try {
+      this.tokenizer.end();
+    } catch (error) {
+      this.fail(
+        error instanceof Error ? error.message : String(error),
+        this.tokenizer.position
+      );
+      return;
+    }
+    this.resolvePendingSchemasAsRaw();
+    if (!this.rootDone) {
+      this.fail(
+        "Stream ended before the root JSON object was complete.",
+        this.tokenizer.position
+      );
+    }
+  }
+  resolvePendingSchemasAsRaw() {
+    const at = this.tokenizer.position;
+    for (const [kind, paths] of [...this.pendingSchemaPaths]) {
+      this.pendingSchemaPaths.delete(kind);
+      for (const [pathKey, path] of paths) {
+        this.closedPendingPaths.delete(pathKey);
+        if (this.rawObjectPaths.has(pathKey)) continue;
+        const value = this.getLiveObjectValue(path) ?? this.getFinalizedObjectValue(path) ?? {};
+        this.emitRawObject(
+          path,
+          safeCopy(value),
+          `No block schema registered for "${kind}".`,
+          at,
+          kind
+        );
+      }
+    }
+  }
+  /** True once the root value has closed — the region is fully consumed. */
+  get isComplete() {
+    return this.rootDone;
+  }
+  get hasFailed() {
+    return this.failed;
+  }
+  /**
+   * Upgrade-in-place: the registry's cold fetch answered. Pending nodes for
+   * this kind validate and complete (closed nodes retroactively); a null
+   * schema (fetch miss) drops them to raw. Safe to call after end().
+   */
+  notifySchemaArrived(kind, schema) {
+    const waiting = this.pendingSchemaPaths.get(kind);
+    if (!waiting) return;
+    this.pendingSchemaPaths.delete(kind);
+    if (schema) {
+      this.arrivedSchemas.set(kind, schema);
+    }
+    const at = this.tokenizer.position;
+    for (const [pathKey, path] of waiting) {
+      if (this.rawObjectPaths.has(pathKey)) continue;
+      const value = this.getLiveObjectValue(path) ?? this.getFinalizedObjectValue(path);
+      if (!schema) {
+        this.emitRawObject(
+          path,
+          safeCopy(value ?? {}),
+          `No block schema registered for "${kind}".`,
+          at,
+          kind
+        );
+        this.closedPendingPaths.delete(pathKey);
+        continue;
+      }
+      if (this.closedPendingPaths.has(pathKey)) {
+        this.closedPendingPaths.delete(pathKey);
+        if (value) {
+          this.finalizeTypedObject(path, value, at);
+        }
+      } else {
+        this.emitBlockSnapshotForObject(path, at);
+      }
+    }
+  }
+  handleToken(token) {
+    if (this.failed) return;
+    if (this.rootDone) {
+      this.fail("Unexpected token after complete JSON object.", token.at);
+      return;
+    }
+    if (token.type === "punct") {
+      this.handlePunctuation(token);
+      return;
+    }
+    if (token.type === "string") {
+      this.handleString(token);
+      return;
+    }
+    this.beginScalar(token.value, token.at);
+  }
+  handleString(token) {
+    const frame = this.currentFrame();
+    if (frame?.kind === "object" && (frame.expecting === "keyOrEnd" || frame.expecting === "key")) {
+      this.acceptObjectKey(frame, token.value, token.at);
+      return;
+    }
+    this.beginScalar(token.value, token.at);
+  }
+  handlePunctuation(token) {
+    switch (token.value) {
+      case "{":
+        this.beginCompound("object", token.at);
+        return;
+      case "[":
+        this.beginCompound("array", token.at);
+        return;
+      case "}":
+        this.closeCompound("object", token.at);
+        return;
+      case "]":
+        this.closeCompound("array", token.at);
+        return;
+      case ":":
+        this.acceptColon(token.at);
+        return;
+      case ",":
+        this.acceptComma(token.at);
+        return;
+    }
+  }
+  beginCompound(kind, at) {
+    const value = kind === "object" ? {} : [];
+    const container = this.currentFrame();
+    const path = this.placeValue(value, kind, at, false);
+    if (!path || this.failed) return;
+    const opaque = container !== void 0 && this.opaquePaths.has(this.pathKey(container.path)) || this.isJsonAnyPlacement(path);
+    if (opaque) this.opaquePaths.add(this.pathKey(path));
+    if (kind === "object") {
+      this.emit({ type: "object_start", path, at });
+      if (opaque) {
+        this.stack.push({
+          kind: "object",
+          path,
+          value,
+          expecting: "keyOrEnd",
+          keyCount: 0
+        });
+        return;
+      }
+      this.registerObjectContext(path);
+      const pathKey = this.pathKey(path);
+      this.stack.push({
+        kind: "object",
+        path,
+        value,
+        expecting: "keyOrEnd",
+        keyCount: 0
+      });
+      if (this.inlineSchemas.has(pathKey) || this.recordSchemas.has(pathKey)) {
+        return;
+      }
+      const speculated = this.resolveSpeculativeKind(path);
+      if (speculated) {
+        this.objectKinds.set(pathKey, speculated);
+        this.speculativeKinds.add(pathKey);
+        if (path.length === 0) {
+          this.rootKind = speculated;
+        }
+        this.emit({
+          type: "kind_identified",
+          kind: speculated,
+          path,
+          speculative: true,
+          at
+        });
+        this.emitBlockSnapshotForObject(path, at);
+        return;
+      }
+      this.awaitingKindPaths.add(pathKey);
+      this.emit({ type: "pending_kind", path, at });
+      return;
+    }
+    const parentField = this.parentFieldName(path);
+    if (parentField) {
+      this.emit({ type: "array_start", path, field: parentField, at });
+    }
+    this.stack.push({
+      kind: "array",
+      path,
+      value,
+      expecting: "valueOrEnd",
+      nextIndex: 0
+    });
+  }
+  /**
+   * THE JSON-ROOT-KEY SURFACE — `content_ir.kind_surface` rows of type
+   * `json_root_key`, live at last (they were inert phantom rows until
+   * 2026-08-20).
+   *
+   * A legacy payload such as `{"quiz_title": ...}` carries no `__kind`, but
+   * the ONE surface registry knows exactly which kind that root key names —
+   * the same lookup the SERVER performs before adapting the payload
+   * (`aidream .../processing/blocks/envelope.py`). Consulting it HERE, in the
+   * shared parser core, is what makes one place decide it: both hosts — the
+   * one-shot `normalizeJsonRegion` (DB reload / reconcile) and the live
+   * `openParseSession` (streaming) — build their parser through
+   * `createKindStreamParser`, so neither passes an option and neither can
+   * drift from the other.
+   *
+   * Recorded at the first root key; ADOPTED only when the root object closes
+   * (`completeTypedObject`). That is the surface registry's complete-only
+   * convergence law, and every json_root_key row is `streaming:false` — these
+   * legacy shapes are recognised by their whole payload, so speculating
+   * mid-stream would flash a kind component over an object that may never
+   * satisfy the schema. An explicit `expectedRootKind` (an agent's declared
+   * output schema) is stronger context and always wins; an actual `__kind`
+   * still wins over both.
+   */
+  noteRootSurfaceKind(key) {
+    if (key === KIND_KEY) return;
+    if (this.options.expectedRootKind) return;
+    if (this.rootKind || this.objectKinds.has(this.pathKey([]))) return;
+    const kind = this.resolver.kindForJsonRootKey?.(key) ?? jsonRootKeyLookup?.(key);
+    if (!kind) return;
+    this.rootSurfaceKind = kind;
+    if (!this.lookupSchema(kind)) {
+      this.resolver.request?.(kind);
+    }
+  }
+  /**
+   * Prediction from the parent schema: object field → declared kind; array
+   * item → sole itemKind; root → expectedRootKind. Only when the schema is
+   * actually resolvable (a prediction we can't validate against is not a
+   * commitment worth making).
+   */
+  resolveSpeculativeKind(path) {
+    if (path.length === 0) {
+      const expected = this.options.expectedRootKind;
+      return expected && this.lookupObjectSchema(expected) ? expected : null;
+    }
+    const last = path[path.length - 1];
+    if (typeof last === "string") {
+      const fieldSchema2 = this.resolveParentFieldSchema(path);
+      if (fieldSchema2?.type === "object" && this.lookupObjectSchema(fieldSchema2.kind)) {
+        return fieldSchema2.kind;
+      }
+      return null;
+    }
+    const fieldName = this.parentFieldName(path);
+    if (!fieldName) return null;
+    const ownerPath = path.slice(0, -2);
+    const ownerKind = this.getObjectKindForPath(ownerPath);
+    if (!ownerKind) return null;
+    const fieldSchema = this.lookupSchema(ownerKind)?.fields[fieldName];
+    const soleItemKind = fieldSchema?.type === "array" && fieldSchema.itemKinds.length === 1 ? fieldSchema.itemKinds[0] : void 0;
+    if (soleItemKind !== void 0 && this.lookupObjectSchema(soleItemKind)) {
+      return soleItemKind;
+    }
+    return null;
+  }
+  /**
+   * A schema usable for OBJECT speculation/snapshots — root-form kinds
+   * (non-object data-only shapes) are never a valid object commitment.
+   */
+  lookupObjectSchema(kind) {
+    const schema = this.lookupSchema(kind);
+    return schema && !schema.root ? schema : void 0;
+  }
+  beginScalar(value, at) {
+    this.placeValue(value, "scalar", at, true);
+  }
+  placeValue(value, valueKind, at, finalizedImmediately) {
+    if (this.root === void 0) {
+      if (valueKind !== "object") {
+        this.fail("Root value must be a JSON object.", at);
+        return null;
+      }
+      this.root = value;
+      return [];
+    }
+    const parent = this.currentFrame();
+    if (!parent) {
+      this.fail("Unexpected value after root object.", at);
+      return null;
+    }
+    let path;
+    let fieldKey;
+    if (parent.kind === "object") {
+      if (parent.expecting !== "value") {
+        this.fail(
+          `Unexpected value inside object. Expected ${parent.expecting}.`,
+          at
+        );
+        return null;
+      }
+      if (parent.currentKey === void 0) {
+        this.fail("Internal parser error: missing object key.", at);
+        return null;
+      }
+      fieldKey = parent.currentKey;
+      path = [...parent.path, fieldKey];
+      const placementError = this.validateFieldPlacement(
+        parent,
+        fieldKey,
+        valueKind,
+        value
+      );
+      if (placementError) {
+        this.markNodeRaw(parent.path, parent.value, placementError, at);
+      }
+      parent.value[fieldKey] = value;
+      parent.currentKey = void 0;
+      parent.expecting = "commaOrEnd";
+    } else {
+      if (parent.expecting !== "valueOrEnd" && parent.expecting !== "value") {
+        this.fail(
+          `Unexpected value inside array. Expected ${parent.expecting}.`,
+          at
+        );
+        return null;
+      }
+      const index = parent.nextIndex;
+      path = [...parent.path, index];
+      fieldKey = this.parentFieldName(path);
+      parent.value.push(value);
+      parent.nextIndex += 1;
+      parent.expecting = "commaOrEnd";
+    }
+    if (finalizedImmediately) {
+      this.onValueFinalized(path, value, at);
+    }
+    return path;
+  }
+  acceptObjectKey(frame, key, at) {
+    if (frame.expecting !== "keyOrEnd" && frame.expecting !== "key") {
+      this.fail(`Unexpected object key "${key}".`, at);
+      return;
+    }
+    if (Object.prototype.hasOwnProperty.call(frame.value, key)) {
+      this.markNodeRaw(
+        frame.path,
+        frame.value,
+        `Duplicate key "${key}".`,
+        at
+      );
+    }
+    if (frame.path.length === 0 && frame.keyCount === 0) {
+      this.noteRootSurfaceKind(key);
+    }
+    frame.currentKey = key;
+    frame.keyCount += 1;
+    frame.expecting = "colon";
+  }
+  acceptColon(at) {
+    const frame = this.currentFrame();
+    if (!frame || frame.kind !== "object" || frame.expecting !== "colon") {
+      this.fail("Unexpected colon.", at);
+      return;
+    }
+    frame.expecting = "value";
+  }
+  acceptComma(at) {
+    const frame = this.currentFrame();
+    if (!frame || frame.expecting !== "commaOrEnd") {
+      this.fail("Unexpected comma.", at);
+      return;
+    }
+    if (frame.kind === "object") {
+      frame.expecting = "key";
+    } else {
+      frame.expecting = "value";
+    }
+  }
+  closeCompound(kind, at) {
+    const frame = this.currentFrame();
+    if (!frame || frame.kind !== kind) {
+      this.fail(
+        `Unexpected closing ${kind === "object" ? "brace" : "bracket"}.`,
+        at
+      );
+      return;
+    }
+    if (frame.kind === "object") {
+      if (frame.expecting !== "keyOrEnd" && frame.expecting !== "commaOrEnd") {
+        this.fail(`Object closed too early. Expected ${frame.expecting}.`, at);
+        return;
+      }
+    } else if (frame.expecting !== "valueOrEnd" && frame.expecting !== "commaOrEnd") {
+      this.fail(`Array closed too early. Expected ${frame.expecting}.`, at);
+      return;
+    }
+    this.stack.pop();
+    if (this.stack.length === 0) {
+      this.rootDone = true;
+    }
+    this.onValueFinalized(frame.path, frame.value, at);
+  }
+  /**
+   * True when a value placed at `path` sits directly under a json-any
+   * placement: a `json`/`json[]` FIELD, or a member of a `record` whose
+   * values are `"json"`. (Deeper descendants inherit via `opaquePaths`.)
+   */
+  isJsonAnyPlacement(path) {
+    const fieldSchema = this.resolveParentFieldSchema(path);
+    if (fieldSchema && isJsonAnyField(fieldSchema)) return true;
+    const last = path[path.length - 1];
+    if (typeof last === "string") {
+      const parentKey = this.pathKey(path.slice(0, -1));
+      if (this.recordSchemas.get(parentKey) === "json") return true;
+    }
+    return false;
+  }
+  onValueFinalized(path, value, at) {
+    if (this.failed) return;
+    const pathKey = this.pathKey(path);
+    const parentIsOpaque = path.length > 0 && this.opaquePaths.has(this.pathKey(path.slice(0, -1)));
+    if (this.opaquePaths.has(pathKey)) {
+      if (!parentIsOpaque) this.emitFieldIfReady(path, value, at);
+      return;
+    }
+    if (parentIsOpaque) return;
+    if (this.isKindFieldPath(path)) {
+      if (typeof value !== "string") {
+        return;
+      }
+      this.onKindDiscriminatorArrived(path.slice(0, -1), value, at);
+      return;
+    }
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      const objectValue = value;
+      const inlineFields = this.inlineSchemas.get(pathKey);
+      if (inlineFields) {
+        const inlineError = this.validateObjectAgainstFields(
+          objectValue,
+          inlineFields
+        );
+        if (inlineError.error) {
+          this.emitRawObject(path, objectValue, inlineError.error, at);
+          return;
+        }
+        this.inlineSchemas.delete(pathKey);
+        this.emitSchemaNotices(path, "inline_object", inlineError, at);
+        this.emit({
+          type: "object_complete",
+          kind: "inline_object",
+          path,
+          value: objectValue,
+          at
+        });
+      } else {
+        const recordValueType = this.recordSchemas.get(pathKey);
+        if (recordValueType) {
+          const recordError = this.validateRecordObject(
+            objectValue,
+            recordValueType
+          );
+          if (recordError) {
+            this.emitRawObject(path, objectValue, recordError, at);
+            return;
+          }
+          this.recordSchemas.delete(pathKey);
+          this.emit({
+            type: "object_complete",
+            kind: "record",
+            path,
+            value: objectValue,
+            at
+          });
+        } else {
+          this.completeTypedObject(path, objectValue, at);
+        }
+      }
+    }
+    this.emitFieldIfReady(path, value, at);
+    if (path.length === 0) {
+      this.completeRoot(value, at);
+    }
+  }
+  /** __kind arrived for an object — confirm speculation, identify, or backtrack. */
+  onKindDiscriminatorArrived(objectPath, kind, at) {
+    const objectPathKey = this.pathKey(objectPath);
+    if (this.rawObjectPaths.has(objectPathKey)) return;
+    const prior = this.objectKinds.get(objectPathKey);
+    const wasSpeculative = this.speculativeKinds.has(objectPathKey);
+    if (prior !== void 0 && wasSpeculative) {
+      this.speculativeKinds.delete(objectPathKey);
+      if (prior === kind) {
+        this.emitBlockSnapshotForObject(objectPath, at);
+        return;
+      }
+      if (this.lookupSchema(kind) && this.validateArrayItemKind(objectPath, kind) === null && this.speculativeRetagAllowed(objectPath, kind)) {
+        this.objectKinds.set(objectPathKey, kind);
+        if (objectPath.length === 0) {
+          this.rootKind = kind;
+        }
+        this.emit({ type: "kind_identified", kind, path: objectPath, at });
+        this.emitBlockSnapshotForObject(objectPath, at);
+        return;
+      }
+      const live = this.getLiveObjectValue(objectPath);
+      this.objectKinds.delete(objectPathKey);
+      if (objectPath.length === 0) {
+        this.rootKind = "";
+      }
+      this.emitRawObject(
+        objectPath,
+        safeCopy(live ?? {}),
+        `Speculated kind "${prior}" contradicted by ${KIND_KEY} "${kind}".`,
+        at
+      );
+      return;
+    }
+    this.objectKinds.set(objectPathKey, kind);
+    this.emit({
+      type: "kind_identified",
+      kind,
+      path: objectPath,
+      at
+    });
+    this.clearKindWait(objectPath, "identified", at, kind);
+    if (objectPath.length === 0) {
+      this.rootKind = kind;
+    }
+    if (!this.lookupSchema(kind) && this.resolver.request) {
+      this.addPendingSchemaPath(kind, objectPath);
+      this.emit({ type: "pending_schema", kind, path: objectPath, at });
+      this.resolver.request(kind);
+      return;
+    }
+    this.flushDeferredFields(objectPath, kind, at);
+    this.emitBlockSnapshotForObject(objectPath, at);
+  }
+  /** A contradicted speculation may re-tag only where the new kind is legal. */
+  speculativeRetagAllowed(path, kind) {
+    if (path.length === 0) {
+      return true;
+    }
+    const last = path[path.length - 1];
+    if (typeof last === "number") {
+      const fieldName = this.parentFieldName(path);
+      const ownerKind = this.getObjectKindForPath(path.slice(0, -2));
+      if (!fieldName || !ownerKind) return false;
+      const fieldSchema = this.lookupSchema(ownerKind)?.fields[fieldName];
+      return fieldSchema?.type === "array" && fieldSchema.itemKinds.includes(kind);
+    }
+    return false;
+  }
+  addPendingSchemaPath(kind, path) {
+    const pathKey = this.pathKey(path);
+    const existing = this.pendingSchemaPaths.get(kind) ?? /* @__PURE__ */ new Map();
+    existing.set(pathKey, path);
+    this.pendingSchemaPaths.set(kind, existing);
+  }
+  completeTypedObject(path, objectValue, at) {
+    const pathKey = this.pathKey(path);
+    if (this.rawObjectPaths.has(pathKey)) return;
+    const declaredKind = readObjectKind(objectValue);
+    const committedKind = this.objectKinds.get(pathKey);
+    if (committedKind && this.pendingSchemaPaths.get(committedKind)?.has(pathKey)) {
+      this.closedPendingPaths.add(pathKey);
+      return;
+    }
+    if (!declaredKind && committedKind && this.speculativeKinds.has(pathKey)) {
+      this.speculativeKinds.delete(pathKey);
+      this.finalizeSpeculatedObject(path, objectValue, committedKind, at);
+      return;
+    }
+    if (path.length === 0 && !declaredKind && !committedKind && this.rootSurfaceKind) {
+      const surfaceKind = this.rootSurfaceKind;
+      this.rootSurfaceKind = null;
+      this.objectKinds.set(pathKey, surfaceKind);
+      this.rootKind = surfaceKind;
+      this.emit({
+        type: "kind_identified",
+        kind: surfaceKind,
+        path,
+        speculative: true,
+        at
+      });
+      this.clearKindWait(path, "identified", at, surfaceKind);
+      this.finalizeSpeculatedObject(path, objectValue, surfaceKind, at);
+      return;
+    }
+    if (!declaredKind) {
+      this.emitRawObject(
+        path,
+        objectValue,
+        `Object is missing "${KIND_KEY}".`,
+        at
+      );
+      return;
+    }
+    this.speculativeKinds.delete(pathKey);
+    this.finalizeTypedObject(path, objectValue, at);
+  }
+  /** Validate + complete an object whose value carries __kind. */
+  finalizeTypedObject(path, objectValue, at) {
+    const pathKey = this.pathKey(path);
+    const kind = readObjectKind(objectValue);
+    if (!kind) {
+      this.emitRawObject(
+        path,
+        objectValue,
+        `Object is missing "${KIND_KEY}".`,
+        at
+      );
+      return;
+    }
+    const schema = this.lookupSchema(kind);
+    if (!schema) {
+      this.emitRawObject(
+        path,
+        objectValue,
+        `No block schema registered for "${kind}".`,
+        at,
+        kind
+      );
+      return;
+    }
+    const arrayItemError = this.validateArrayItemKind(path, kind);
+    if (arrayItemError) {
+      this.emitRawObject(path, objectValue, arrayItemError, at);
+      return;
+    }
+    const outcome = this.validateObjectAgainstSchema(objectValue, schema);
+    if (outcome.error) {
+      this.emitRawObject(path, objectValue, outcome.error, at);
+      return;
+    }
+    this.objectKinds.set(pathKey, kind);
+    this.emitSchemaNotices(path, kind, outcome, at);
+    this.emitBlockSnapshotForObject(path, at, true);
+    this.emit({
+      type: "object_complete",
+      kind,
+      path,
+      value: objectValue,
+      at
+    });
+  }
+  /** Validate + complete an object typed purely by parent prediction. */
+  finalizeSpeculatedObject(path, objectValue, kind, at) {
+    const schema = this.lookupSchema(kind);
+    if (!schema) {
+      this.emitRawObject(
+        path,
+        objectValue,
+        `No block schema registered for "${kind}".`,
+        at,
+        kind
+      );
+      return;
+    }
+    const outcome = this.validateObjectAgainstSchema(
+      { ...objectValue, [KIND_KEY]: kind },
+      schema
+    );
+    if (outcome.error) {
+      this.emitRawObject(path, objectValue, outcome.error, at);
+      return;
+    }
+    this.emitSchemaNotices(path, kind, outcome, at);
+    this.emitBlockSnapshotForObject(path, at, true);
+    this.emit({
+      type: "object_complete",
+      kind,
+      path,
+      value: objectValue,
+      at
+    });
+  }
+  validateArrayItemKind(path, kind) {
+    const last = path[path.length - 1];
+    if (typeof last !== "number") return null;
+    const fieldName = this.parentFieldName(path);
+    if (!fieldName) return null;
+    const ownerObjectPath = path.slice(0, -2);
+    const parentKind = this.getObjectKindForPath(ownerObjectPath);
+    if (!parentKind) return null;
+    const fieldSchema = this.lookupSchema(parentKind)?.fields[fieldName];
+    if (!fieldSchema || fieldSchema.type !== "array") return null;
+    if (!fieldSchema.itemKinds.includes(kind)) {
+      return `Kind "${kind}" is not allowed in "${fieldName}" on "${parentKind}" (expected one of: ${fieldSchema.itemKinds.join(", ")}).`;
+    }
+    return null;
+  }
+  completeRoot(rootObject, at) {
+    const pathKey = this.pathKey([]);
+    if (this.rawObjectPaths.has(pathKey)) {
+      this.emit({
+        type: "complete",
+        kind: readObjectKind(rootObject) ?? "",
+        value: rootObject,
+        at
+      });
+      return;
+    }
+    const committedKind = this.objectKinds.get(pathKey);
+    if (committedKind && this.pendingSchemaPaths.get(committedKind)?.has(pathKey)) {
+      this.emit({
+        type: "complete",
+        kind: committedKind,
+        value: rootObject,
+        at
+      });
+      return;
+    }
+    this.emit({
+      type: "complete",
+      kind: this.objectKinds.get(pathKey) ?? readObjectKind(rootObject) ?? "",
+      value: rootObject,
+      at
+    });
+  }
+  /** Mark a node raw (node-scoped failure) without killing the stream. */
+  markNodeRaw(path, liveValue, reason, at) {
+    const pathKey = this.pathKey(path);
+    if (this.rawObjectPaths.has(pathKey)) return;
+    this.speculativeKinds.delete(pathKey);
+    this.emitRawObject(path, safeCopy(liveValue), reason, at);
+  }
+  emitRawObject(path, value, reason, at, identifiedKind) {
+    const pathKey = this.pathKey(path);
+    if (this.rawObjectPaths.has(pathKey)) return;
+    this.rawObjectPaths.add(pathKey);
+    this.clearKindWait(path, "raw_fallback", at, void 0, reason);
+    this.emit({
+      type: "raw_object",
+      path,
+      value,
+      reason,
+      ...identifiedKind !== void 0 && { kind: identifiedKind },
+      at
+    });
+  }
+  clearKindWait(path, outcome, at, kind, reason) {
+    const pathKey = this.pathKey(path);
+    if (!this.awaitingKindPaths.has(pathKey)) return;
+    this.awaitingKindPaths.delete(pathKey);
+    this.emit({
+      type: "kind_wait_end",
+      path,
+      outcome,
+      ...kind !== void 0 && { kind },
+      ...reason !== void 0 && { reason },
+      at
+    });
+  }
+  emitFieldIfReady(path, value, at) {
+    const fieldKey = this.fieldKeyFromPath(path);
+    if (!fieldKey || fieldKey === KIND_KEY) return;
+    const parentPath = path.slice(0, -1);
+    const objectKind = this.getDirectObjectKind(parentPath);
+    if (!objectKind) {
+      const parentPathKey = this.pathKey(parentPath);
+      const deferred = this.deferredFields.get(parentPathKey) ?? [];
+      deferred.push({ key: fieldKey, value, at });
+      this.deferredFields.set(parentPathKey, deferred);
+      return;
+    }
+    const schemaResolved = this.lookupSchema(objectKind) !== void 0;
+    if (schemaResolved && !this.isAllowedSchemaField(parentPath, fieldKey, objectKind)) {
+      return;
+    }
+    this.emit({
+      type: "field",
+      kind: objectKind,
+      path,
+      key: fieldKey,
+      value,
+      at
+    });
+    this.emitBlockSnapshotForObject(parentPath, at);
+  }
+  flushDeferredFields(objectPath, kind, at) {
+    const pathKey = this.pathKey(objectPath);
+    const deferred = this.deferredFields.get(pathKey);
+    if (!deferred) return;
+    for (const entry of deferred) {
+      if (entry.key === KIND_KEY) continue;
+      if (!this.isAllowedSchemaField(objectPath, entry.key, kind)) continue;
+      this.emit({
+        type: "field",
+        kind,
+        path: [...objectPath, entry.key],
+        key: entry.key,
+        value: entry.value,
+        at: entry.at
+      });
+    }
+    this.deferredFields.delete(pathKey);
+    this.emitBlockSnapshotForObject(objectPath, at);
+  }
+  getLiveObjectValue(path) {
+    const pathKey = this.pathKey(path);
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      const frame = this.stack[i];
+      if (!frame) continue;
+      if (frame.kind === "object" && this.pathKey(frame.path) === pathKey) {
+        return frame.value;
+      }
+    }
+    return null;
+  }
+  emitBlockSnapshotForObject(objectPath, at, complete = false) {
+    const pathKey = this.pathKey(objectPath);
+    if (this.rawObjectPaths.has(pathKey)) return;
+    const kind = this.getDirectObjectKind(objectPath);
+    if (!kind) return;
+    const schema = this.lookupObjectSchema(kind);
+    if (!schema) return;
+    const partial = complete ? this.getFinalizedObjectValue(objectPath) : this.getLiveObjectValue(objectPath);
+    if (!partial) return;
+    const { value, residue } = buildCompliantKindSnapshot(schema, partial);
+    this.emit({
+      type: "block_snapshot",
+      kind,
+      path: objectPath,
+      value,
+      residue,
+      complete,
+      at
+    });
+  }
+  /**
+   * On `complete` snapshots (and post-close schema upgrades) the frame has
+   * already been popped — the finalized value lives in the root tree.
+   */
+  getFinalizedObjectValue(path) {
+    const live = this.getLiveObjectValue(path);
+    if (live) return live;
+    if (path.length === 0) {
+      return typeof this.root === "object" && this.root !== null && !Array.isArray(this.root) ? this.root : null;
+    }
+    let cursor = this.root;
+    for (const segment of path) {
+      if (cursor === null || typeof cursor !== "object") return null;
+      cursor = cursor[segment];
+    }
+    return typeof cursor === "object" && cursor !== null && !Array.isArray(cursor) ? cursor : null;
+  }
+  validateFieldPlacement(parent, fieldKey, valueKind, value) {
+    const parentPathKey = this.pathKey(parent.path);
+    const inlineFields = this.inlineSchemas.get(parentPathKey);
+    if (inlineFields) {
+      const fieldSchema = inlineFields[fieldKey];
+      if (!fieldSchema) {
+        return null;
+      }
+      return this.validateValueAgainstField(
+        fieldSchema,
+        valueKind,
+        value,
+        fieldKey
+      );
+    }
+    const recordValueType = this.recordSchemas.get(parentPathKey);
+    if (recordValueType) {
+      if (recordValueType === "json") return null;
+      if (valueKind !== "scalar") {
+        return `Record field "${fieldKey}" must be a scalar.`;
+      }
+      return this.validateRecordScalar(recordValueType, value, fieldKey);
+    }
+    return null;
+  }
+  emitSchemaNotices(path, kind, outcome, at) {
+    for (const field of outcome.optionalMissing) {
+      this.emit({
+        type: "optional_field_missing",
+        kind,
+        path,
+        field,
+        at
+      });
+    }
+    for (const field of outcome.extraFields) {
+      this.emit({
+        type: "extra_field",
+        kind,
+        path,
+        field,
+        at
+      });
+    }
+  }
+  validateObjectAgainstSchema(objectValue, schema) {
+    const optionalMissing = [];
+    const extraFields = [];
+    const emptyOutcome = { optionalMissing, extraFields };
+    if (schema.root) {
+      return {
+        error: `Kind "${schema.kind}" has a non-object root form and cannot be a "${KIND_KEY}" object.`,
+        ...emptyOutcome
+      };
+    }
+    const kind = readObjectKind(objectValue);
+    if (kind !== schema.kind) {
+      return {
+        error: `Object "${KIND_KEY}" is "${kind ?? "missing"}", expected "${schema.kind}".`,
+        ...emptyOutcome
+      };
+    }
+    for (const [fieldName, fieldSchema] of Object.entries(schema.fields)) {
+      if (fieldSchema.required) {
+        if (!(fieldName in objectValue)) {
+          return {
+            error: `Kind "${schema.kind}" is missing required field "${fieldName}".`,
+            ...emptyOutcome
+          };
+        }
+        continue;
+      }
+      if (!(fieldName in objectValue)) {
+        optionalMissing.push(fieldName);
+      }
+    }
+    for (const [fieldName, fieldValue] of Object.entries(objectValue)) {
+      if (fieldName === KIND_KEY) continue;
+      const fieldSchema = schema.fields[fieldName];
+      if (!fieldSchema) {
+        extraFields.push(fieldName);
+        continue;
+      }
+      const error = this.validateFinalFieldValue(
+        fieldSchema,
+        fieldValue,
+        fieldName,
+        schema.kind
+      );
+      if (error) {
+        return { error, optionalMissing, extraFields };
+      }
+    }
+    return { error: null, optionalMissing, extraFields };
+  }
+  validateFinalFieldValue(fieldSchema, value, fieldName, objectKind) {
+    if (fieldSchema.type === "json") return null;
+    if (fieldSchema.type === "json[]") {
+      if (value === null) {
+        return fieldSchema.nullable ? null : `Field "${fieldName}" on kind "${objectKind}" cannot be null.`;
+      }
+      if (!Array.isArray(value)) {
+        return `Field "${fieldName}" on kind "${objectKind}" must be an array.`;
+      }
+      return null;
+    }
+    if (isScalarArrayType(fieldSchema.type)) {
+      if (!Array.isArray(value)) {
+        return `Field "${fieldName}" on kind "${objectKind}" must be an array.`;
+      }
+      const itemType = scalarArrayItemType(fieldSchema.type);
+      if (!value.every((item) => typeof item === itemType)) {
+        return `Field "${fieldName}" on kind "${objectKind}" must be an array of ${itemType}s.`;
+      }
+      if (fieldSchema.type === "string[]" && fieldSchema.values !== void 0 && !fieldSchema.open) {
+        const allowed = fieldSchema.values;
+        const bad = value.find(
+          (item) => typeof item === "string" && !allowed.includes(item)
+        );
+        if (bad !== void 0) {
+          return `Field "${fieldName}" on kind "${objectKind}" items must be one of: ${allowed.join(", ")}.`;
+        }
+      }
+      return null;
+    }
+    if (fieldSchema.type === "array") {
+      if (!Array.isArray(value)) {
+        return `Field "${fieldName}" on kind "${objectKind}" must be an array.`;
+      }
+      return null;
+    }
+    if (fieldSchema.type === "object") {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return `Field "${fieldName}" on kind "${objectKind}" must be an object.`;
+      }
+      const nestedKind = readObjectKind(value);
+      if (nestedKind !== fieldSchema.kind) {
+        return `Field "${fieldName}" on kind "${objectKind}" must be kind "${fieldSchema.kind}".`;
+      }
+      const nestedSchema = this.lookupSchema(fieldSchema.kind);
+      if (!nestedSchema) {
+        return `Unknown nested kind "${fieldSchema.kind}" on field "${fieldName}".`;
+      }
+      return this.validateObjectAgainstSchema(
+        value,
+        nestedSchema
+      ).error;
+    }
+    if (fieldSchema.type === "inline_object") {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return `Field "${fieldName}" on kind "${objectKind}" must be an inline object.`;
+      }
+      return this.validateObjectAgainstFields(
+        value,
+        fieldSchema.fields
+      ).error;
+    }
+    if (fieldSchema.type === "record") {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return `Field "${fieldName}" on kind "${objectKind}" must be a record object.`;
+      }
+      return this.validateRecordObject(
+        value,
+        fieldSchema.values
+      );
+    }
+    if (fieldSchema.type === "union") {
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        const kinds = fieldSchema.kinds ?? [];
+        if (kinds.length === 0) {
+          return `Field "${fieldName}" on kind "${objectKind}" must be ${fieldSchema.scalars.join(" | ")}.`;
+        }
+        const memberKind = readObjectKind(value);
+        if (!memberKind || !kinds.includes(memberKind)) {
+          return `Field "${fieldName}" on kind "${objectKind}" must be one of kinds: ${kinds.join(", ")}.`;
+        }
+        const memberSchema = this.lookupSchema(memberKind);
+        if (!memberSchema) {
+          return `Unknown union member kind "${memberKind}" on field "${fieldName}".`;
+        }
+        return this.validateObjectAgainstSchema(
+          value,
+          memberSchema
+        ).error;
+      }
+      return this.validateScalarField(fieldSchema, value, fieldName);
+    }
+    if (fieldSchema.type === "string" || fieldSchema.type === "number" || fieldSchema.type === "boolean" || fieldSchema.type === "enum") {
+      return this.validateScalarField(fieldSchema, value, fieldName);
+    }
+    return `Unsupported field schema for "${fieldName}".`;
+  }
+  validateValueAgainstField(fieldSchema, valueKind, value, fieldName) {
+    if (fieldSchema.type === "json") {
+      return null;
+    }
+    if (fieldSchema.type === "array" || fieldSchema.type === "json[]") {
+      return valueKind === "array" ? null : `Field "${fieldName}" must be an array.`;
+    }
+    if (fieldSchema.type === "object" || fieldSchema.type === "inline_object") {
+      return valueKind === "object" ? null : `Field "${fieldName}" must be an object.`;
+    }
+    if (fieldSchema.type === "record") {
+      return valueKind === "object" ? null : `Field "${fieldName}" must be a record object.`;
+    }
+    if (isScalarArrayType(fieldSchema.type)) {
+      return valueKind === "array" ? null : `Field "${fieldName}" must be an array.`;
+    }
+    if (fieldSchema.type === "union" && (fieldSchema.kinds?.length ?? 0) > 0) {
+      if (valueKind === "object") return null;
+    }
+    if (valueKind !== "scalar") {
+      return `Field "${fieldName}" must be a scalar.`;
+    }
+    return this.validateScalarField(fieldSchema, value, fieldName);
+  }
+  validateScalarField(fieldSchema, value, fieldName) {
+    if (value === null) {
+      return fieldSchema.nullable ? null : `Field "${fieldName}" cannot be null.`;
+    }
+    if (fieldSchema.type === "enum") {
+      if (typeof value !== "string") {
+        return `Field "${fieldName}" must be a string.`;
+      }
+      if (!fieldSchema.open && !fieldSchema.values.includes(value)) {
+        return `Field "${fieldName}" must be one of: ${fieldSchema.values.join(", ")}.`;
+      }
+      return null;
+    }
+    if (fieldSchema.type === "union") {
+      const valueType = typeof value;
+      if (valueType !== "string" && valueType !== "number" && valueType !== "boolean") {
+        return `Field "${fieldName}" must be ${fieldSchema.scalars.join(" | ")}.`;
+      }
+      if (!fieldSchema.scalars.includes(
+        valueType
+      )) {
+        return `Field "${fieldName}" must be ${fieldSchema.scalars.join(" | ")}.`;
+      }
+      return null;
+    }
+    if (fieldSchema.type === "string" || fieldSchema.type === "number" || fieldSchema.type === "boolean") {
+      if (typeof value !== fieldSchema.type) {
+        return `Field "${fieldName}" must be ${fieldSchema.type}.`;
+      }
+      if (fieldSchema.type === "number" && typeof value === "number") {
+        if (fieldSchema.min !== void 0 && value < fieldSchema.min) {
+          return `Field "${fieldName}" must be >= ${fieldSchema.min}.`;
+        }
+        if (fieldSchema.max !== void 0 && value > fieldSchema.max) {
+          return `Field "${fieldName}" must be <= ${fieldSchema.max}.`;
+        }
+      }
+      return null;
+    }
+    return `Field "${fieldName}" is not a scalar.`;
+  }
+  validateRecordScalar(valueType, value, fieldName) {
+    if (valueType === "json") return null;
+    if (typeof value !== valueType) {
+      return `Record field "${fieldName}" must be ${valueType}.`;
+    }
+    return null;
+  }
+  validateRecordObject(objectValue, valueType) {
+    if (valueType === "json") return null;
+    for (const [key, entry] of Object.entries(objectValue)) {
+      if (typeof entry !== valueType) {
+        return `Record key "${key}" must be ${valueType}.`;
+      }
+    }
+    return null;
+  }
+  validateObjectAgainstFields(objectValue, fields) {
+    const optionalMissing = [];
+    const extraFields = [];
+    const emptyOutcome = { optionalMissing, extraFields };
+    for (const [fieldName, fieldSchema] of Object.entries(fields)) {
+      if (fieldSchema.required) {
+        if (!(fieldName in objectValue)) {
+          return {
+            error: `Inline object is missing required field "${fieldName}".`,
+            ...emptyOutcome
+          };
+        }
+        continue;
+      }
+      if (!(fieldName in objectValue)) {
+        optionalMissing.push(fieldName);
+      }
+    }
+    for (const [fieldName, fieldValue] of Object.entries(objectValue)) {
+      const fieldSchema = fields[fieldName];
+      if (!fieldSchema) {
+        extraFields.push(fieldName);
+        continue;
+      }
+      const error = this.validateFinalFieldValue(
+        fieldSchema,
+        fieldValue,
+        fieldName,
+        "inline_object"
+      );
+      if (error) {
+        return { error, optionalMissing, extraFields };
+      }
+    }
+    return { error: null, optionalMissing, extraFields };
+  }
+  registerObjectContext(path) {
+    const fieldSchema = this.resolveParentFieldSchema(path);
+    if (!fieldSchema) return;
+    const pathKey = this.pathKey(path);
+    if (fieldSchema.type === "inline_object") {
+      this.inlineSchemas.set(pathKey, fieldSchema.fields);
+    }
+    if (fieldSchema.type === "record") {
+      this.recordSchemas.set(pathKey, fieldSchema.values);
+    }
+  }
+  resolveParentFieldSchema(path) {
+    const fieldKey = this.fieldKeyFromPath(path);
+    if (!fieldKey) return void 0;
+    const parentPath = path.slice(0, -1);
+    const parentKind = this.getObjectKindForPath(parentPath);
+    if (!parentKind) return void 0;
+    return this.lookupSchema(parentKind)?.fields[fieldKey];
+  }
+  getObjectKindForPath(path) {
+    return this.objectKinds.get(this.pathKey(path)) ?? (path.length === 0 ? this.rootKind || null : null);
+  }
+  getDirectObjectKind(objectPath) {
+    if (objectPath.length === 0) {
+      return this.rootKind || null;
+    }
+    return this.objectKinds.get(this.pathKey(objectPath)) ?? null;
+  }
+  isAllowedSchemaField(objectPath, fieldKey, objectKind) {
+    const pathKey = this.pathKey(objectPath);
+    const inlineFields = this.inlineSchemas.get(pathKey);
+    if (inlineFields) {
+      return fieldKey in inlineFields;
+    }
+    if (this.recordSchemas.has(pathKey)) {
+      return true;
+    }
+    const schema = this.lookupSchema(objectKind);
+    return !!schema?.fields[fieldKey];
+  }
+  parentFieldName(path) {
+    if (path.length === 0) return void 0;
+    const parent = path[path.length - 2];
+    return typeof parent === "string" ? parent : void 0;
+  }
+  fieldKeyFromPath(path) {
+    const last = path[path.length - 1];
+    return typeof last === "string" ? last : null;
+  }
+  isKindFieldPath(path) {
+    return path[path.length - 1] === KIND_KEY;
+  }
+  pathKey(path) {
+    return path.map((segment) => String(segment)).join(".");
+  }
+  lookupSchema(kind) {
+    return this.resolver.get(kind) ?? this.arrivedSchemas.get(kind);
+  }
+  fail(reason, at) {
+    if (this.failed) return;
+    this.failed = true;
+    this.emit({ type: "error", reason, at });
+  }
+  emit(event) {
+    this.options.onEvent(event);
+  }
+  currentFrame() {
+    return this.stack[this.stack.length - 1];
+  }
+};
+function createKindStreamParser(options) {
+  return new KindStreamParser(options);
+}
+
+// core/fingerprint.ts
+var SEED_A = 2166136261;
+var SEED_B = 16777619;
+function fnv1aStep(hash, input) {
+  let h = hash >>> 0;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24)) >>> 0;
+  }
+  return h >>> 0;
+}
+function createFingerprinter() {
+  let a = SEED_A;
+  let b = SEED_B;
+  let length = 0;
+  return {
+    push(chunk) {
+      a = fnv1aStep(a, chunk);
+      b = fnv1aStep(b, chunk);
+      length += chunk.length;
+    },
+    current() {
+      return `${length.toString(36)}-${a.toString(36)}${b.toString(36)}`;
+    }
+  };
+}
+function fingerprintText(source) {
+  const hasher = createFingerprinter();
+  hasher.push(source);
+  return hasher.current();
+}
+
+// core/normalize.ts
+function isCanonicalBlockIR(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return candidate.v === IR_VERSION && typeof candidate.fingerprint === "string" && typeof candidate.engine === "string" && typeof candidate.root === "object" && candidate.root !== null && candidate.root.role === "structured";
+}
+function reuseEnvelopeIfCurrent(source, candidate) {
+  if (!isCanonicalBlockIR(candidate)) return null;
+  return candidate.fingerprint === fingerprintText(source) ? candidate : null;
+}
+function envelopeFromCompleteValue(value, kind, options) {
+  return {
+    v: IR_VERSION,
+    engine: "fe-kind-parser",
+    fingerprint: fingerprintText(JSON.stringify(value)),
+    root: {
+      role: "structured",
+      kind,
+      kindState: "resolved",
+      discriminator: options?.discriminator ?? { format: "json", key: KIND_KEY },
+      path: [],
+      status: "complete",
+      value,
+      residue: null
+    }
+  };
+}
+function normalizeJsonRegion(source, options) {
+  const reused = reuseEnvelopeIfCurrent(source, options.existing);
+  if (reused) return reused;
+  const tree = new IrTree();
+  const parser = createKindStreamParser({
+    schemas: options.schemas,
+    ...options.expectedRootKind !== void 0 && {
+      expectedRootKind: options.expectedRootKind
+    },
+    onEvent(event) {
+      tree.applyEvent(event);
+    }
+  });
+  parser.push(source);
+  parser.end();
+  return tree.buildEnvelope(fingerprintText(source));
+}
+
+// core/envelope-cache.ts
+var IR_ENVELOPE_CACHE_VERSION = 1;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isIrEnvelopeCache(value) {
+  if (!isRecord2(value)) return false;
+  if (value.v !== IR_ENVELOPE_CACHE_VERSION) return false;
+  if (!isRecord2(value.blocks)) return false;
+  const entries = Object.entries(value.blocks);
+  if (entries.length === 0) return false;
+  for (const [fingerprint, envelope] of entries) {
+    if (!isCanonicalBlockIR(envelope)) return false;
+    if (envelope.fingerprint !== fingerprint) return false;
+    if (envelope.root.status !== "complete") return false;
+  }
+  return true;
+}
+function envelopeCacheFromEnvelopes(envelopes) {
+  let blocks = null;
+  for (const envelope of envelopes) {
+    if (!isCanonicalBlockIR(envelope)) continue;
+    if (envelope.root.status !== "complete") continue;
+    (blocks ??= {})[envelope.fingerprint] = envelope;
+  }
+  return blocks ? { v: IR_ENVELOPE_CACHE_VERSION, blocks } : null;
+}
+
+// core/envelope-read.ts
+function readEnvelope(metadata) {
+  const candidate = metadata?.[IR_ENVELOPE_KEY];
+  return isCanonicalBlockIR(candidate) ? candidate : null;
+}
+function classifyInboundEnvelopeMetadata(metadata) {
+  if (!metadata || !(IR_ENVELOPE_KEY in metadata)) {
+    return { outcome: "absent", metadata: metadata ?? void 0 };
+  }
+  const candidate = metadata[IR_ENVELOPE_KEY];
+  if (isCanonicalBlockIR(candidate)) {
+    return { outcome: "valid", metadata, envelope: candidate };
+  }
+  const engine = typeof candidate === "object" && candidate !== null && typeof candidate.engine === "string" ? candidate.engine : "unknown";
+  const { [IR_ENVELOPE_KEY]: _dropped, ...rest } = metadata;
+  return { outcome: "malformed", metadata: rest, engine, raw: candidate };
+}
+function sanitizeInboundEnvelopeMetadata(metadata, context, hooks = {}) {
+  const verdict = classifyInboundEnvelopeMetadata(metadata);
+  if (verdict.outcome === "valid") {
+    hooks.seedEnvelope?.(verdict.envelope);
+    return verdict.metadata;
+  }
+  if (verdict.outcome === "malformed") {
+    hooks.reportMalformed?.({
+      blockId: context.blockId,
+      engine: verdict.engine,
+      raw: verdict.raw
+    });
+    return verdict.metadata;
+  }
+  return verdict.metadata;
+}
+
+// core/envelope-value.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function reconstructRegionValue(envelope) {
+  const cloned = structuredClone(envelope.root.value);
+  const applyExtras = (target, extras) => {
+    if (!extras) return;
+    for (const [key, value] of Object.entries(extras)) {
+      target[key] = structuredClone(value);
+    }
+  };
+  applyExtras(cloned, envelope.root.residue?.extra);
+  for (const [pathKey, meta] of Object.entries(envelope.nodeIndex ?? {})) {
+    const residue = meta.residue;
+    if (!residue || isEmptyResidue(residue) || !residue.extra) continue;
+    const segments = pathKey.split(".");
+    let cursor = cloned;
+    for (const segment of segments) {
+      if (Array.isArray(cursor)) {
+        cursor = cursor[Number(segment)];
+      } else if (isRecord3(cursor)) {
+        cursor = cursor[segment];
+      } else {
+        cursor = void 0;
+        break;
+      }
+    }
+    if (isRecord3(cursor)) {
+      applyExtras(cursor, residue.extra);
+    }
+  }
+  return cloned;
+}
+function stripKindDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map(stripKindDeep);
+  }
+  if (isRecord3(value)) {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      if (key === KIND_KEY) continue;
+      out[key] = stripKindDeep(child);
+    }
+    return out;
+  }
+  return value;
+}
+
+// utils/text-case-converter.ts
+var DEFAULT_WORD_REPLACEMENTS = {
+  // Acronyms & initialisms
+  "api": "API",
+  "apis": "APIs",
+  "ui": "UI",
+  "ux": "UX",
+  "id": "ID",
+  "ids": "IDs",
+  "qr": "QR",
+  "ssr": "SSR",
+  "csr": "CSR",
+  "ssg": "SSG",
+  "isr": "ISR",
+  "spa": "SPA",
+  "pwa": "PWA",
+  "sdk": "SDK",
+  "sdks": "SDKs",
+  "cli": "CLI",
+  "tty": "TTY",
+  "repl": "REPL",
+  "ci": "CI",
+  "cd": "CD",
+  "cpu": "CPU",
+  "cpus": "CPUs",
+  "gpu": "GPU",
+  "gpus": "GPUs",
+  "ram": "RAM",
+  "rom": "ROM",
+  "ssd": "SSD",
+  "ssds": "SSDs",
+  "hdd": "HDD",
+  "hdds": "HDDs",
+  "kpi": "KPI",
+  "kpis": "KPIs",
+  "sla": "SLA",
+  "slas": "SLAs",
+  "slo": "SLO",
+  "slos": "SLOs",
+  "sli": "SLI",
+  "slis": "SLIs",
+  "dom": "DOM",
+  // Web, formats, protocols
+  "url": "URL",
+  "urls": "URLs",
+  "uri": "URI",
+  "uris": "URIs",
+  "http": "HTTP",
+  "https": "HTTPS",
+  "html": "HTML",
+  "css": "CSS",
+  "json": "JSON",
+  "yaml": "YAML",
+  "yml": "YML",
+  "toml": "TOML",
+  "csv": "CSV",
+  "pdf": "PDF",
+  "tsv": "TSV",
+  "jpg": "JPG",
+  "jpeg": "JPEG",
+  "png": "PNG",
+  "gif": "GIF",
+  "webp": "WebP",
+  "heic": "HEIC",
+  "heif": "HEIF",
+  "bmp": "BMP",
+  "tiff": "TIFF",
+  "ico": "ICO",
+  "xml": "XML",
+  "sql": "SQL",
+  "db": "DB",
+  "dbs": "DBs",
+  "nosql": "NoSQL",
+  "graphql": "GraphQL",
+  "grpc": "gRPC",
+  "rest": "REST",
+  "restful": "RESTful",
+  "websocket": "WebSocket",
+  "websockets": "WebSockets",
+  "webrtc": "WebRTC",
+  // Networking
+  "ip": "IP",
+  "ipv4": "IPv4",
+  "ipv6": "IPv6",
+  "dns": "DNS",
+  "dhcp": "DHCP",
+  "nat": "NAT",
+  "tcp": "TCP",
+  "udp": "UDP",
+  "icmp": "ICMP",
+  "ttl": "TTL",
+  "lan": "LAN",
+  "wan": "WAN",
+  "vlan": "VLAN",
+  "cdn": "CDN",
+  "ftp": "FTP",
+  "ssh": "SSH",
+  "tls": "TLS",
+  "ssl": "SSL",
+  // Security & crypto
+  "jwt": "JWT",
+  "jws": "JWS",
+  "jwe": "JWE",
+  "hmac": "HMAC",
+  "rsa": "RSA",
+  "ecdsa": "ECDSA",
+  "aes": "AES",
+  "pbkdf2": "PBKDF2",
+  "argon2": "Argon2",
+  "scrypt": "scrypt",
+  "totp": "TOTP",
+  "hotp": "HOTP",
+  "mfa": "MFA",
+  "2fa": "2FA",
+  "csrf": "CSRF",
+  "xss": "XSS",
+  "ssrf": "SSRF",
+  "rce": "RCE",
+  "dos": "DoS",
+  "ddos": "DDoS",
+  "mitm": "MITM",
+  "csp": "CSP",
+  "cors": "CORS",
+  "pii": "PII",
+  "phi": "PHI",
+  "gdpr": "GDPR",
+  "ccpa": "CCPA",
+  "hipaa": "HIPAA",
+  "rfc": "RFC",
+  // Platforms, langs, tools (single-token)
+  "javascript": "JavaScript",
+  "typescript": "TypeScript",
+  "jsx": "JSX",
+  "tsx": "TSX",
+  "node": "Node",
+  // (used when tokenized alone)
+  "deno": "Deno",
+  "bun": "Bun",
+  "react": "React",
+  "nextjs": "Next.js",
+  // if your tokenizer drops dots, keep this
+  "nodejs": "Node.js",
+  "postgresql": "PostgreSQL",
+  "postgres": "Postgres",
+  "mysql": "MySQL",
+  "sqlite": "SQLite",
+  "redis": "Redis",
+  "supabase": "Supabase",
+  "docker": "Docker",
+  "kubernetes": "Kubernetes",
+  "k8s": "Kubernetes",
+  "helm": "Helm",
+  "npm": "npm",
+  "pnpm": "pnpm",
+  "yarn": "Yarn",
+  "eslint": "ESLint",
+  "prettier": "Prettier",
+  "vite": "Vite",
+  "webpack": "Webpack",
+  "babel": "Babel",
+  // OS & vendors
+  "macos": "macOS",
+  "ios": "iOS",
+  "ipados": "iPadOS",
+  "watchos": "watchOS",
+  "tvos": "tvOS",
+  "windows": "Windows",
+  "linux": "Linux",
+  "ubuntu": "Ubuntu",
+  "github": "GitHub",
+  "gitlab": "GitLab",
+  "bitbucket": "Bitbucket",
+  // Data & analytics
+  "etl": "ETL",
+  "elt": "ELT",
+  "olap": "OLAP",
+  "oltp": "OLTP",
+  "bi": "BI",
+  // Time & locales
+  "utc": "UTC",
+  "gmt": "GMT",
+  "pst": "PST",
+  "pdt": "PDT",
+  "pt": "PT",
+  // Common “small words” to keep lowercase (unless first/last word)
+  "or": "or",
+  "and": "and",
+  "the": "the",
+  "of": "of",
+  "in": "in",
+  "to": "to",
+  "with": "with",
+  "as": "as",
+  "by": "by",
+  "for": "for",
+  "on": "on",
+  "at": "at",
+  "up": "up",
+  "a": "a",
+  "an": "an",
+  "is": "is",
+  "are": "are",
+  "was": "was",
+  "were": "were",
+  "be": "be",
+  "but": "but",
+  "nor": "nor",
+  "so": "so",
+  "yet": "yet",
+  "per": "per",
+  "via": "via",
+  // Latin abbreviations (tokenized as words in some pipelines)
+  "eg": "e.g.",
+  "ie": "i.e.",
+  "etc": "etc.",
+  "aka": "aka",
+  "vs": "vs.",
+  "v": "v.",
+  // Client abbreviations
+  "CIC": "CIC",
+  "AGR": "AGR",
+  "AGER": "AGER",
+  "DD": "DD",
+  "TS": "TS",
+  "TM": "TM",
+  "arman": "Arman"
+};
+var DEFAULT_OPTIONS = {
+  textCase: "title",
+  wordReplacements: DEFAULT_WORD_REPLACEMENTS,
+  trim: true
+};
+function formatText(text, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  if (!text) return "";
+  let normalized = text.replace(/_/g, " ").replace(/-/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/\s+/g, " ");
+  if (opts.trim) {
+    normalized = normalized.trim();
+  }
+  let caseTransformed = normalized;
+  switch (opts.textCase) {
+    case "title":
+      caseTransformed = normalized.replace(
+        /\w\S*/g,
+        (word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+      );
+      break;
+    case "sentence":
+      if (normalized.length > 0) {
+        caseTransformed = normalized.charAt(0).toUpperCase() + normalized.slice(1).toLowerCase();
+      }
+      break;
+    case "lower":
+      caseTransformed = normalized.toLowerCase();
+      break;
+    case "upper":
+      caseTransformed = normalized.toUpperCase();
+      break;
+  }
+  let result = caseTransformed;
+  if (opts.wordReplacements) {
+    Object.entries(opts.wordReplacements).forEach(([key, value]) => {
+      const regex = new RegExp(`\\b${key}\\b`, "gi");
+      result = result.replace(regex, value);
+    });
+  }
+  return result;
+}
+
+// core/schema-structure.ts
+function formatBlockLabel(key) {
+  return formatText(key, { textCase: "title" });
+}
+function schemaStructureDepth(schema, allSchemas, visiting = /* @__PURE__ */ new Set()) {
+  if (visiting.has(schema.kind)) return 0;
+  visiting.add(schema.kind);
+  let max = 0;
+  for (const field of Object.values(schema.fields)) {
+    max = Math.max(max, fieldStructureDepth(field, allSchemas, visiting));
+  }
+  visiting.delete(schema.kind);
+  return max;
+}
+function fieldStructureDepth(field, allSchemas, visiting) {
+  switch (field.type) {
+    case "array": {
+      let itemMax = 0;
+      for (const itemKind of field.itemKinds) {
+        const itemSchema = allSchemas[itemKind];
+        itemMax = Math.max(
+          itemMax,
+          itemSchema ? 1 + schemaStructureDepth(itemSchema, allSchemas, visiting) : 1
+        );
+      }
+      return itemMax;
+    }
+    case "object": {
+      const ref = allSchemas[field.kind];
+      return ref ? 1 + schemaStructureDepth(ref, allSchemas, visiting) : 1;
+    }
+    case "inline_object": {
+      let nested = 0;
+      for (const child of Object.values(field.fields)) {
+        nested = Math.max(
+          nested,
+          fieldStructureDepth(child, allSchemas, visiting)
+        );
+      }
+      return nested > 0 ? 1 + nested : 1;
+    }
+    default:
+      return 0;
+  }
+}
+function schemaLayoutMode(schema, allSchemas) {
+  const depth = schemaStructureDepth(schema, allSchemas);
+  if (depth <= 0) return "flat";
+  if (depth === 1) return "grid";
+  return "nested";
+}
+
+// session/parse-session.ts
+var ParseSession = class {
+  identity;
+  parser;
+  tree = new IrTree();
+  listeners = /* @__PURE__ */ new Map();
+  anyListeners = /* @__PURE__ */ new Set();
+  unsubscribeSchemaArrivals;
+  fingerprinter = createFingerprinter();
+  ended = false;
+  constructor(options) {
+    this.identity = options.identity;
+    this.parser = createKindStreamParser({
+      schemas: options.schemas,
+      ...options.expectedRootKind !== void 0 && {
+        expectedRootKind: options.expectedRootKind
+      },
+      onEvent: (event) => {
+        this.tree.applyEvent(event);
+        options.onEvent?.(event);
+      }
+    });
+    this.unsubscribeSchemaArrivals = options.onSchemaArrived?.((kind, schema) => {
+      this.parser.notifySchemaArrived(kind, schema);
+      this.flushNotify();
+    }) ?? null;
+  }
+  /** The single writer's input. Does NOT notify — host flushes on its cadence. */
+  write(chunk) {
+    this.fingerprinter.push(chunk);
+    this.parser.push(chunk);
+  }
+  end() {
+    if (this.ended) return;
+    this.ended = true;
+    this.parser.end();
+  }
+  get isEnded() {
+    return this.ended;
+  }
+  get status() {
+    return this.tree.status;
+  }
+  getNode(pathKey) {
+    return this.tree.getNode(pathKey);
+  }
+  listNodes() {
+    return this.tree.listNodes();
+  }
+  isRawPath(pathKey) {
+    return this.tree.isRawPath(pathKey);
+  }
+  subscribe(pathKey, listener) {
+    const set = this.listeners.get(pathKey) ?? /* @__PURE__ */ new Set();
+    set.add(listener);
+    this.listeners.set(pathKey, set);
+    return () => {
+      set.delete(listener);
+      if (set.size === 0) this.listeners.delete(pathKey);
+    };
+  }
+  /** Structural subscription: fires when ANY node changes (mount lists). */
+  subscribeAny(listener) {
+    this.anyListeners.add(listener);
+    return () => {
+      this.anyListeners.delete(listener);
+    };
+  }
+  /** Publish dirty paths to their readers. Host-cadence, coalesced. */
+  flushNotify() {
+    if (!this.tree.hasDirty()) return;
+    const dirty = this.tree.drainDirty();
+    for (const pathKey of dirty) {
+      const set = this.listeners.get(pathKey);
+      if (!set) continue;
+      for (const listener of set) listener();
+    }
+    if (this.anyListeners.size > 0) {
+      for (const listener of this.anyListeners) listener();
+    }
+  }
+  buildEnvelope() {
+    return this.tree.buildEnvelope(this.fingerprinter.current());
+  }
+  dispose() {
+    this.unsubscribeSchemaArrivals?.();
+    this.listeners.clear();
+    this.anyListeners.clear();
+  }
+};
+
+// session/session-manager.ts
+var sessions = /* @__PURE__ */ new Map();
+function openParseSession(options) {
+  const existing = sessions.get(options.identity);
+  if (existing && !existing.isEnded) {
+    throw new Error(
+      `content-ir: a writer is already open for identity "${options.identity}". One writer per stream identity \u2014 everyone else reads.`
+    );
+  }
+  existing?.dispose();
+  const session = new ParseSession(options);
+  sessions.set(options.identity, session);
+  return session;
+}
+function getParseSession(identity) {
+  return sessions.get(identity) ?? null;
+}
+function disposeParseSession(identity) {
+  const session = sessions.get(identity);
+  if (!session) return;
+  session.dispose();
+  sessions.delete(identity);
+}
+
+// registry/kind-storage-transform.ts
+var ROOT_STORAGE_NAME = "__root";
+var KindStorageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "KindStorageError";
+  }
+};
+var PATH_SEP = ".";
+function base(field) {
+  const out = {
+    name: ""
+  };
+  if (field.required) out.required = true;
+  if (field.nullable) out.nullable = true;
+  if (field.description !== void 0) out.description = field.description;
+  if (field.default !== void 0) out.default = field.default;
+  return out;
+}
+function storeField(name, field, path, edges) {
+  const b = { ...base(field), name };
+  switch (field.type) {
+    case "string":
+    case "boolean":
+    case "number[]":
+    case "boolean[]":
+    case "json":
+    case "json[]":
+      return { ...b, type: field.type };
+    case "number":
+      return {
+        ...b,
+        type: "number",
+        ...field.min !== void 0 ? { min: field.min } : {},
+        ...field.max !== void 0 ? { max: field.max } : {},
+        ...field.step !== void 0 ? { step: field.step } : {}
+      };
+    case "string[]":
+      return {
+        ...b,
+        type: "string[]",
+        ...field.values !== void 0 ? { values: [...field.values] } : {},
+        ...field.open ? { open: true } : {}
+      };
+    case "record":
+      return { ...b, type: "record", values: field.values };
+    case "enum":
+      return {
+        ...b,
+        type: "enum",
+        values: [...field.values],
+        ...field.open ? { open: true } : {}
+      };
+    case "union": {
+      if (field.kinds && field.kinds.length > 0) {
+        field.kinds.forEach((childKind, position) => {
+          edges.push({ fieldPath: path, childKind, position });
+        });
+        return { ...b, type: "union", scalars: [...field.scalars], hasKinds: true };
+      }
+      return { ...b, type: "union", scalars: [...field.scalars] };
+    }
+    case "object":
+      edges.push({ fieldPath: path, childKind: field.kind, position: null });
+      return { ...b, type: "object" };
+    case "array":
+      field.itemKinds.forEach((childKind, position) => {
+        edges.push({ fieldPath: path, childKind, position });
+      });
+      return { ...b, type: "array" };
+    case "inline_object": {
+      const fields = [];
+      for (const [childName, childField] of Object.entries(field.fields)) {
+        fields.push(
+          storeField(
+            childName,
+            childField,
+            `${path}${PATH_SEP}${childName}`,
+            edges
+          )
+        );
+      }
+      return field.open ? { ...b, type: "inline_object", fields, open: true } : { ...b, type: "inline_object", fields };
+    }
+  }
+}
+function kindSchemaToStorage(schema) {
+  const data = [];
+  const edges = [];
+  if (schema.root) {
+    if (Object.keys(schema.fields).length > 0) {
+      throw new KindStorageError(
+        `kind "${schema.kind}": root form and a non-empty fields map are mutually exclusive.`
+      );
+    }
+    data.push(storeField(ROOT_STORAGE_NAME, schema.root, ROOT_STORAGE_NAME, edges));
+    return { data, edges };
+  }
+  for (const [name, field] of Object.entries(schema.fields)) {
+    if (name === ROOT_STORAGE_NAME) {
+      throw new KindStorageError(
+        `kind "${schema.kind}": field name "${ROOT_STORAGE_NAME}" is reserved for the non-object root form.`
+      );
+    }
+    data.push(storeField(name, field, name, edges));
+  }
+  return { data, edges };
+}
+function indexEdges(edges) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const list = byPath.get(edge.fieldPath);
+    if (list) list.push(edge);
+    else byPath.set(edge.fieldPath, [edge]);
+  }
+  return byPath;
+}
+function restoreField(element, path, byPath) {
+  const b = {};
+  if (element.required) b.required = true;
+  if (element.nullable) b.nullable = true;
+  if (element.description !== void 0) b.description = element.description;
+  if (element.default !== void 0) b.default = element.default;
+  switch (element.type) {
+    case "string":
+    case "boolean":
+    case "number[]":
+    case "boolean[]":
+    case "json":
+    case "json[]":
+      return { ...b, type: element.type };
+    case "number":
+      return {
+        ...b,
+        type: "number",
+        ...element.min !== void 0 ? { min: element.min } : {},
+        ...element.max !== void 0 ? { max: element.max } : {},
+        ...element.step !== void 0 ? { step: element.step } : {}
+      };
+    case "string[]":
+      return {
+        ...b,
+        type: "string[]",
+        ...element.values !== void 0 ? { values: [...element.values] } : {},
+        ...element.open ? { open: true } : {}
+      };
+    case "record":
+      return { ...b, type: "record", values: element.values };
+    case "enum":
+      return {
+        ...b,
+        type: "enum",
+        values: [...element.values],
+        ...element.open ? { open: true } : {}
+      };
+    case "union": {
+      const list = byPath.get(path) ?? [];
+      if (element.hasKinds) {
+        if (list.length === 0) {
+          throw new KindStorageError(
+            `union field "${path}" declares kind members (hasKinds) but has no edges.`
+          );
+        }
+        const kinds = [...list].sort((a, z) => (a.position ?? 0) - (z.position ?? 0)).map((e) => e.childKind);
+        return { ...b, type: "union", scalars: [...element.scalars], kinds };
+      }
+      if (list.length > 0) {
+        throw new KindStorageError(
+          `union field "${path}" has ${list.length} edge(s) but does not declare hasKinds.`
+        );
+      }
+      return { ...b, type: "union", scalars: [...element.scalars] };
+    }
+    case "object": {
+      const list = byPath.get(path) ?? [];
+      if (list.length !== 1) {
+        throw new KindStorageError(
+          `object field "${path}" must have exactly one edge, found ${list.length}.`
+        );
+      }
+      const [edge] = list;
+      if (!edge) {
+        throw new KindStorageError(
+          `object field "${path}" must have exactly one edge, found 0.`
+        );
+      }
+      return { ...b, type: "object", kind: edge.childKind };
+    }
+    case "array": {
+      const list = byPath.get(path) ?? [];
+      if (list.length === 0) {
+        throw new KindStorageError(
+          `array field "${path}" must have at least one edge.`
+        );
+      }
+      const itemKinds = [...list].sort((a, z) => (a.position ?? 0) - (z.position ?? 0)).map((e) => e.childKind);
+      return { ...b, type: "array", itemKinds };
+    }
+    case "inline_object": {
+      const fields = {};
+      for (const child of element.fields) {
+        fields[child.name] = restoreField(
+          child,
+          `${path}${PATH_SEP}${child.name}`,
+          byPath
+        );
+      }
+      return element.open ? { ...b, type: "inline_object", fields, open: true } : { ...b, type: "inline_object", fields };
+    }
+  }
+}
+function storageToKindSchema(kind, shape) {
+  const byPath = indexEdges(shape.edges);
+  const [first] = shape.data;
+  if (first && first.name === ROOT_STORAGE_NAME) {
+    if (shape.data.length !== 1) {
+      throw new KindStorageError(
+        `kind "${kind}": a "${ROOT_STORAGE_NAME}" element must be the only data element (found ${shape.data.length}).`
+      );
+    }
+    return {
+      kind,
+      fields: {},
+      root: restoreField(first, ROOT_STORAGE_NAME, byPath)
+    };
+  }
+  const fields = {};
+  for (const element of shape.data) {
+    if (element.name === ROOT_STORAGE_NAME) {
+      throw new KindStorageError(
+        `kind "${kind}": "${ROOT_STORAGE_NAME}" must be the first and only data element.`
+      );
+    }
+    fields[element.name] = restoreField(element, element.name, byPath);
+  }
+  return { kind, fields };
+}
+var ajv = new Ajv__default.default({ allErrors: true, strict: false });
+function stripKind(value) {
+  if (Array.isArray(value)) return value.map(stripKind);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (k === KIND_KEY) continue;
+      out[k] = stripKind(v);
+    }
+    return out;
+  }
+  return value;
+}
+function validateStructuralLeg(sample, emittedJsonSchema) {
+  let validate;
+  try {
+    validate = ajv.compile(emittedJsonSchema);
+  } catch (err) {
+    return {
+      ok: false,
+      detail: `emitted_json_schema failed to compile: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const ok = validate(stripKind(sample));
+  if (ok) return { ok: true };
+  const errors = (validate.errors ?? []).map((e) => `${e.instancePath || "(root)"} ${e.message ?? ""}`.trim()).slice(0, 8);
+  return { ok: false, detail: `sample failed schema: ${errors.join("; ")}` };
+}
+var SERVER_DATA_ANNOTATION_KEYS = /* @__PURE__ */ new Set(["language"]);
+var SUBSTANCE_DEPTH_LIMIT = 8;
+function isSubstantiveValue(value, depth = 0) {
+  if (value === null || value === void 0) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value === "boolean") return true;
+  if (depth >= SUBSTANCE_DEPTH_LIMIT) return true;
+  if (Array.isArray(value)) {
+    return value.some((entry) => isSubstantiveValue(entry, depth + 1));
+  }
+  if (typeof value === "object") {
+    return Object.values(value).some(
+      (entry) => isSubstantiveValue(entry, depth + 1)
+    );
+  }
+  return false;
+}
+function describeUnrenderableBridgeOutput(serverData) {
+  if (serverData === void 0 || serverData === null) {
+    return "bridge returned no serverData (undefined)";
+  }
+  if (typeof serverData !== "object") {
+    return `bridge returned a non-object serverData (${typeof serverData})`;
+  }
+  if (Array.isArray(serverData)) {
+    return "bridge returned an array, not a serverData record";
+  }
+  const record = serverData;
+  const keys = Object.keys(record);
+  if (keys.length === 0) return "bridge returned an empty object ({})";
+  const contentKeys = keys.filter((key) => !SERVER_DATA_ANNOTATION_KEYS.has(key));
+  if (contentKeys.length === 0) {
+    return `bridge returned only annotation keys [${keys.join(", ")}] \u2014 that is the raw code-region annotation, not kind data`;
+  }
+  if (!contentKeys.some((key) => isSubstantiveValue(record[key]))) {
+    return `bridge returned serverData whose every content value is empty (keys: ${contentKeys.join(", ")}) \u2014 structurally present, semantically empty`;
+  }
+  return null;
+}
+function validateRender(kind, sample, definition, resolvedComponent, dataOnly) {
+  if (dataOnly) {
+    return {
+      ok: true,
+      detail: "data-only contract kind \u2014 render leg is structurally inapplicable (n/a)"
+    };
+  }
+  if (!definition && !resolvedComponent?.isActive) {
+    return {
+      ok: false,
+      detail: `kind "${kind}" has no component (not in the compiled registry, and no active role='output' kind_component row) \u2014 nothing to render`
+    };
+  }
+  if (definition && !definition.legacyBlockType && !definition.component && !definition.toLegacyServerData && !resolvedComponent?.isActive) {
+    return {
+      ok: false,
+      detail: `kind "${kind}" has no component (no compiled legacyBlockType/component facet, and no active role='output' kind_component row) \u2014 nothing to render`
+    };
+  }
+  if (definition?.toLegacyServerData) {
+    let serverData;
+    try {
+      serverData = definition.toLegacyServerData(
+        envelopeFromCompleteValue(sample, kind)
+      );
+    } catch (err) {
+      return {
+        ok: false,
+        detail: `toLegacyServerData threw: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    const problem = describeUnrenderableBridgeOutput(serverData);
+    if (problem) {
+      return {
+        ok: false,
+        detail: `${problem} (the "No ${kind} available" failure)`
+      };
+    }
+    return { ok: true };
+  }
+  const satisfier = definition?.legacyBlockType ? `compiled component "${definition.legacyBlockType}"` : definition?.component ? "compiled component facet" : resolvedComponent ? `resolved ${resolvedComponent.source} component "${resolvedComponent.componentKey}"` : "component";
+  return {
+    ok: true,
+    detail: `bridgeless kind \u2014 ${satisfier} parses content itself; full DOM render check deferred to an RTL harness`
+  };
+}
+function runKindDualGate(input) {
+  const structural = validateStructuralLeg(input.sample, input.emittedJsonSchema);
+  const render = validateRender(
+    input.kind,
+    input.sample,
+    input.definition,
+    input.resolvedComponent,
+    input.dataOnly
+  );
+  return { isActive: structural.ok && render.ok, structural, render };
+}
+function describeDualGateFailure(kind, result) {
+  if (result.isActive) return "";
+  const parts = [];
+  if (!result.structural.ok) {
+    parts.push(`structural(Pydantic): ${result.structural.detail ?? "failed"}`);
+  }
+  if (!result.render.ok) {
+    parts.push(`render(UI): ${result.render.detail ?? "failed"}`);
+  }
+  return `kind "${kind}" failed the dual gate \u2014 ${parts.join(" | ")}`;
+}
+
+// convert/openai-schema-converter.ts
+function requiredNullableFlags(required, nullable) {
+  return {
+    ...required ? { required: true } : {},
+    ...nullable ? { nullable: true } : {}
+  };
+}
+var METADATA_KEYS = /* @__PURE__ */ new Set([
+  "description",
+  "title",
+  "default",
+  "examples",
+  "format",
+  "minimum",
+  "maximum",
+  "multipleOf",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "minLength",
+  "maxLength",
+  "minItems",
+  "maxItems",
+  "pattern",
+  "const",
+  "$schema",
+  "$id",
+  "deprecated",
+  "readOnly",
+  "writeOnly"
+]);
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepClone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function fieldSchemaSummary(field) {
+  if (field.type === "enum") {
+    return `enum(${field.values.join("|")}${field.open ? "|+any" : ""})${field.required ? "*" : ""}`;
+  }
+  if (field.type === "array") {
+    return `array<${field.itemKinds.join("|")}>${field.required ? "*" : ""}`;
+  }
+  if (field.type === "inline_object") {
+    return `inline{${Object.keys(field.fields).join(",")}}${field.required ? "*" : ""}`;
+  }
+  if (field.type === "object") {
+    return `object:${field.kind}${field.required ? "*" : ""}`;
+  }
+  if (field.type === "union") {
+    const members = [...field.scalars, ...field.kinds ?? []];
+    return `union(${members.join("|")})${field.required ? "*" : ""}`;
+  }
+  if (field.type === "record") {
+    return `record(${field.values})${field.required ? "*" : ""}`;
+  }
+  return `${field.type}${field.required ? "*" : ""}${field.nullable ? "?" : ""}`;
+}
+function resolvePrimaryType(node) {
+  const raw = node.type;
+  if (typeof raw === "string") {
+    return { type: raw === "integer" ? "number" : raw, nullable: false };
+  }
+  if (Array.isArray(raw)) {
+    const types = raw.filter((t) => typeof t === "string");
+    const nullable = types.includes("null");
+    const primary = types.find((t) => t !== "null") ?? (nullable && types.length === 1 ? "null" : null);
+    if (primary === "integer") {
+      return { type: "number", nullable };
+    }
+    return { type: primary ?? null, nullable };
+  }
+  if (node.enum) return { type: "string", nullable: false };
+  if (node.properties) return { type: "object", nullable: false };
+  if (node.items) return { type: "array", nullable: false };
+  return { type: null, nullable: false };
+}
+function carriedMetadataKeys(field) {
+  if (field === null) return /* @__PURE__ */ new Set();
+  const carried = /* @__PURE__ */ new Set(["description", "default"]);
+  if (field.type === "number") {
+    carried.add("minimum");
+    carried.add("maximum");
+    carried.add("multipleOf");
+  }
+  return carried;
+}
+function collectDropped(node, path, carriedField = null) {
+  const carried = carriedMetadataKeys(carriedField);
+  const dropped = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (METADATA_KEYS.has(key) && !carried.has(key)) {
+      dropped[key] = value;
+    }
+  }
+  if (Object.keys(dropped).length > 0) {
+    return [{ path, dropped }];
+  }
+  return [];
+}
+function attachNodeMetadata(node, field) {
+  let out = field;
+  if (typeof node.description === "string" && out.description === void 0) {
+    out = { ...out, description: node.description };
+  }
+  if (node.default !== void 0 && out.default === void 0) {
+    out = { ...out, default: node.default };
+  }
+  if (out.type === "number") {
+    const bounds = {};
+    if (typeof node.minimum === "number" && out.min === void 0) {
+      bounds.min = node.minimum;
+    }
+    if (typeof node.maximum === "number" && out.max === void 0) {
+      bounds.max = node.maximum;
+    }
+    if (typeof node.multipleOf === "number" && out.step === void 0) {
+      bounds.step = node.multipleOf;
+    }
+    if (Object.keys(bounds).length > 0) out = { ...out, ...bounds };
+  }
+  return out;
+}
+function synthesizeItemKindSlug(schemaName, fieldName) {
+  const base2 = fieldName.endsWith("ies") ? `${fieldName.slice(0, -3)}y` : fieldName.endsWith("s") ? fieldName.slice(0, -1) : fieldName;
+  return `${schemaName}_${base2}`;
+}
+function makeKindJsonSchemaProperty(kindSlug, strict) {
+  const base2 = {
+    type: "string",
+    description: "Block discriminator for render pipeline."
+  };
+  if (strict) {
+    return { ...base2, const: kindSlug };
+  }
+  return { ...base2, enum: [kindSlug] };
+}
+function injectKindIntoObjectSchema(objectSchema, kindSlug, strict) {
+  const clone = deepClone(objectSchema);
+  const properties = isRecord4(clone.properties) ? { ...clone.properties } : {};
+  properties[KIND_KEY] = makeKindJsonSchemaProperty(kindSlug, strict);
+  const required = Array.isArray(clone.required) ? clone.required.filter((k) => typeof k === "string") : [];
+  const nextRequired = required.includes(KIND_KEY) ? required : [KIND_KEY, ...required];
+  return {
+    ...clone,
+    properties,
+    required: nextRequired,
+    ...strict ? { additionalProperties: false } : {}
+  };
+}
+function injectKindsIntoRootSchema(rootSchema, rootKindSlug, arrayBindings, strict) {
+  let updated = injectKindIntoObjectSchema(rootSchema, rootKindSlug, strict);
+  if (!isRecord4(updated.properties)) {
+    return updated;
+  }
+  const properties = { ...updated.properties };
+  for (const binding of arrayBindings) {
+    const fieldNode = properties[binding.arrayField];
+    if (!isRecord4(fieldNode)) continue;
+    const items = fieldNode.items;
+    const itemNode = Array.isArray(items) ? items[0] : items;
+    if (!isRecord4(itemNode)) continue;
+    const updatedItem = injectKindIntoObjectSchema(
+      itemNode,
+      binding.itemKindSlug,
+      strict
+    );
+    properties[binding.arrayField] = {
+      ...fieldNode,
+      items: updatedItem
+    };
+  }
+  return { ...updated, properties };
+}
+function buildAgentSchemaWithRenderBlockSupport(input, rootKindSlug, arrayBindings, strict) {
+  if (!isRecord4(input)) return null;
+  const normalized = normalizeAiSchemaInput(input);
+  if (!normalized.rootSchema) return null;
+  if (normalized.rootSchema.type !== "object" && !isRecord4(normalized.rootSchema.properties)) {
+    return deepClone(input);
+  }
+  const updatedRoot = injectKindsIntoRootSchema(
+    normalized.rootSchema,
+    rootKindSlug,
+    arrayBindings,
+    strict
+  );
+  if (isRecord4(input.schema) && typeof input.name === "string") {
+    return {
+      ...deepClone(input),
+      schema: updatedRoot
+    };
+  }
+  if (isRecord4(input.json_schema)) {
+    const inner = buildAgentSchemaWithRenderBlockSupport(
+      input.json_schema,
+      rootKindSlug,
+      arrayBindings,
+      strict
+    );
+    return inner ? { ...deepClone(input), json_schema: inner } : null;
+  }
+  if (typeof input.name === "string") {
+    return {
+      ...deepClone(input),
+      schema: updatedRoot
+    };
+  }
+  return updatedRoot;
+}
+function isAnyValueSchema(node) {
+  return node.type === void 0 && node.enum === void 0 && node.const === void 0 && node.properties === void 0 && node.items === void 0 && node.additionalProperties === void 0 && node.anyOf === void 0 && node.oneOf === void 0 && node.allOf === void 0 && node.$ref === void 0;
+}
+function registerDeclaredKindDraft(declaredKind, objectNode, path, ctx) {
+  if (ctx.blockSchemas.some((draft) => draft.slug === declaredKind)) return;
+  if (!isRecord4(objectNode.properties)) return;
+  const memberRequired = new Set(
+    Array.isArray(objectNode.required) ? objectNode.required.filter((k) => typeof k === "string") : []
+  );
+  const fields = {};
+  for (const [propName, propNode] of Object.entries(objectNode.properties)) {
+    if (!isRecord4(propNode)) continue;
+    if (propName === KIND_KEY) continue;
+    const converted = convertProperty(
+      propName,
+      propNode,
+      memberRequired.has(propName),
+      `${path}.${propName}`,
+      ctx
+    );
+    if (converted) fields[propName] = converted;
+  }
+  ctx.blockSchemas.push({
+    slug: declaredKind,
+    label: formatBlockLabel(declaredKind),
+    fields
+  });
+}
+function convertProperty(fieldName, node, required, path, ctx) {
+  const core = convertPropertyCore(fieldName, node, required, path, ctx);
+  const field = core === null ? null : attachNodeMetadata(node, core);
+  ctx.droppedMetadata.push(...collectDropped(node, path, field));
+  return field;
+}
+function convertPropertyCore(fieldName, node, required, path, ctx) {
+  if (typeof node.$ref === "string") {
+    ctx.problems.push({
+      severity: "error",
+      path,
+      message: `$ref is not supported ("${node.$ref}"). Inline the schema manually.`
+    });
+    return null;
+  }
+  if (Array.isArray(node.anyOf) || Array.isArray(node.oneOf)) {
+    const variants = node.anyOf ?? node.oneOf;
+    const scalarTypes = /* @__PURE__ */ new Set();
+    const enumVariantSets = [];
+    const memberKinds = [];
+    const anonymousObjects = [];
+    let sawNull = false;
+    let unsupported = false;
+    for (const variant of variants) {
+      if (!isRecord4(variant)) {
+        unsupported = true;
+        continue;
+      }
+      if (typeof variant.$ref === "string") {
+        ctx.problems.push({
+          severity: "error",
+          path,
+          message: `$ref inside anyOf/oneOf is not supported ("${variant.$ref}"). Inline the schema manually.`
+        });
+        unsupported = true;
+        continue;
+      }
+      const { type: type2, nullable: nullable2 } = resolvePrimaryType(variant);
+      if (nullable2) sawNull = true;
+      if (type2 === "null") {
+        sawNull = true;
+        continue;
+      }
+      if (type2 === "string" && Array.isArray(variant.enum)) {
+        enumVariantSets.push(
+          variant.enum.filter((v) => typeof v === "string")
+        );
+        continue;
+      }
+      if (type2 === "string" || type2 === "number" || type2 === "boolean") {
+        scalarTypes.add(type2);
+        continue;
+      }
+      if (type2 === "object" && isRecord4(variant.properties)) {
+        const declared = readBlockKindFromProperties(variant.properties);
+        if (declared) {
+          memberKinds.push(declared);
+          registerDeclaredKindDraft(declared, variant, `${path}<${declared}>`, ctx);
+        } else {
+          anonymousObjects.push(variant);
+        }
+        continue;
+      }
+      unsupported = true;
+    }
+    if (unsupported) {
+      ctx.problems.push({
+        severity: "error",
+        path,
+        message: "anyOf/oneOf with unsupported variants cannot be converted automatically."
+      });
+      return null;
+    }
+    if (enumVariantSets.length > 0 && anonymousObjects.length === 0 && memberKinds.length === 0 && [...scalarTypes].every((s) => s === "string")) {
+      const values = [...new Set(enumVariantSets.flat())];
+      const open = scalarTypes.has("string");
+      return {
+        ...requiredNullableFlags(required, sawNull),
+        type: "enum",
+        values,
+        ...open ? { open: true } : {}
+      };
+    }
+    if (enumVariantSets.length > 0) {
+      ctx.problems.push({
+        severity: "warning",
+        path,
+        message: "anyOf/oneOf mixes an enum variant with non-string members \u2014 enum widened to string within the union."
+      });
+      scalarTypes.add("string");
+    }
+    if (anonymousObjects.length === 1 && scalarTypes.size === 0 && memberKinds.length === 0) {
+      const [sole] = anonymousObjects;
+      const converted = sole ? convertProperty(fieldName, sole, required, path, ctx) : null;
+      if (!converted) return null;
+      return sawNull ? { ...converted, nullable: true } : converted;
+    }
+    if (anonymousObjects.length > 0) {
+      ctx.problems.push({
+        severity: "error",
+        path,
+        message: "anyOf/oneOf mixing anonymous objects with other variants cannot be converted \u2014 declare __kind on each object variant."
+      });
+      return null;
+    }
+    if (scalarTypes.size === 1 && memberKinds.length === 0) {
+      const [scalar] = [...scalarTypes];
+      if (scalar) {
+        return { ...requiredNullableFlags(required, sawNull), type: scalar };
+      }
+    }
+    if (scalarTypes.size > 0 || memberKinds.length > 0) {
+      ctx.problems.push({
+        severity: "warning",
+        path,
+        message: `Converted anyOf/oneOf to union of: ${[
+          ...scalarTypes,
+          ...memberKinds
+        ].join(", ")}.`
+      });
+      return {
+        ...requiredNullableFlags(required, sawNull),
+        type: "union",
+        scalars: [...scalarTypes],
+        ...memberKinds.length > 0 ? { kinds: memberKinds } : {}
+      };
+    }
+    ctx.problems.push({
+      severity: "warning",
+      path,
+      message: "anyOf/oneOf carried only null variants \u2014 widened to json (any value)."
+    });
+    return { ...requiredNullableFlags(required), type: "json" };
+  }
+  if (Array.isArray(node.allOf)) {
+    ctx.problems.push({
+      severity: "warning",
+      path,
+      message: "allOf merged using first object branch only."
+    });
+    const objectBranch = node.allOf.find(
+      (b) => b.properties
+    );
+    if (objectBranch) {
+      return convertProperty(fieldName, objectBranch, required, path, ctx);
+    }
+  }
+  if (isAnyValueSchema(node)) {
+    ctx.problems.push({
+      severity: "info",
+      path,
+      message: `Typeless schema at "${path || "(root)"}" \u2014 any JSON value (json).`
+    });
+    return { ...requiredNullableFlags(required), type: "json" };
+  }
+  const { type, nullable } = resolvePrimaryType(node);
+  if (type === "string") {
+    if (Array.isArray(node.enum)) {
+      const values = node.enum.filter(
+        (v) => typeof v === "string"
+      );
+      if (values.length !== node.enum.length) {
+        ctx.problems.push({
+          severity: "warning",
+          path,
+          message: "Enum contains non-string values; non-strings dropped."
+        });
+      }
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "enum",
+        values
+      };
+    }
+    return {
+      ...requiredNullableFlags(required, nullable),
+      type: "string"
+    };
+  }
+  if (type === "number") {
+    return {
+      ...requiredNullableFlags(required, nullable),
+      type: "number"
+    };
+  }
+  if (type === "boolean") {
+    return {
+      ...requiredNullableFlags(required, nullable),
+      type: "boolean"
+    };
+  }
+  if (type === "array") {
+    const items = node.items;
+    if (!items) {
+      ctx.problems.push({
+        severity: "error",
+        path,
+        message: "Array field is missing items schema."
+      });
+      return null;
+    }
+    const itemNode = Array.isArray(items) ? items[0] : items;
+    if (!isRecord4(itemNode)) {
+      ctx.problems.push({
+        severity: "error",
+        path,
+        message: "Array items schema must be an object."
+      });
+      return null;
+    }
+    if (isAnyValueSchema(itemNode)) {
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "json[]"
+      };
+    }
+    const itemVariants = Array.isArray(itemNode.anyOf) ? itemNode.anyOf : Array.isArray(itemNode.oneOf) ? itemNode.oneOf : null;
+    if (itemVariants) {
+      const itemEnumSets = [];
+      let itemPlainString = false;
+      let itemsAllString = true;
+      for (const variant of itemVariants) {
+        if (!isRecord4(variant) || resolvePrimaryType(variant).type !== "string") {
+          itemsAllString = false;
+          break;
+        }
+        if (Array.isArray(variant.enum)) {
+          itemEnumSets.push(
+            variant.enum.filter((v) => typeof v === "string")
+          );
+        } else {
+          itemPlainString = true;
+        }
+      }
+      if (itemsAllString && itemEnumSets.length > 0) {
+        return {
+          ...requiredNullableFlags(required, nullable),
+          type: "string[]",
+          values: [...new Set(itemEnumSets.flat())],
+          ...itemPlainString ? { open: true } : {}
+        };
+      }
+      const itemKinds = [];
+      for (const variant of itemVariants) {
+        if (!isRecord4(variant) || !isRecord4(variant.properties)) {
+          ctx.problems.push({
+            severity: "error",
+            path: `${path}[]`,
+            message: "Array items anyOf/oneOf variants must be inline objects declaring __kind."
+          });
+          return null;
+        }
+        const declared = readBlockKindFromProperties(variant.properties);
+        if (!declared) {
+          ctx.problems.push({
+            severity: "error",
+            path: `${path}[]`,
+            message: "Array items anyOf/oneOf variant is missing a __kind const/enum declaration."
+          });
+          return null;
+        }
+        itemKinds.push(declared);
+        registerDeclaredKindDraft(declared, variant, `${path}[]<${declared}>`, ctx);
+        ctx.arrayBindings.push({ arrayField: fieldName, itemKindSlug: declared });
+      }
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "array",
+        itemKinds
+      };
+    }
+    const itemType = resolvePrimaryType(itemNode).type;
+    if (itemType === "string") {
+      if (Array.isArray(itemNode.enum)) {
+        return {
+          ...requiredNullableFlags(required, nullable),
+          type: "string[]",
+          values: itemNode.enum.filter(
+            (v) => typeof v === "string"
+          )
+        };
+      }
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "string[]"
+      };
+    }
+    if (itemType === "number") {
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "number[]"
+      };
+    }
+    if (itemType === "boolean") {
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "boolean[]"
+      };
+    }
+    if (itemType === "object" && isRecord4(itemNode.properties)) {
+      const declaredItemKind = readBlockKindFromProperties(itemNode.properties);
+      const itemKindSlug = declaredItemKind ?? synthesizeItemKindSlug(ctx.schemaName, fieldName);
+      const itemRequired = new Set(
+        Array.isArray(itemNode.required) ? itemNode.required.filter((k) => typeof k === "string") : []
+      );
+      const itemFields = {};
+      for (const [propName, propNode] of Object.entries(itemNode.properties)) {
+        if (!isRecord4(propNode)) continue;
+        if (propName === KIND_KEY) continue;
+        const converted = convertProperty(
+          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({
+        arrayField: fieldName,
+        itemKindSlug
+      });
+      if (!ctx.blockSchemas.some((draft) => draft.slug === itemKindSlug)) {
+        ctx.blockSchemas.push({
+          slug: itemKindSlug,
+          label: declaredItemKind ? formatBlockLabel(itemKindSlug) : formatBlockLabel(`${ctx.schemaName}_${fieldName}_item`),
+          fields: itemFields
+        });
+      }
+      if (!alreadyHasBlockKind) {
+        ctx.problems.push({
+          severity: "warning",
+          path: `${path}[]`,
+          message: `Array "${fieldName}" items need __kind:"${itemKindSlug}" at runtime (OPTION 1: server injects, OPTION 2: use agent schema with __kind).`
+        });
+      }
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "array",
+        itemKinds: [itemKindSlug]
+      };
+    }
+    ctx.problems.push({
+      severity: "error",
+      path,
+      message: `Unsupported array items type "${itemType ?? "unknown"}".`
+    });
+    return null;
+  }
+  if (type === "object") {
+    const ap = node.additionalProperties;
+    const apIsOpen = ap === true || isRecord4(ap) && isAnyValueSchema(ap);
+    if (isRecord4(node.properties)) {
+      const nestedRequired = new Set(
+        Array.isArray(node.required) ? node.required.filter((k) => typeof k === "string") : []
+      );
+      const nestedFields = {};
+      for (const [propName, propNode] of Object.entries(node.properties)) {
+        if (!isRecord4(propNode)) continue;
+        if (propName === KIND_KEY) continue;
+        const converted = convertProperty(
+          propName,
+          propNode,
+          nestedRequired.has(propName),
+          `${path}.${propName}`,
+          ctx
+        );
+        if (converted) {
+          nestedFields[propName] = converted;
+        }
+      }
+      const referencedKind = readBlockKindFromProperties(node.properties);
+      if (referencedKind) {
+        return {
+          ...requiredNullableFlags(required, nullable),
+          type: "object",
+          kind: referencedKind
+        };
+      }
+      let open = apIsOpen;
+      if (!apIsOpen && isRecord4(ap)) {
+        ctx.problems.push({
+          severity: "warning",
+          path,
+          message: "Typed additionalProperties alongside declared properties is not representable \u2014 treated as an OPEN object (extra values unconstrained)."
+        });
+        open = true;
+      } else if (ap === false) {
+        ctx.droppedMetadata.push({
+          path,
+          dropped: { additionalProperties: false }
+        });
+      }
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "inline_object",
+        fields: nestedFields,
+        ...open ? { open: true } : {}
+      };
+    }
+    if (apIsOpen || ap === void 0) {
+      if (ap === void 0) {
+        ctx.problems.push({
+          severity: "info",
+          path,
+          message: `Bare object schema at "${path || "(root)"}" \u2014 record of any JSON values.`
+        });
+      }
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "record",
+        values: "json"
+      };
+    }
+    if (isRecord4(ap)) {
+      const apType = resolvePrimaryType(ap).type;
+      if (apType === "string" || apType === "number" || apType === "boolean") {
+        return {
+          ...requiredNullableFlags(required, nullable),
+          type: "record",
+          values: apType
+        };
+      }
+      ctx.problems.push({
+        severity: "warning",
+        path,
+        message: `Record value schema at "${path}" is not scalar \u2014 widened to record of any JSON values.`
+      });
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "record",
+        values: "json"
+      };
+    }
+    return {
+      ...requiredNullableFlags(required, nullable),
+      type: "inline_object",
+      fields: {}
+    };
+  }
+  ctx.problems.push({
+    severity: "error",
+    path,
+    message: `Unsupported or missing JSON Schema type at "${path}".`
+  });
+  return null;
+}
+function propNameIsBlockKind(properties) {
+  return KIND_KEY in properties;
+}
+function readBlockKindFromProperties(properties) {
+  const kindProp = properties[KIND_KEY];
+  if (!isRecord4(kindProp)) return null;
+  if (typeof kindProp.const === "string") return kindProp.const;
+  if (Array.isArray(kindProp.enum) && typeof kindProp.enum[0] === "string") {
+    return kindProp.enum[0];
+  }
+  return null;
+}
+function normalizeAiSchemaInput(input) {
+  const parseErrors = [];
+  if (!isRecord4(input)) {
+    return {
+      name: null,
+      strict: null,
+      rootSchema: null,
+      parseErrors: ["Input must be a JSON object."]
+    };
+  }
+  if (isRecord4(input.json_schema)) {
+    return normalizeAiSchemaInput(input.json_schema);
+  }
+  if (isRecord4(input.schema) && typeof input.name === "string") {
+    return {
+      name: input.name,
+      strict: typeof input.strict === "boolean" ? input.strict : null,
+      rootSchema: input.schema,
+      parseErrors: []
+    };
+  }
+  if (typeof input.type === "string" || Array.isArray(input.type) || input.properties || input.items) {
+    const name = typeof input.name === "string" ? input.name : typeof input.title === "string" ? input.title : null;
+    return {
+      name,
+      strict: typeof input.strict === "boolean" ? input.strict : null,
+      rootSchema: input,
+      parseErrors: []
+    };
+  }
+  parseErrors.push(
+    "Expected OpenAI output_schema shape { name, schema } or a root JSON Schema object."
+  );
+  return { name: null, strict: null, rootSchema: null, parseErrors };
+}
+function convertAiSchemaToBlockFields(schemaName, rootSchema, strict) {
+  const ctx = {
+    schemaName,
+    problems: [],
+    droppedMetadata: [],
+    blockSchemas: [],
+    arrayBindings: []
+  };
+  ctx.droppedMetadata.push(...collectDropped(rootSchema, ""));
+  const rootAp = rootSchema.additionalProperties;
+  const rootIsOpen = rootAp === true || isRecord4(rootAp) && isAnyValueSchema(rootAp);
+  const properties = rootSchema.properties;
+  if (!isRecord4(properties) || rootIsOpen) {
+    const rootField = convertProperty("$root", rootSchema, false, "$root", ctx);
+    if (!rootField) {
+      ctx.problems.push({
+        severity: "error",
+        path: "",
+        message: "Root schema could not be converted (see problems above) \u2014 expected an object with properties, a scalar/array/json root, or an open object."
+      });
+      return emptyConversionResult(schemaName, strict, ctx);
+    }
+    ctx.blockSchemas.unshift({
+      slug: schemaName,
+      label: formatBlockLabel(schemaName),
+      fields: {},
+      root: rootField
+    });
+    return {
+      schemaName,
+      strict,
+      blockSchemas: ctx.blockSchemas,
+      problems: ctx.problems,
+      droppedMetadata: ctx.droppedMetadata
+    };
+  }
+  const required = new Set(
+    Array.isArray(rootSchema.required) ? rootSchema.required.filter((k) => typeof k === "string") : []
+  );
+  const convertedFields = {};
+  for (const [fieldName, fieldNode] of Object.entries(properties)) {
+    if (!isRecord4(fieldNode)) continue;
+    if (fieldName === KIND_KEY) continue;
+    const converted = convertProperty(
+      fieldName,
+      fieldNode,
+      required.has(fieldName),
+      fieldName,
+      ctx
+    );
+    if (converted) {
+      convertedFields[fieldName] = converted;
+    }
+  }
+  const rootHasKind = propNameIsBlockKind(properties) || required.has(KIND_KEY);
+  if (!rootHasKind) {
+    ctx.problems.push({
+      severity: "warning",
+      path: "",
+      message: `Root object needs __kind:"${schemaName}" at runtime (OPTION 1: server injects, OPTION 2: use agent schema with __kind).`
+    });
+  }
+  const rootDraft = {
+    slug: schemaName,
+    label: formatBlockLabel(schemaName),
+    fields: convertedFields
+  };
+  ctx.blockSchemas.unshift(rootDraft);
+  if (typeof rootSchema.additionalProperties === "boolean") {
+    ctx.droppedMetadata.push({
+      path: "",
+      dropped: { additionalProperties: rootSchema.additionalProperties }
+    });
+  }
+  if (strict) {
+    ctx.droppedMetadata.push({
+      path: "",
+      dropped: { strict }
+    });
+  }
+  return {
+    schemaName,
+    strict,
+    blockSchemas: ctx.blockSchemas,
+    problems: ctx.problems,
+    droppedMetadata: ctx.droppedMetadata
+  };
+}
+function emptyConversionResult(schemaName, strict, ctx) {
+  return {
+    schemaName,
+    strict,
+    blockSchemas: ctx.blockSchemas,
+    problems: ctx.problems,
+    droppedMetadata: ctx.droppedMetadata
+  };
+}
+function compareFieldSchemas(aiField, blockField, fieldName) {
+  const aiPresent = aiField !== void 0;
+  const blockPresent = blockField !== void 0;
+  const aiSummary = aiField ? fieldSchemaSummary(aiField) : null;
+  const blockSummary = blockField ? fieldSchemaSummary(blockField) : null;
+  if (aiPresent && blockPresent) {
+    if (aiSummary === blockSummary) {
+      return {
+        field: fieldName,
+        aiPresent,
+        blockPresent,
+        aiSummary,
+        blockSummary,
+        status: "match"
+      };
+    }
+    const aiRicher = aiField?.type === "enum" && blockField?.type === "string" || aiField?.type === "inline_object" && blockField?.type !== "inline_object";
+    const blockRicher = blockField?.type === "enum" && aiField?.type === "string" || blockField?.required && !aiField?.required;
+    return {
+      field: fieldName,
+      aiPresent,
+      blockPresent,
+      aiSummary,
+      blockSummary,
+      status: aiRicher ? "ai_richer" : blockRicher ? "block_richer" : "type_mismatch",
+      ...aiSummary !== blockSummary && {
+        detail: `${aiSummary} vs ${blockSummary}`
+      }
+    };
+  }
+  if (aiPresent) {
+    return {
+      field: fieldName,
+      aiPresent,
+      blockPresent,
+      aiSummary,
+      blockSummary,
+      status: "ai_only"
+    };
+  }
+  return {
+    field: fieldName,
+    aiPresent,
+    blockPresent,
+    aiSummary,
+    blockSummary,
+    status: "block_only"
+  };
+}
+function compareWithExistingKindSchema(convertedFields, existing) {
+  if (!existing) return [];
+  const allFields = /* @__PURE__ */ new Set([
+    ...Object.keys(convertedFields),
+    ...Object.keys(existing.fields)
+  ]);
+  return [...allFields].sort().map(
+    (field) => compareFieldSchemas(
+      convertedFields[field],
+      existing.fields[field],
+      field
+    )
+  );
+}
+function runSchemaConversion(input, existingSchemas) {
+  const normalized = normalizeAiSchemaInput(input);
+  if (!normalized.rootSchema || !normalized.name) {
+    return {
+      schemaName: normalized.name,
+      strict: normalized.strict,
+      blockSchemas: [],
+      agentSchemaWithKinds: null,
+      problems: [],
+      droppedMetadata: [],
+      comparisons: [],
+      parseErrors: normalized.parseErrors.length ? normalized.parseErrors : ["Schema name and root schema are required."]
+    };
+  }
+  const strict = normalized.strict ?? false;
+  const core = convertAiSchemaToBlockFields(
+    normalized.name,
+    normalized.rootSchema,
+    strict
+  );
+  const existing = existingSchemas[normalized.name] ?? null;
+  const rootDraft = core.blockSchemas[0];
+  const comparisons = rootDraft ? compareWithExistingKindSchema(rootDraft.fields, existing) : [];
+  const problems = [...core.problems];
+  if (!existing) {
+    problems.push({
+      severity: "info",
+      path: "",
+      message: `No existing block schema with slug "${normalized.name}".`
+    });
+  }
+  const agentSchemaWithKinds = buildAgentSchemaWithRenderBlockSupport(
+    input,
+    normalized.name,
+    collectArrayBindingsFromDrafts(core.blockSchemas, normalized.name),
+    strict
+  );
+  return {
+    ...core,
+    agentSchemaWithKinds,
+    comparisons,
+    problems,
+    parseErrors: []
+  };
+}
+function collectArrayBindingsFromDrafts(drafts, rootSlug) {
+  const root = drafts.find((d) => d.slug === rootSlug);
+  if (!root) return [];
+  const bindings = [];
+  for (const [fieldName, field] of Object.entries(root.fields)) {
+    if (field.type !== "array") continue;
+    for (const itemKind of field.itemKinds) {
+      bindings.push({ arrayField: fieldName, itemKindSlug: itemKind });
+    }
+  }
+  return bindings;
+}
+function validateBlockSchemaSavePlan(blockSchemas, existingSlugs, hasConversionErrors) {
+  const errors = [];
+  const normalizedExisting = new Set(
+    existingSlugs.map((s) => s.trim().toLowerCase())
+  );
+  const batchSlugs = /* @__PURE__ */ new Set();
+  const itemKindRefs = [];
+  for (const draft of blockSchemas) {
+    const slug = draft.slug.trim();
+    const normalized = slug.toLowerCase();
+    if (!slug) {
+      errors.push("Every block schema must have a non-empty slug.");
+      continue;
+    }
+    if (batchSlugs.has(normalized)) {
+      errors.push(`Duplicate slug in conversion batch: "${slug}".`);
+    }
+    batchSlugs.add(normalized);
+  }
+  const entries = blockSchemas.map((draft) => {
+    const existsInDb = normalizedExisting.has(draft.slug.trim().toLowerCase());
+    return {
+      draft,
+      existsInDb,
+      willSave: !existsInDb
+    };
+  });
+  for (const draft of blockSchemas) {
+    for (const [fieldName, field] of Object.entries(draft.fields)) {
+      if (field.type !== "array") continue;
+      for (const itemKind of field.itemKinds) {
+        const inBatch = batchSlugs.has(itemKind.trim().toLowerCase());
+        const inDb = normalizedExisting.has(itemKind.trim().toLowerCase());
+        const satisfied = inBatch || inDb;
+        itemKindRefs.push({
+          parentSlug: draft.slug,
+          field: fieldName,
+          itemKind,
+          satisfied,
+          source: inBatch ? "batch" : inDb ? "database" : "missing"
+        });
+        if (!satisfied) {
+          errors.push(
+            `"${draft.slug}".${fieldName} references itemKind "${itemKind}" \u2014 not in this batch and not in DB.`
+          );
+        }
+      }
+    }
+  }
+  const newCount = entries.filter((e) => e.willSave).length;
+  if (newCount === 0 && blockSchemas.length > 0) {
+    errors.push("All block schema slugs already exist in the database.");
+  }
+  if (hasConversionErrors) {
+    errors.push("Resolve conversion errors before saving.");
+  }
+  return {
+    entries,
+    itemKindRefs,
+    newCount,
+    canSave: errors.length === 0 && newCount > 0,
+    errors
+  };
+}
+function fieldsToDbPayload(fields) {
+  return JSON.parse(JSON.stringify(fields));
+}
+function isDuplicateBlockSlug(slug, entries) {
+  const normalized = slug.trim().toLowerCase();
+  return entries.some((e) => e.slug.trim().toLowerCase() === normalized);
+}
+
+// convert/kind-to-json-schema.ts
+function collectReferencedKinds(fields) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (kind) => {
+    if (!seen.has(kind)) {
+      seen.add(kind);
+      out.push(kind);
+    }
+  };
+  const visit = (field) => {
+    if (field.type === "object") {
+      add(field.kind);
+    } else if (field.type === "array") {
+      field.itemKinds.forEach(add);
+    } else if (field.type === "union") {
+      (field.kinds ?? []).forEach(add);
+    } else if (field.type === "inline_object") {
+      Object.values(field.fields).forEach(visit);
+    }
+  };
+  Object.values(fields).forEach(visit);
+  return out;
+}
+function collectSchemaReferencedKinds(schema) {
+  if (!schema.root) return collectReferencedKinds(schema.fields);
+  return collectReferencedKinds({ [ROOT_REF_FIELD]: schema.root });
+}
+var ROOT_REF_FIELD = "__root";
+function kindSchemaToJsonSchema(kind, resolve, options = {}) {
+  const strict = options.strict ?? false;
+  const injectKind = options.injectKind ?? true;
+  const rootSchema = resolve(kind);
+  if (!rootSchema) return null;
+  const visited = /* @__PURE__ */ new Set([kind]);
+  const defsOrder = [];
+  const resolvedDefs = /* @__PURE__ */ new Map();
+  const unresolved = [];
+  const queue = collectSchemaReferencedKinds(rootSchema);
+  while (queue.length > 0) {
+    const next = queue.shift();
+    if (visited.has(next)) continue;
+    visited.add(next);
+    defsOrder.push(next);
+    const schema = resolve(next);
+    if (!schema) {
+      unresolved.push(next);
+      continue;
+    }
+    resolvedDefs.set(next, schema);
+    queue.push(...collectSchemaReferencedKinds(schema));
+  }
+  const refFor = (slug) => slug === kind ? { $ref: "#" } : { $ref: `#/$defs/${slug}` };
+  const withNull = (type, nullable) => nullable ? [type, "null"] : type;
+  function fieldToJsonSchema(field) {
+    const node = fieldToJsonSchemaCore(field);
+    if (field.description !== void 0) node.description = field.description;
+    if (field.default !== void 0) node.default = field.default;
+    return node;
+  }
+  function fieldToJsonSchemaCore(field) {
+    switch (field.type) {
+      case "string":
+      case "boolean":
+        return { type: withNull(field.type, field.nullable) };
+      case "number":
+        return {
+          type: withNull("number", field.nullable),
+          ...!strict && field.min !== void 0 ? { minimum: field.min } : {},
+          ...!strict && field.max !== void 0 ? { maximum: field.max } : {},
+          ...!strict && field.step !== void 0 ? { multipleOf: field.step } : {}
+        };
+      case "json":
+        return {};
+      case "string[]": {
+        const items = field.values === void 0 ? { type: "string" } : field.open ? {
+          anyOf: [
+            { type: "string", enum: [...field.values] },
+            { type: "string" }
+          ]
+        } : { type: "string", enum: [...field.values] };
+        return { type: withNull("array", field.nullable), items };
+      }
+      case "number[]":
+      case "boolean[]":
+        return {
+          type: withNull("array", field.nullable),
+          items: { type: scalarArrayItemType(field.type) }
+        };
+      case "json[]":
+        return {
+          type: withNull("array", field.nullable),
+          items: {}
+        };
+      case "enum": {
+        if (!field.open) {
+          return {
+            type: withNull("string", field.nullable),
+            enum: [...field.values]
+          };
+        }
+        const variants = [
+          { type: "string", enum: [...field.values] },
+          { type: "string" }
+        ];
+        if (field.nullable) variants.push({ type: "null" });
+        return { anyOf: variants };
+      }
+      case "union": {
+        const variants = field.scalars.map((scalar) => ({
+          type: scalar
+        }));
+        for (const memberKind of field.kinds ?? []) {
+          variants.push(refFor(memberKind));
+        }
+        if (field.nullable) variants.push({ type: "null" });
+        return { anyOf: variants };
+      }
+      case "record":
+        return {
+          type: withNull("object", field.nullable),
+          additionalProperties: field.values === "json" ? true : { type: field.values }
+        };
+      case "inline_object": {
+        const properties = {};
+        const required = [];
+        for (const [name, child] of Object.entries(field.fields)) {
+          properties[name] = fieldToJsonSchema(child);
+          if (child.required) required.push(name);
+        }
+        return {
+          type: withNull("object", field.nullable),
+          properties,
+          required,
+          ...field.open ? { additionalProperties: true } : strict ? { additionalProperties: false } : {}
+        };
+      }
+      case "object":
+        return field.nullable ? { anyOf: [refFor(field.kind), { type: "null" }] } : refFor(field.kind);
+      case "array": {
+        const [soleItemKind] = field.itemKinds;
+        const items = field.itemKinds.length === 1 && soleItemKind !== void 0 ? refFor(soleItemKind) : { anyOf: field.itemKinds.map(refFor) };
+        return { type: withNull("array", field.nullable), items };
+      }
+    }
+  }
+  function kindObjectSchema(schema) {
+    if (schema.root) {
+      return fieldToJsonSchema(schema.root);
+    }
+    const properties = {};
+    const required = [];
+    for (const [name, field] of Object.entries(schema.fields)) {
+      properties[name] = fieldToJsonSchema(field);
+      if (field.required) required.push(name);
+    }
+    const node = {
+      type: "object",
+      properties,
+      required,
+      ...strict ? { additionalProperties: false } : {}
+    };
+    return injectKind ? injectKindIntoObjectSchema(node, schema.kind, strict) : node;
+  }
+  function unresolvedStub(slug) {
+    const node = {
+      type: "object",
+      description: `Unresolved kind "${slug}" \u2014 schema not available at export time.`
+    };
+    return injectKind ? injectKindIntoObjectSchema(node, slug, false) : node;
+  }
+  const rootNode = kindObjectSchema(rootSchema);
+  if (defsOrder.length === 0) {
+    return { name: kind, schema: rootNode, strict, unresolved };
+  }
+  const defs = {};
+  for (const slug of defsOrder) {
+    const schema = resolvedDefs.get(slug);
+    defs[slug] = schema ? kindObjectSchema(schema) : unresolvedStub(slug);
+  }
+  return { name: kind, schema: { ...rootNode, $defs: defs }, strict, unresolved };
+}
+
+// wire/partial-kind.ts
+var IR_PARTIAL_KEY = "__ir_partial";
+var PARTIAL_STATES = [
+  "partial",
+  "superseded",
+  "retracted"
+];
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readPath(value) {
+  if (!Array.isArray(value)) return null;
+  return value.every(
+    (segment) => typeof segment === "string" || typeof segment === "number"
+  ) ? value : null;
+}
+function readDiscriminator(value) {
+  if (!isRecord5(value)) return null;
+  if (value.format === "json" && value.key === "__kind") {
+    return { format: "json", key: "__kind" };
+  }
+  if (value.format === "xml" && typeof value.tag === "string") {
+    return { format: "xml", tag: value.tag };
+  }
+  if (value.format === "fence" && typeof value.language === "string") {
+    return { format: "fence", language: value.language };
+  }
+  return null;
+}
+function readResidue(value) {
+  if (value === null) return null;
+  if (!isRecord5(value)) return void 0;
+  const extra = value.extra;
+  const optionalMissing = value.optionalMissing;
+  const notices = value.notices;
+  if (extra !== null && !isRecord5(extra)) return void 0;
+  if (optionalMissing !== null && (!Array.isArray(optionalMissing) || !optionalMissing.every((item) => typeof item === "string"))) {
+    return void 0;
+  }
+  if (notices !== null && (!Array.isArray(notices) || !notices.every(
+    (notice) => isRecord5(notice) && typeof notice.code === "string" && typeof notice.message === "string" && (notice.at === void 0 || typeof notice.at === "number")
+  ))) {
+    return void 0;
+  }
+  return { extra, optionalMissing, notices };
+}
+function readPartialKindEvent(metadata) {
+  if (!isRecord5(metadata)) return null;
+  const candidate = metadata[IR_PARTIAL_KEY];
+  if (!isRecord5(candidate)) return null;
+  if (candidate.v !== IR_VERSION) return null;
+  if (typeof candidate.engine !== "string") return null;
+  if (typeof candidate.seq !== "number" || !Number.isFinite(candidate.seq)) {
+    return null;
+  }
+  const state = candidate.state;
+  if (typeof state !== "string") return null;
+  if (!PARTIAL_STATES.includes(state)) return null;
+  if (state === "partial") {
+    const root = candidate.root;
+    if (!isRecord5(root)) return null;
+    if (root.role !== "structured") return null;
+    if (root.status !== "streaming") return null;
+    if (root.kindState !== "speculative") return null;
+    if (typeof root.kind !== "string" || !root.kind) return null;
+    if (!isRecord5(root.value)) return null;
+    const discriminator = readDiscriminator(root.discriminator);
+    const path = readPath(root.path);
+    const residue = readResidue(root.residue);
+    if (discriminator === null || path === null || residue === void 0) {
+      return null;
+    }
+    return {
+      v: IR_VERSION,
+      engine: candidate.engine,
+      state: "partial",
+      seq: candidate.seq,
+      fingerprint: typeof candidate.fingerprint === "string" ? candidate.fingerprint : "",
+      root: {
+        role: "structured",
+        kind: root.kind,
+        kindState: "speculative",
+        discriminator,
+        path,
+        status: "streaming",
+        value: root.value,
+        residue
+      }
+    };
+  }
+  if (typeof candidate.kind !== "string" || !candidate.kind) return null;
+  if (state === "superseded") {
+    return {
+      v: IR_VERSION,
+      engine: candidate.engine,
+      state: "superseded",
+      seq: candidate.seq,
+      kind: candidate.kind
+    };
+  }
+  if (typeof candidate.reason !== "string" || !candidate.reason) return null;
+  if (candidate.becameKind !== null && typeof candidate.becameKind !== "string") {
+    return null;
+  }
+  if (candidate.becameBlockType !== null && typeof candidate.becameBlockType !== "string") {
+    return null;
+  }
+  return {
+    v: IR_VERSION,
+    engine: candidate.engine,
+    state: "retracted",
+    seq: candidate.seq,
+    kind: candidate.kind,
+    reason: candidate.reason,
+    becameKind: candidate.becameKind,
+    becameBlockType: candidate.becameBlockType
+  };
+}
+function sanitizeInboundPartialKindMetadata(metadata, context, hooks = {}) {
+  if (!isRecord5(metadata) || !(IR_PARTIAL_KEY in metadata)) {
+    return metadata ?? void 0;
+  }
+  if (readPartialKindEvent(metadata) !== null) return metadata;
+  const { [IR_PARTIAL_KEY]: raw, ...rest } = metadata;
+  hooks.reportMalformed?.({ blockId: context.blockId, raw });
+  return rest;
+}
+function isProvisionalKind(event) {
+  return event !== null && event.state === "partial";
+}
+function isTerminalKindEvent(event) {
+  return event !== null && (event.state === "superseded" || event.state === "retracted");
+}
+function advancePartialKind(seen, blockId, event) {
+  if (event === null) return null;
+  const last = seen[blockId];
+  if (last !== void 0 && event.seq <= last) return null;
+  return event;
+}
+function makePartialKindStalenessGate() {
+  const seen = {};
+  const lastAccepted = {};
+  const terminated = {};
+  return (blockId, metadata) => {
+    if (!isRecord5(metadata)) return metadata;
+    if (!(IR_PARTIAL_KEY in metadata)) {
+      const open = lastAccepted[blockId];
+      if (terminated[blockId] || open === void 0) return metadata;
+      return { ...metadata, [IR_PARTIAL_KEY]: open };
+    }
+    const parsed = readPartialKindEvent(metadata);
+    if (parsed === null) return metadata;
+    if (advancePartialKind(seen, blockId, parsed) !== null) {
+      seen[blockId] = parsed.seq;
+      lastAccepted[blockId] = metadata[IR_PARTIAL_KEY];
+      if (isTerminalKindEvent(parsed)) terminated[blockId] = true;
+      return metadata;
+    }
+    const carried = lastAccepted[blockId];
+    if (carried === void 0 || carried === metadata[IR_PARTIAL_KEY]) {
+      return metadata;
+    }
+    return { ...metadata, [IR_PARTIAL_KEY]: carried };
+  };
+}
+
+// wire/runtime-wrapper.ts
+var NODE_OUTCOME_KIND = "node_outcome";
+var RUN_RESULT_KIND = "run_result";
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str(source, key) {
+  const value = source[key];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function num(source, key) {
+  const value = source[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function bool(source, key) {
+  const value = source[key];
+  return typeof value === "boolean" ? value : null;
+}
+function strings(source, key) {
+  const value = source[key];
+  if (!Array.isArray(value)) return null;
+  const out = value.filter((item) => typeof item === "string");
+  return out.length > 0 ? out : null;
+}
+function readOutputRef(frame, ref) {
+  let cursor = frame;
+  for (const segment of ref.split(".")) {
+    if (!isRecord6(cursor)) return void 0;
+    if (!(segment in cursor)) return void 0;
+    cursor = cursor[segment];
+  }
+  return cursor;
+}
+function rehydrateNodeOutcome(raw, frame) {
+  if (!isRecord6(raw)) return null;
+  if (raw[KIND_KEY] !== NODE_OUTCOME_KIND) return null;
+  const ref = str(raw, "output_ref");
+  const resolved = ref === null ? void 0 : readOutputRef(frame, ref);
+  return readNodeOutcomeValue(
+    resolved === void 0 ? raw : { ...raw, output: resolved }
+  );
+}
+function readNodeOutcomeValue(raw) {
+  if (!isRecord6(raw)) return null;
+  const runId = str(raw, "run_id");
+  const nodeId = str(raw, "node_id");
+  if (!runId || !nodeId) return null;
+  const output = raw.output ?? null;
+  return {
+    __kind: NODE_OUTCOME_KIND,
+    run_id: runId,
+    node_id: nodeId,
+    workflow_id: str(raw, "workflow_id"),
+    step: num(raw, "step"),
+    attempt: num(raw, "attempt") ?? 1,
+    status: str(raw, "status") ?? "completed",
+    started_at: str(raw, "started_at"),
+    ended_at: str(raw, "ended_at"),
+    duration_ms: num(raw, "duration_ms"),
+    output_kind: str(raw, "output_kind"),
+    output_kind_ok: bool(raw, "output_kind_ok"),
+    output_kind_errors: strings(raw, "output_kind_errors"),
+    output
+  };
+}
+function rehydrateRunResult(raw, frame) {
+  if (!isRecord6(raw)) return null;
+  if (raw[KIND_KEY] !== RUN_RESULT_KIND) return null;
+  const ref = str(raw, "output_ref");
+  const resolved = ref === null ? void 0 : readOutputRef(frame, ref);
+  const outputs = Array.isArray(raw.outputs) ? raw.outputs.map((child) => rehydrateNodeOutcome(child, frame) ?? child) : [];
+  return readRunResultValue({
+    ...raw,
+    ...resolved === void 0 ? {} : { output: resolved },
+    outputs
+  });
+}
+function readRunResultValue(raw) {
+  if (!isRecord6(raw)) return null;
+  const runId = str(raw, "run_id");
+  if (!runId) return null;
+  const output = raw.output ?? null;
+  const outputs = Array.isArray(raw.outputs) ? raw.outputs.map((child) => readNodeOutcomeValue(child)).filter((child) => child !== null) : [];
+  return {
+    __kind: RUN_RESULT_KIND,
+    run_id: runId,
+    workflow_id: str(raw, "workflow_id"),
+    status: str(raw, "status") ?? "completed",
+    started_at: str(raw, "started_at"),
+    ended_at: str(raw, "ended_at"),
+    duration_ms: num(raw, "duration_ms"),
+    output_kind: str(raw, "output_kind"),
+    output,
+    outputs
+  };
+}
+function kindVerdictOf(wrapper) {
+  if (wrapper.output_kind_ok === true) return "passed";
+  if (wrapper.output_kind_ok === false) return "failed";
+  return "unchecked";
+}
+
+// wire/emit-payload.ts
+function withRootKind(kind, value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return { [KIND_KEY]: kind, ...value };
+  }
+  return value;
+}
+function emitPayloadJson(kind, value) {
+  return JSON.stringify(withRootKind(kind, value), null, 2);
+}
+function emitPayloadFence(kind, value) {
+  return "```json\n" + emitPayloadJson(kind, value) + "\n```";
+}
+
+exports.IR_ENVELOPE_CACHE_VERSION = IR_ENVELOPE_CACHE_VERSION;
+exports.IR_ENVELOPE_KEY = IR_ENVELOPE_KEY;
+exports.IR_PARTIAL_KEY = IR_PARTIAL_KEY;
+exports.IR_VERSION = IR_VERSION;
+exports.IrTree = IrTree;
+exports.JSON_DISCRIMINATOR = JSON_DISCRIMINATOR;
+exports.JsonStreamTokenizer = JsonStreamTokenizer;
+exports.KIND_KEY = KIND_KEY;
+exports.KindStorageError = KindStorageError;
+exports.KindStreamParser = KindStreamParser;
+exports.NODE_OUTCOME_KIND = NODE_OUTCOME_KIND;
+exports.ParseSession = ParseSession;
+exports.ROOT_STORAGE_NAME = ROOT_STORAGE_NAME;
+exports.RUN_RESULT_KIND = RUN_RESULT_KIND;
+exports.advancePartialKind = advancePartialKind;
+exports.buildAgentSchemaWithRenderBlockSupport = buildAgentSchemaWithRenderBlockSupport;
+exports.buildCompliantKindSnapshot = buildCompliantKindSnapshot;
+exports.classifyInboundEnvelopeMetadata = classifyInboundEnvelopeMetadata;
+exports.collectReferencedKinds = collectReferencedKinds;
+exports.collectSchemaReferencedKinds = collectSchemaReferencedKinds;
+exports.compareWithExistingKindSchema = compareWithExistingKindSchema;
+exports.convertAiSchemaToBlockFields = convertAiSchemaToBlockFields;
+exports.createFingerprinter = createFingerprinter;
+exports.createKindStreamParser = createKindStreamParser;
+exports.describeDualGateFailure = describeDualGateFailure;
+exports.disposeParseSession = disposeParseSession;
+exports.emitPayloadFence = emitPayloadFence;
+exports.emitPayloadJson = emitPayloadJson;
+exports.emptyValueForFieldSchema = emptyValueForFieldSchema;
+exports.envelopeCacheFromEnvelopes = envelopeCacheFromEnvelopes;
+exports.envelopeFromCompleteValue = envelopeFromCompleteValue;
+exports.fenceDiscriminator = fenceDiscriminator;
+exports.fieldsToDbPayload = fieldsToDbPayload;
+exports.fingerprintText = fingerprintText;
+exports.formatBlockLabel = formatBlockLabel;
+exports.getParseSession = getParseSession;
+exports.injectKindIntoObjectSchema = injectKindIntoObjectSchema;
+exports.irPathIsUnderOrEqual = irPathIsUnderOrEqual;
+exports.irPathKey = irPathKey;
+exports.irPathLabel = irPathLabel;
+exports.irPathsEqual = irPathsEqual;
+exports.isCanonicalBlockIR = isCanonicalBlockIR;
+exports.isDuplicateBlockSlug = isDuplicateBlockSlug;
+exports.isEmptyResidue = isEmptyResidue;
+exports.isIrEnvelopeCache = isIrEnvelopeCache;
+exports.isJsonAnyField = isJsonAnyField;
+exports.isProvisionalKind = isProvisionalKind;
+exports.isScalarArrayType = isScalarArrayType;
+exports.isTerminalKindEvent = isTerminalKindEvent;
+exports.kindSchemaToJsonSchema = kindSchemaToJsonSchema;
+exports.kindSchemaToStorage = kindSchemaToStorage;
+exports.kindVerdictOf = kindVerdictOf;
+exports.makePartialKindStalenessGate = makePartialKindStalenessGate;
+exports.mergeResidueIntoValue = mergeResidueIntoValue;
+exports.normalizeAiSchemaInput = normalizeAiSchemaInput;
+exports.normalizeJsonRegion = normalizeJsonRegion;
+exports.openParseSession = openParseSession;
+exports.readEnvelope = readEnvelope;
+exports.readNodeOutcomeValue = readNodeOutcomeValue;
+exports.readObjectKind = readObjectKind;
+exports.readOutputRef = readOutputRef;
+exports.readPartialKindEvent = readPartialKindEvent;
+exports.readRunResultValue = readRunResultValue;
+exports.reconstructRegionValue = reconstructRegionValue;
+exports.rehydrateNodeOutcome = rehydrateNodeOutcome;
+exports.rehydrateRunResult = rehydrateRunResult;
+exports.reuseEnvelopeIfCurrent = reuseEnvelopeIfCurrent;
+exports.runKindDualGate = runKindDualGate;
+exports.runSchemaConversion = runSchemaConversion;
+exports.sanitizeInboundEnvelopeMetadata = sanitizeInboundEnvelopeMetadata;
+exports.sanitizeInboundPartialKindMetadata = sanitizeInboundPartialKindMetadata;
+exports.scalarArrayItemType = scalarArrayItemType;
+exports.schemaLayoutMode = schemaLayoutMode;
+exports.schemaStructureDepth = schemaStructureDepth;
+exports.setJsonRootKeyLookup = setJsonRootKeyLookup;
+exports.storageToKindSchema = storageToKindSchema;
+exports.stripKindDeep = stripKindDeep;
+exports.validateBlockSchemaSavePlan = validateBlockSchemaSavePlan;
+exports.validateStructuralLeg = validateStructuralLeg;
+exports.withRootKind = withRootKind;
+exports.xmlDiscriminator = xmlDiscriminator;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map