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

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.5.1 — 2026-08-29
+
+- **Body-less warm rows now complete through the canonical cold fetch.**
+  `requestComponent` treats a DB resolution with `hasComponentSource=true`
+  and `componentSource=null` as incomplete, fetches that kind once, replaces
+  the metadata shell with the heavy row, and bumps the per-kind repaint
+  version. Hosts no longer need resolver logic to make lazy component bodies
+  arrive.
+
+## 0.5.0 — 2026-08-29
+
+- **`hasComponentSource` — the seam that lets component BODIES load lazily.**
+  `KindComponentRow` gains optional `hasComponentSource` (a host whose warm
+  list is body-less supplies it; omitted → derived from `componentSource`,
+  so eager hosts change nothing) and `ComponentResolution` carries it
+  computed. `routeToDbComponent` now gates on the FLAG, never on body
+  presence: a body-less row from a lazy warm list still routes to
+  `db_kind_component`, and the renderer fetches/compiles the body per kind
+  on demand. A row that truly has no body screams and falls through exactly
+  as before. Pinned by a new kind-route test.
+
 ## 0.4.0 — 2026-08-29
 
 - **NO EXCEPTIONS for a root `__kind` (Arman's ruling, 2026-08-29).** The

package/dist/index.cjs

@@ -126,6 +126,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
@@ -142,6 +143,7 @@ var ComponentResolver = class {
         resolvedBy: "compiled",
         componentSource: null,
         propsTransform: null,
+        hasComponentSource: false,
         pinnedKindVersion: null,
         updatedAt: null,
         createdBy: null
@@ -219,6 +221,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
@@ -229,7 +260,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)) {
@@ -238,8 +269,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",
@@ -328,7 +361,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;
   }