@remnic/core 10.0.2 → 10.0.4

package/dist/{chunk-LHOIYLKH.js → chunk-ABET5LA5.js}

@@ -1,3 +1,9 @@
+import {
+  TombstoneStore,
+  applyTombstoneResurrectionGate,
+  buildRetiredFactTombstoneInputs,
+  collectRetiredMemoriesForRebuild
+} from "./chunk-46WM6JX2.js";
 import {
   WEARABLES_DIR_NAME,
   escapeSegmentText,
@@ -9,15 +15,9 @@ import {
   unescapeSegmentText,
   unescapeSpeakerLabel
 } from "./chunk-UHVXE24Y.js";
-import {
-  TombstoneStore,
-  applyTombstoneResurrectionGate,
-  buildRetiredFactTombstoneInputs,
-  collectRetiredMemoriesForRebuild
-} from "./chunk-46WM6JX2.js";
 import {
   normalizeQmdResultPath
-} from "./chunk-GUD6FYQG.js";
+} from "./chunk-R4O2G6ML.js";
 import {
   withholdToolScopedFromSharedNamespace
 } from "./chunk-S2V7RUCL.js";
@@ -64,7 +64,7 @@ import {
   parseTombstoneBlockedOfflineSyncMemory,
   tombstoneBlocked,
   withCasCommitReceipt
-} from "./chunk-6O2VUWV6.js";
+} from "./chunk-EIFYYHAF.js";
 import {
   matchEntitySchemaSection,
   normalizeEntityStructuredSection,
@@ -77,7 +77,7 @@ import {
   okfTypeForEntityKind,
   okfTypeForMemory,
   refreshDirectorySidecarsAfterWrite
-} from "./chunk-345MEMRU.js";
+} from "./chunk-3OUGSOJP.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
@@ -87,7 +87,7 @@ import {
 } from "./chunk-YXZG5TVN.js";
 import {
   checkCorpusReadAbort
-} from "./chunk-5GINB5LC.js";
+} from "./chunk-6MKLMEBE.js";
 import {
   detectLanguageHint
 } from "./chunk-3WU7XOFN.js";
@@ -169,6 +169,7 @@ import {
   drainPendingLifecycleLedgerForSync,
   drainPendingLifecycleLedgerIfAny,
   formatProjectionAge,
+  iterateLifecycleEventsFromLedger,
   readAllLifecycleEventsFromLedger,
   readAllLifecycleEventsFromLedgerBuffer,
   readBoundedLifecycleEventsFromLedger,
@@ -177,7 +178,7 @@ import {
   readMemoryActionEventRowsFromLines,
   readProjectionRebuiltAt,
   serializeLifecycleAppendPayload
-} from "./chunk-22DYJLFN.js";
+} from "./chunk-XVC7JU2N.js";
 import {
   assertMemoryFrontmatterId,
   warnProjectionFallback
@@ -213,7 +214,7 @@ import {
 import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier
-} from "./chunk-RKDSELA3.js";
+} from "./chunk-Z63GU5NN.js";
 import {
   isSupportPassportPrivateMemory
 } from "./chunk-PWPIERBM.js";
