@soulcraft/cor 3.0.5 → 3.0.6

package/dist/graph/NativeGraphAdjacencyIndex.d.ts

@@ -217,12 +217,21 @@ export declare class GraphAdjacencyIndex implements GraphIndexProvider {
     isHealthy(): boolean;
     /**
      * Whether the graph's edges are loaded and queryable WITHOUT a rebuild —
-     * brainy 8.0's rebuild gate (#36). Delegates straight to the native
-     * edges-ready latch (set on SSTable cold-load, a non-empty manifest, or a
-     * memtable flush) ORed with a live non-empty memtable. Synchronous (no
-     * await) and **never gated on the verb-id membership walk**, so the
-     * deferred O(N) membership fast-follow can never depress readiness for a
-     * graph whose edges are already mapped in.
+     * brainy 8.0's rebuild gate (#36). Synchronous (no await) and **never gated
+     * on the verb-id membership walk**, so the deferred O(N) membership fast-follow
+     * can never depress readiness for a graph whose edges are already mapped in.
+     *
+     * The native `is_ready()` latch fires only when EDGES load (SSTable cold-load,
+     * a non-empty manifest, or a memtable flush). That latch is never set for an
+     * **edgeless** brain (entities but no relationships — a very common shape:
+     * per-user brains, catalogs, CMS content), so a naive delegate reported
+     * `false` and made brainy spuriously rebuild the graph on every boot — which
+     * cascades into an id-mapper hydration + a full metadata rebuild (the observed
+     * multi-minute boot / 502 window). An edgeless graph is trivially ready: a
+     * rebuild would reconstruct zero edges. So once cold-load has run
+     * ({@link initialized}) we also report ready when the durable graph stores are
+     * genuinely EMPTY — distinguished from "edges exist on disk but didn't load"
+     * (which must still rebuild) via the persisted SSTable + memtable counts.
      */
     isReady(): boolean;
     /**

package/dist/graph/NativeGraphAdjacencyIndex.js

@@ -497,15 +497,38 @@ export class GraphAdjacencyIndex {
     }
     /**
      * Whether the graph's edges are loaded and queryable WITHOUT a rebuild —
-     * brainy 8.0's rebuild gate (#36). Delegates straight to the native
-     * edges-ready latch (set on SSTable cold-load, a non-empty manifest, or a
-     * memtable flush) ORed with a live non-empty memtable. Synchronous (no
-     * await) and **never gated on the verb-id membership walk**, so the
-     * deferred O(N) membership fast-follow can never depress readiness for a
-     * graph whose edges are already mapped in.
+     * brainy 8.0's rebuild gate (#36). Synchronous (no await) and **never gated
+     * on the verb-id membership walk**, so the deferred O(N) membership fast-follow
+     * can never depress readiness for a graph whose edges are already mapped in.
+     *
+     * The native `is_ready()` latch fires only when EDGES load (SSTable cold-load,
+     * a non-empty manifest, or a memtable flush). That latch is never set for an
+     * **edgeless** brain (entities but no relationships — a very common shape:
+     * per-user brains, catalogs, CMS content), so a naive delegate reported
+     * `false` and made brainy spuriously rebuild the graph on every boot — which
+     * cascades into an id-mapper hydration + a full metadata rebuild (the observed
+     * multi-minute boot / 502 window). An edgeless graph is trivially ready: a
+     * rebuild would reconstruct zero edges. So once cold-load has run
+     * ({@link initialized}) we also report ready when the durable graph stores are
+     * genuinely EMPTY — distinguished from "edges exist on disk but didn't load"
+     * (which must still rebuild) via the persisted SSTable + memtable counts.
      */
     isReady() {
-        return this.native.isReady();
+        if (this.native.isReady())
+            return true;
+        if (!this.initialized)
+            return false;
+        // Cold-load has run but the edges-ready latch is unset. Ready ⇔ there is
+        // nothing durable to load: no SSTables and empty memtables on either the
+        // source or target tree. If any durable edges exist but didn't load, this
+        // is false and brainy correctly rebuilds.
+        const raw = this.native.getStats();
+        const s = typeof raw === 'string' ? JSON.parse(raw) : raw;
+        const durableEmpty = Number(s?.sourceSstableCount ?? 0) === 0 &&
+            Number(s?.targetSstableCount ?? 0) === 0 &&
+            Number(s?.sourceMemTableSize ?? 0) === 0 &&
+            Number(s?.targetMemTableSize ?? 0) === 0;
+        return durableEmpty;
     }
     /**
      * @description **#18 migration lock — feature-detected by Brainy.** `true` while

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/cor",
-  "version": "3.0.5",
+  "version": "3.0.6",
   "description": "Native Rust acceleration for Brainy \u2014 SIMD distance, vector quantization, zero-copy mmap, native embeddings. Free tier for storage, Pro license for compute acceleration.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",