@ai-matrx/content-ir-react 0.4.0 → 0.5.1

package/dist/index.d.ts

@@ -70,6 +70,13 @@ interface KindComponentRow {
     isActive: boolean;
     componentSource: string | null;
     propsTransform: string | null;
+    /**
+     * Whether the row carries a real `component_source` body — supplied by the
+     * host when its warm list is BODY-LESS (the lazy design: metadata travels
+     * on the list, the body arrives per kind via the cold fetch). Omitted →
+     * derived from `componentSource` itself, so eager hosts change nothing.
+     */
+    hasComponentSource?: boolean;
     pinnedKindVersion: number | null;
     updatedAt: string | null;
     createdBy: string | null;
@@ -101,6 +108,14 @@ interface ComponentResolution {
     resolvedBy: "compiled" | "db";
     componentSource: string | null;
     propsTransform: string | null;
+    /**
+     * TRUE when the row owns a real component body — even if `componentSource`
+     * is null because the host's warm list is body-less and the cold fetch has
+     * not landed it yet. THE routing gate: `routeToDbComponent` re-types on
+     * this flag, never on body presence, so a body-less row still routes and
+     * the renderer fetches/compiles the body lazily.
+     */
+    hasComponentSource: boolean;
     pinnedKindVersion: number | null;
     /** The db row's `updated_at` — the compile-cache staleness key. */
     updatedAt: string | null;
@@ -366,6 +381,18 @@ declare class ComponentResolver implements ComponentResolutionSource {
     subscribe(listener: () => void): () => void;
     private bumpKind;
     private notifyChanged;
+    /**
+     * A warm metadata shell is resolved enough for routing, but not for the
+     * host's db-component renderer. Its body must still come from the cold
+     * single-kind loader.
+     */
+    private needsColdFetch;
+    /**
+     * Cold rows are the authoritative heavy form of warm metadata shells. Keep
+     * the same first-row-per-key winner contract, but replace an existing shell
+     * so `componentSource` / `propsTransform` can land and repaint the kind.
+     */
+    private ingestColdRows;
     /**
      * The eager lightweight single-kind fetch (streaming path): the moment a
      * cloud kind is identified mid-stream, pull ONLY that kind's resolver rows

package/dist/index.js

@@ -120,6 +120,7 @@ var ComponentResolver = class {
         resolvedBy: "db",
         componentSource: dbRow.componentSource,
         propsTransform: dbRow.propsTransform,
+        hasComponentSource: dbRow.hasComponentSource ?? Boolean(dbRow.componentSource && dbRow.componentSource.trim()),
         pinnedKindVersion: dbRow.pinnedKindVersion,
         updatedAt: dbRow.updatedAt,
         createdBy: dbRow.createdBy
@@ -136,6 +137,7 @@ var ComponentResolver = class {
         resolvedBy: "compiled",
         componentSource: null,
         propsTransform: null,
+        hasComponentSource: false,
         pinnedKindVersion: null,
         updatedAt: null,
         createdBy: null
@@ -213,6 +215,35 @@ var ComponentResolver = class {
     this.version += 1;
     for (const listener of this.listeners) listener();
   }
+  /**
+   * A warm metadata shell is resolved enough for routing, but not for the
+   * host's db-component renderer. Its body must still come from the cold
+   * single-kind loader.
+   */
+  needsColdFetch(kind, platform, role) {
+    const resolution = this.resolve(kind, platform, role);
+    return resolution === null || resolution.resolvedBy === "db" && resolution.hasComponentSource && resolution.componentSource === null;
+  }
+  /**
+   * Cold rows are the authoritative heavy form of warm metadata shells. Keep
+   * the same first-row-per-key winner contract, but replace an existing shell
+   * so `componentSource` / `propsTransform` can land and repaint the kind.
+   */
+  ingestColdRows(rows) {
+    const winners = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const key = keyOf(row.kind, row.platform, row.role);
+      if (!winners.has(key)) winners.set(key, row);
+    }
+    if (winners.size === 0) return;
+    const changedKinds = /* @__PURE__ */ new Set();
+    for (const [key, row] of winners) {
+      this.db.set(key, row);
+      changedKinds.add(row.kind);
+    }
+    for (const kind of changedKinds) this.bumpKind(kind);
+    this.notifyChanged();
+  }
   /**
    * The eager lightweight single-kind fetch (streaming path): the moment a
    * cloud kind is identified mid-stream, pull ONLY that kind's resolver rows
@@ -223,7 +254,7 @@ var ComponentResolver = class {
   requestComponent(kind, platform, role) {
     const loadForKind = this.options.loadForKind;
     if (!loadForKind) return;
-    if (this.resolve(kind, platform, role)) return;
+    if (!this.needsColdFetch(kind, platform, role)) return;
     const missKey = keyOf(kind, platform, role);
     const flightKey = `${kind}${KEY_SEPARATOR}${platform}`;
     if (this.coldInFlight.has(flightKey) || this.coldMisses.has(missKey)) {
@@ -232,8 +263,10 @@ var ComponentResolver = class {
     this.coldInFlight.add(flightKey);
     void (async () => {
       try {
-        this.ingestDbRows(await loadForKind(kind, platform));
-        if (!this.resolve(kind, platform, role)) this.coldMisses.add(missKey);
+        this.ingestColdRows(await loadForKind(kind, platform));
+        if (this.needsColdFetch(kind, platform, role)) {
+          this.coldMisses.add(missKey);
+        }
       } catch (error) {
         this.reportError({
           source: "content-ir",
@@ -322,7 +355,7 @@ function resetSourcelessDbRowReports() {
 }
 function routeToDbComponent(block, kind, resolution, env) {
   if (!isDbSourceResolution(resolution)) return null;
-  if (!resolution.componentSource || !resolution.componentSource.trim()) {
+  if (!resolution.hasComponentSource) {
     reportDbRowWithoutSource(kind, env);
     return null;
   }