@@ -241,7 +242,7 @@ import {
 import {
   isPathInsideStorageRoot,
   resolveSafeStoragePath
-} from "./chunk-FF4KLI5W.js";
+} from "./chunk-LDPPTPO5.js";
 import {
   MAGIC_HEADER_SIZE,
   SecureStoreLockedError,
@@ -689,11 +690,13 @@ var MemoryReadStore = class {
    * covers any hot→cold demotion that changes cold-tier contents) and
    * expires after COLD_SCAN_CACHE_TTL_MS as a safety net.
    */
-  async readAllColdMemories() {
+  async readAllColdMemories(options) {
+    checkCorpusReadAbort(options);
+    const retainRaw = options?.retainRaw !== false;
     const coldRoot = this.deps.resolveTierRootDir("cold");
     const currentColdVersion = this.deps.readColdWriteVersion();
     const keyId = this.deps.hotCacheKeyId();
-    const cached = this.deps.storageManagerClass.coldMemoriesCache.get(coldRoot);
+    const cached = retainRaw ? this.deps.storageManagerClass.coldMemoriesCache.get(coldRoot) : void 0;
     if (cached && cached.keyId === keyId && Date.now() - cached.loadedAt < this.deps.storageManagerClass.COLD_SCAN_CACHE_TTL_MS && cached.coldVersion === currentColdVersion) {
       return cached.memories;
     }
@@ -717,8 +720,10 @@ var MemoryReadStore = class {
       }
     };
     await collectPaths(coldRoot);
-    const memories = await this.deps.readParsedMemoriesFromPaths(filePaths, 50);
-    this.deps.storageManagerClass.coldMemoriesCache.set(coldRoot, { memories, loadedAt: Date.now(), coldVersion: currentColdVersion, keyId });
+    const memories = await this.deps.readParsedMemoriesFromPaths(filePaths, 50, options);
+    if (retainRaw) {
+      this.deps.storageManagerClass.coldMemoriesCache.set(coldRoot, { memories, loadedAt: Date.now(), coldVersion: currentColdVersion, keyId });
+    }
     return memories;
   }
   /** Read a single memory file by its absolute path. Returns null if unreadable. */
@@ -9046,6 +9051,7 @@ ${sanitized.text}
   }
   async readAllMemories(options) {
     checkCorpusReadAbort(options);
+    if (options?.retainRaw === false) return this._readAllMemoriesFromDisk(options);
     if (this.hotMemoriesCacheEnabled) {
       const cached = getCachedMemories(
         this.baseDir,
@@ -9286,18 +9292,16 @@ ${sanitized.text}
             const raw = await readMaybeEncryptedFile(fullPath, this._secureStoreKey, this.baseDir);
             const parsed = parseFrontmatter(raw);
             if (!parsed) return null;
-            return rememberRawFrontmatter(
-              {
-                path: fullPath,
-                frontmatter: normalizeFrontmatterForPath(
-                  parsed.frontmatter,
-                  toMemoryPathRel(this.baseDir, fullPath),
-                  parsed.content
-                ),
-                content: parsed.content
-              },
-              raw
-            );
+            const memory = {
+              path: fullPath,
+              frontmatter: normalizeFrontmatterForPath(
+                parsed.frontmatter,
+                toMemoryPathRel(this.baseDir, fullPath),
+                parsed.content
+              ),
+              content: parsed.content
+            };
+            return options?.retainRaw === false ? memory : rememberRawFrontmatter(memory, raw);
           } catch (err) {
             if (err instanceof SecureStoreLockedError) throw err;
             return null;
@@ -9394,20 +9398,23 @@ ${sanitized.text}
     const filePaths = await this.collectActiveMemoryPaths(options);
     return this.readParsedMemoriesFromPaths(filePaths, 50, options);
   }
-  async readAllColdMemories() {
-    return this.rememberMemorySnapshots(await this.memoryReadStore.readAllColdMemories());
+  async readAllColdMemories(options) {
+    const memories = await this.memoryReadStore.readAllColdMemories(options);
+    return options?.retainRaw === false ? memories : this.rememberMemorySnapshots(memories);
   }
   /**
    * Read archived memory markdown files under archive/.
    * Used by long-term recall fallback when hot recall has no hits.
    */
-  async readArchivedMemories() {
+  async readArchivedMemories(options) {
+    checkCorpusReadAbort(options);
     const memories = [];
     const root = this.archiveDir;
     const readDir = async (dir) => {
       try {
         const entries = await readdir6(dir, { withFileTypes: true });
         for (const entry of entries) {
+          checkCorpusReadAbort(options);
           const fullPath = path13.join(dir, entry.name);
           if (entry.isDirectory()) {
             await readDir(fullPath);
@@ -9416,23 +9423,19 @@ ${sanitized.text}
               const raw = await readMaybeEncryptedFile(fullPath, this._secureStoreKey, this.baseDir);
               const parsed = parseFrontmatter(raw);
               if (parsed) {
-                memories.push(
-                  rememberRawFrontmatter(
-                    {
-                      path: fullPath,
-                      frontmatter: normalizeFrontmatterForPath(
-                        parsed.frontmatter,
-                        toMemoryPathRel(this.baseDir, fullPath),
-                        parsed.content
-                      ),
-                      content: parsed.content
-                    },
-                    raw
-                  )
-                );
+                const memory = {
+                  path: fullPath,
+                  frontmatter: normalizeFrontmatterForPath(
+                    parsed.frontmatter,
+                    toMemoryPathRel(this.baseDir, fullPath),
+                    parsed.content
+                  ),
+                  content: parsed.content
+                };
+                memories.push(options?.retainRaw === false ? memory : rememberRawFrontmatter(memory, raw));
               }
             } catch (err) {
-              if (err instanceof SecureStoreLockedError) throw err;
+              if (isAbortError(err) || err instanceof SecureStoreLockedError) throw err;
               if (!isErrnoCode(err, "ENOENT")) {
                 log.warn(`skipping unreadable archived memory ${fullPath}: ${err}`);
               }
@@ -9440,12 +9443,13 @@ ${sanitized.text}
           }
         }
       } catch (error) {
-        if (error instanceof SecureStoreLockedError) throw error;
+        if (isAbortError(error) || error instanceof SecureStoreLockedError) throw error;
         if (!isErrnoCode(error, "ENOENT")) throw error;
       }
     };
     await readDir(root);
-    return this.rememberMemorySnapshots(memories);
+    checkCorpusReadAbort(options);
+    return options?.retainRaw === false ? memories : this.rememberMemorySnapshots(memories);
   }
   async readMemoryByPath(filePath) {
     return this.rememberMemorySnapshot(await this.memoryReadStore.readMemoryByPath(filePath));
@@ -10246,6 +10250,13 @@ ${memory.content}
   async readAllMemoryLifecycleEvents() {
     return readAllLifecycleEventsFromLedger(this.memoryLifecycleLedgerPath, (p) => this.readStorageSecureFile(p));
   }
+  /** File-order lifecycle rows. Callers that need canonical order sort after. */
+  async *iterateMemoryLifecycleEvents() {
+    yield* iterateLifecycleEventsFromLedger(
+      this.memoryLifecycleLedgerPath,
+      (filePath) => this.readStorageSecureFile(filePath)
+    );
+  }
   /** Raw decrypted ledger bytes as a Buffer, never a string, so an oversized
    *  ledger cannot throw on decode before recovery (#2033). */
   async readMemoryLifecycleLedgerRawBufferForCompaction() {
@@ -11369,4 +11380,4 @@ export {
   isValidBufferSurpriseEvent,
   StorageManager3 as StorageManager
 };
-//# sourceMappingURL=chunk-LHOIYLKH.js.map
+//# sourceMappingURL=chunk-ABET5LA5.js.map