@ai-matrx/content-ir-react 0.12.7 → 0.13.1

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## 0.13.1 — 2026-09-30
+
+- **The settling ingest notifies once.** In 0.13.0 the first `ingestDbRows`
+  that settled the tier bumped the ingested kinds AND the epoch, so their
+  listeners (and `subscribe` listeners) fired twice. A settling ingest now
+  notifies every listener exactly once; later ingests stay per-kind.
+
+### Consumer action
+
+- None required. Host tests that assert "ingest reaches only the ingested
+  kinds" must start from a SETTLED tier — the ingest that settles it reaches
+  every kind by design (0.13.0).
+
+## 0.13.0 — 2026-09-30
+
+- **Settling repaints every block that waited on it.** THE COLD-VERDICT RULE
+  holds a block whose kind the resolver cannot answer while its tier is
+  unsettled. `ensureWarm` settling (a landed list, empty or not, or retries
+  exhausted) and the first `ingestDbRows` that settles the tier now bump the
+  epoch and call EVERY per-kind listener. Before, only kinds that gained rows
+  were told, so a waiting block for any other kind kept its pre-settle
+  rendering (raw JSON in hosts that drew it) until something unrelated
+  re-rendered it.
+- **A single-kind fetch always answers its waiters.** `requestComponent` now
+  bumps that kind when its fetch misses or fails too (a landing already did).
+
+### Consumer action
+
+- A host that holds a completed block on a loader while `hasSettled()` is
+  false may now rely on the per-kind repaint (`subscribeKind` /
+  `getKindVersion`) to release it — no polling, no timer.
+
 ## 0.12.7
 
 Automatic changed-only republish (docs/metadata drift since the last tag — see

package/dist/index.cjs

@@ -268,6 +268,7 @@ var ComponentResolver = class {
    * key wins: rows arrive is_default-first / sort_order-asc from the source.
    */
   ingestDbRows(rows) {
+    const wasSettled = this.hasSettled();
     const changedKinds = /* @__PURE__ */ new Set();
     for (const row of rows) {
       const key = keyOf(row.kind, row.platform, row.role);
@@ -276,11 +277,35 @@ var ComponentResolver = class {
         changedKinds.add(row.kind);
       }
     }
+    if (!wasSettled && this.hasSettled()) {
+      this.notifySettled();
+      return;
+    }
     if (changedKinds.size > 0) {
       for (const kind of changedKinds) this.bumpKind(kind);
       this.notifyChanged();
     }
   }
+  /**
+   * Mark the tier settled. THE COLD-VERDICT RULE held every block whose kind
+   * the tier could not answer; settling changes that verdict for ALL of them,
+   * so the flip bumps the epoch and calls every per-kind listener (as a
+   * wholesale replace does). Before 0.13.0 a settle notified only kinds that
+   * gained rows, and a waiting block for any other kind kept its pre-settle
+   * rendering until something unrelated re-rendered it.
+   */
+  markSettled() {
+    const wasSettled = this.hasSettled();
+    this.settled = true;
+    if (!wasSettled) this.notifySettled();
+  }
+  notifySettled() {
+    this.epoch += 1;
+    for (const set of this.kindListeners.values()) {
+      for (const listener of set) listener();
+    }
+    this.notifyChanged();
+  }
   /**
    * Refresh landing point: REPLACE the db tier wholesale (same
    * first-row-per-key contract as {@link ingestDbRows}) so edits, deletions,
@@ -376,6 +401,7 @@ var ComponentResolver = class {
       return;
     }
     this.coldInFlight.add(flightKey);
+    const versionBefore = this.kindVersions.get(kind) ?? 0;
     void (async () => {
       try {
         this.ingestColdRows(await loadForKind(kind, platform));
@@ -391,6 +417,9 @@ var ComponentResolver = class {
         });
       } finally {
         this.coldInFlight.delete(flightKey);
+        if ((this.kindVersions.get(kind) ?? 0) === versionBefore) {
+          this.bumpKind(kind);
+        }
       }
     })();
   }
@@ -432,7 +461,7 @@ var ComponentResolver = class {
     if (!this.warmPromise) {
       this.warmPromise = loadAll().then((rows) => {
         this.ingestDbRows(rows);
-        this.settled = true;
+        this.markSettled();
         this.warmFailures = 0;
         if (this.warmRetryTimer) {
           clearTimeout(this.warmRetryTimer);
@@ -450,7 +479,7 @@ var ComponentResolver = class {
         this.warmFailures += 1;
         const delay = WARM_RETRY_DELAYS_MS[this.warmFailures - 1] ?? null;
         if (delay === null) {
-          this.settled = true;
+          this.markSettled();
         } else if (!this.warmRetryTimer) {
           this.warmRetryTimer = setTimeout(() => {
             this.warmRetryTimer = null;