@remnic/core 9.48.1 → 9.49.0

package/dist/{chunk-PLCZD3LG.js → chunk-EY64JLOM.js}

@@ -27,6 +27,10 @@ import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier
 } from "./chunk-3S63QIFQ.js";
+import {
+  normalizeProjectionPreview,
+  normalizeProjectionTags
+} from "./chunk-SCU65EZI.js";
 import {
   rewriteProjectedEntityReferences,
   rewriteProjectedMemoryEntityReference
@@ -34,10 +38,6 @@ import {
 import {
   createMemorySnapshot
 } from "./chunk-S2HLHAZ4.js";
-import {
-  normalizeProjectionPreview,
-  normalizeProjectionTags
-} from "./chunk-SCU65EZI.js";
 import {
   rotateMarkdownFileToArchive
 } from "./chunk-DM2T26WE.js";
@@ -74,20 +74,23 @@ import {
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
+import {
+  checkCorpusReadAbort
+} from "./chunk-5GINB5LC.js";
 import {
   isConsolidationOperator,
   isValidDerivedFromEntry
 } from "./chunk-G7D6GZ5J.js";
 import {
   createVersion
-} from "./chunk-7YKVM5H3.js";
+} from "./chunk-RHTO4HTL.js";
 import {
+  attachInFlightReader,
+  beginCoalescedScan,
   clearInFlightReads,
   deleteInFlightRead,
-  deleteInFlightReadsForDir,
-  getInFlightRead,
-  setInFlightRead
-} from "./chunk-PDJTHRAW.js";
+  deleteInFlightReadsForDir
+} from "./chunk-RBOJCG4T.js";
 import {
   ENTITY_CANONICAL_ID_MIGRATION_FILE,
   ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER,
@@ -190,6 +193,10 @@ import {
 import {
   resolveNamespaceCapabilities
 } from "./chunk-2XRE6FLM.js";
+import {
+  isAbortError,
+  raceAbort
+} from "./chunk-BTTPKDIL.js";
 import {
   isPathInsideStorageRoot
 } from "./chunk-FF4KLI5W.js";
@@ -299,7 +306,8 @@ var MemoryReadStore = class {
     });
     return days;
   }
-  async readAllArtifactsCached() {
+  async readAllArtifactsCached(options) {
+    checkCorpusReadAbort(options);
     if (this.deps.artifactIndexCache && Date.now() - this.deps.artifactIndexCache.loadedAtMs <= this.deps.storageManagerClass.ARTIFACT_INDEX_CACHE_TTL_MS && this.deps.artifactIndexCache.writeVersion === this.deps.getArtifactWriteVersion()) {
       return this.deps.artifactIndexCache.memories;
     }
@@ -309,6 +317,7 @@ var MemoryReadStore = class {
         try {
           const entries = await readdir(dir, { withFileTypes: true });
           for (const entry of entries) {
+            checkCorpusReadAbort(options);
             const fullPath = path.join(dir, entry.name);
             if (entry.isDirectory()) {
               await readDir(fullPath);
@@ -319,7 +328,8 @@ var MemoryReadStore = class {
             if (!memory) continue;
             artifacts.push(memory);
           }
-        } catch {
+        } catch (err) {
+          if (isAbortError(err)) throw err;
         }
       };
       await readDir(this.deps.artifactsDir);
@@ -328,10 +338,12 @@ var MemoryReadStore = class {
     const MAX_REBUILD_RETRIES = 2;
     let latestArtifacts = [];
     for (let attempt = 0; attempt <= MAX_REBUILD_RETRIES; attempt += 1) {
+      checkCorpusReadAbort(options);
       const versionBefore = this.deps.getArtifactWriteVersion();
       const artifacts = await scanArtifacts();
       const versionAfter = this.deps.getArtifactWriteVersion();
       latestArtifacts = artifacts;
+      checkCorpusReadAbort(options);
       if (versionAfter === versionBefore) {
         this.deps.artifactIndexCache = { memories: artifacts, loadedAtMs: Date.now(), writeVersion: versionAfter };
         return artifacts;
@@ -348,7 +360,7 @@ var MemoryReadStore = class {
    * consolidation-provenance-check.ts; reuses the shared containment helper.
    * Paths only — no frontmatter parse.
    */
-  async collectContainedMarkdownPaths(startDirs, propagateReadErrors = false) {
+  async collectContainedMarkdownPaths(startDirs, propagateReadErrors = false, options) {
     const filePaths = [];
     let memoryRootReal;
     try {
@@ -358,6 +370,7 @@ var MemoryReadStore = class {
       return filePaths;
     }
     const collectPaths = async (dir) => {
+      checkCorpusReadAbort(options);
       let dirStat;
       try {
         dirStat = await lstat(dir);
@@ -382,6 +395,7 @@ var MemoryReadStore = class {
       }
       const subdirs = [];
       for (const entry of entries) {
+        checkCorpusReadAbort(options);
         if (entry.isSymbolicLink()) continue;
         const fullPath = path.join(dir, entry.name);
         if (entry.isDirectory()) {
@@ -402,12 +416,14 @@ var MemoryReadStore = class {
     for (const dir of startDirs) {
       await collectPaths(dir);
     }
+    checkCorpusReadAbort(options);
     return filePaths;
   }
   async collectActiveMemoryPaths(options) {
     return this.collectContainedMarkdownPaths(
       RECALL_FALLBACK_DIRS.map((dir) => path.join(this.deps.baseDir, dir)),
-      options?.propagateReadErrors ?? false
+      options?.propagateReadErrors ?? false,
+      options
     );
   }
   /**
@@ -422,7 +438,8 @@ var MemoryReadStore = class {
   async collectColdMemoryPaths(options) {
     return this.collectContainedMarkdownPaths(
       [this.deps.resolveTierRootDir("cold")],
-      options?.propagateReadErrors ?? false
+      options?.propagateReadErrors ?? false,
+      options
     );
   }
   async readMemoriesWindow(options = {}) {
@@ -1727,7 +1744,8 @@ var EntityStore = class {
    * Read all entity files and return lightweight EntityFile objects.
    * Parsing is fast (~50-100ms for ~1,800 files) since entity files are small.
    */
-  async readAllEntityFiles() {
+  async readAllEntityFiles(options) {
+    checkCorpusReadAbort(options);
     const currentVersion = this.deps.getMemoryStatusVersion();
     const cacheKey = [
       this.deps.getEntityCacheSecureStoreKey(),
@@ -1743,6 +1761,7 @@ var EntityStore = class {
       const BATCH_SIZE = 100;
       const entities = [];
       for (let i = 0; i < mdFiles.length; i += BATCH_SIZE) {
+        checkCorpusReadAbort(options);
         const batch = mdFiles.slice(i, i + BATCH_SIZE);
         const results = await Promise.all(
           batch.map(async (entry) => {
@@ -1759,6 +1778,7 @@ var EntityStore = class {
           if (content !== null) entities.push(parseEntityFile(content, this.deps.entitySchemas));
         }
       }
+      checkCorpusReadAbort(options);
       setCachedEntities(this.deps.baseDir, entities, currentVersion, cacheKey);
       return entities;
     } catch (err) {
@@ -8524,12 +8544,12 @@ ${sanitized.text}
     this.artifactIndexCache = null;
     return id;
   }
-  async readAllArtifactsCached() {
-    return this.memoryReadStore.readAllArtifactsCached();
+  async readAllArtifactsCached(options) {
+    return this.memoryReadStore.readAllArtifactsCached(options);
   }
   async searchArtifacts(query, maxResults, options = {}) {
     return selectArtifactMatches(
-      () => this.readAllArtifactsCached(),
+      () => this.readAllArtifactsCached({ abortSignal: options.abortSignal }),
       query,
       maxResults,
       options
@@ -8613,7 +8633,8 @@ ${sanitized.text}
     for (const memory of memories) this.rememberMemorySnapshot(memory);
     return memories;
   }
-  async readAllMemories() {
+  async readAllMemories(options) {
+    checkCorpusReadAbort(options);
     if (this.hotMemoriesCacheEnabled) {
       const cached = getCachedMemories(
         this.baseDir,
@@ -8624,20 +8645,32 @@ ${sanitized.text}
       if (cached !== null) return this.rememberMemorySnapshots(cached);
     }
     const keyId = this.hotCacheKeyId();
-    const inFlight = getInFlightRead(this.baseDir, keyId);
-    if (inFlight) return this.rememberMemorySnapshots(await inFlight);
+    const inFlight = attachInFlightReader(this.baseDir, keyId, options?.abortSignal);
+    if (inFlight) {
+      try {
+        return this.rememberMemorySnapshots(
+          await raceAbort(inFlight.read, options?.abortSignal, "corpus read aborted")
+        );
+      } finally {
+        inFlight.waiter.leave();
+      }
+    }
+    const scan = beginCoalescedScan(this.baseDir, keyId, options?.abortSignal);
     const readPromise = (async () => {
       const version = this.getMemoryCorpusVersion();
-      const memories = await this._readAllMemoriesFromDisk();
+      const memories = await this._readAllMemoriesFromDisk({ abortSignal: scan.scanSignal });
       if (this.hotMemoriesCacheEnabled && this.getMemoryCorpusVersion() === version && this.hotCacheKeyId() === keyId) {
         setCachedMemories(this.baseDir, memories, version, keyId, this.hotCacheTtlMs());
       }
       return memories;
     })();
-    setInFlightRead(this.baseDir, keyId, readPromise);
+    scan.arm(readPromise);
     try {
-      return this.rememberMemorySnapshots(await readPromise);
+      return this.rememberMemorySnapshots(
+        await raceAbort(readPromise, options?.abortSignal, "corpus read aborted")
+      );
     } finally {
+      scan.leave();
       deleteInFlightRead(this.baseDir, keyId, readPromise);
     }
   }
@@ -8821,11 +8854,12 @@ ${sanitized.text}
   getCorpusScanVersion() {
     return `${this.getMemoryCorpusVersion()}:${this.readColdWriteVersion()}`;
   }
-  async readParsedMemoriesFromPaths(filePaths, batchSize) {
+  async readParsedMemoriesFromPaths(filePaths, batchSize, options) {
     if (filePaths.length === 0) return [];
     const normalizedBatchSize = this.normalizeMemoryReadBatchSize(batchSize);
     const memories = [];
     for (let i = 0; i < filePaths.length; i += normalizedBatchSize) {
+      checkCorpusReadAbort(options);
       const batch = filePaths.slice(i, i + normalizedBatchSize);
       const results = await Promise.all(
         batch.map(async (fullPath) => {
@@ -8855,6 +8889,7 @@ ${sanitized.text}
         if (memory !== null) memories.push(memory);
       }
     }
+    checkCorpusReadAbort(options);
     return memories;
   }
   async readWindowUpdatedMs(filePath) {
@@ -8936,9 +8971,9 @@ ${sanitized.text}
   async readMemoriesWindow(options = {}) {
     return this.memoryReadStore.readMemoriesWindow(options);
   }
-  async _readAllMemoriesFromDisk() {
-    const filePaths = await this.collectActiveMemoryPaths();
-    return this.readParsedMemoriesFromPaths(filePaths, 50);
+  async _readAllMemoriesFromDisk(options) {
+    const filePaths = await this.collectActiveMemoryPaths(options);
+    return this.readParsedMemoriesFromPaths(filePaths, 50, options);
   }
   async readAllColdMemories() {
     return this.rememberMemorySnapshots(await this.memoryReadStore.readAllColdMemories());
@@ -10127,8 +10162,8 @@ ${reflection}
   // ---------------------------------------------------------------------------
   // Scoring + Knowledge Index (Knowledge Graph v7.0)
   // ---------------------------------------------------------------------------
-  async readAllEntityFiles() {
-    return this.entityStore.readAllEntityFiles();
+  async readAllEntityFiles(options) {
+    return this.entityStore.readAllEntityFiles(options);
   }
   /**
    * Score an entity based on recency, frequency, activity, type priority,
@@ -10804,4 +10839,4 @@ export {
   isValidBufferSurpriseEvent,
   StorageManager3 as StorageManager
 };
-//# sourceMappingURL=chunk-PLCZD3LG.js.map
+//# sourceMappingURL=chunk-EY64JLOM.js.map