@remnic/core 9.3.658 → 9.3.660

package/dist/{chunk-2VCTTEJM.js → chunk-7H7J3ZWN.js}

@@ -11,13 +11,13 @@ import {
 } from "./chunk-D24OXEPB.js";
 import {
   EngramAccessInputError
-} from "./chunk-6M4LYWA2.js";
+} from "./chunk-RP2U54GG.js";
 import {
   projectTagProjectId
 } from "./chunk-GYSYLGNE.js";
 import {
   validateBriefingFormat
-} from "./chunk-KI6QM5AV.js";
+} from "./chunk-GY3V3SUI.js";
 import {
   resolvePrincipal
 } from "./chunk-UZYLX7M6.js";
@@ -3117,4 +3117,4 @@ ${body}`;
 export {
   EngramMcpServer
 };
-//# sourceMappingURL=chunk-2VCTTEJM.js.map
+//# sourceMappingURL=chunk-7H7J3ZWN.js.map

package/dist/{chunk-QRSKPI62.js → chunk-7PCZGNG2.js}

@@ -7,7 +7,7 @@ import {
 import {
   getCachedQmdSearch,
   setCachedQmdSearch
-} from "./chunk-CPPS65WS.js";
+} from "./chunk-AWJ2FHCF.js";
 import {
   mergeEnv
 } from "./chunk-JUC24CTX.js";
@@ -2136,4 +2136,4 @@ export {
   getQmdCommandName,
   QmdClient
 };
-//# sourceMappingURL=chunk-QRSKPI62.js.map
+//# sourceMappingURL=chunk-7PCZGNG2.js.map

package/dist/{chunk-ZCMO46YY.js → chunk-A7EF2XRO.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-4PLOQDBB.js";
+} from "./chunk-AX5O25EF.js";
 import {
   decideLifecycleTransition
 } from "./chunk-TBBDFYXW.js";
@@ -729,4 +729,4 @@ export {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
 };
-//# sourceMappingURL=chunk-ZCMO46YY.js.map
+//# sourceMappingURL=chunk-A7EF2XRO.js.map

package/dist/{chunk-BNUAOLDK.js → chunk-ANJOULTP.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-3UXOZBHV.js";
 import {
   StorageManager
-} from "./chunk-4PLOQDBB.js";
+} from "./chunk-AX5O25EF.js";
 import {
   isSafeRouteNamespace
 } from "./chunk-U3PN77QT.js";
@@ -118,4 +118,4 @@ export {
   runCodexMaterialize,
   runPostConsolidationMaterialize
 };
-//# sourceMappingURL=chunk-BNUAOLDK.js.map
+//# sourceMappingURL=chunk-ANJOULTP.js.map

package/dist/{chunk-CPPS65WS.js → chunk-AWJ2FHCF.js}

@@ -1,3 +1,8 @@
+import {
+  clearQmdRecallCache,
+  qmdRecallCacheSize
+} from "./chunk-42JKGUFJ.js";
+
 // src/memory-cache.ts
 var hotCacheByDir = /* @__PURE__ */ new Map();
 var archiveCacheByDir = /* @__PURE__ */ new Map();
@@ -32,8 +37,14 @@ function setCachedArchivedMemories(baseDir, memories, version) {
   archiveCacheByDir.set(baseDir, { memories: map, version, loadedAt: Date.now() });
 }
 var entityCacheByDir = /* @__PURE__ */ new Map();
-function buildEntityCacheKey(baseDir, schemaKey = "") {
-  return `${baseDir}\0${schemaKey}`;
+function normalizeEntitySchemaKey(schemaKey) {
+  return schemaKey ?? "";
+}
+function entityCacheKeyPrefix(baseDir) {
+  return `${baseDir}\0`;
+}
+function buildEntityCacheKey(baseDir, schemaKey) {
+  return `${entityCacheKeyPrefix(baseDir)}${normalizeEntitySchemaKey(schemaKey)}`;
 }
 function getCachedEntities(baseDir, currentVersion, schemaKey = "") {
   if (currentVersion === 0) return null;
@@ -49,7 +60,7 @@ function setCachedEntities(baseDir, entities, version, schemaKey = "") {
   });
 }
 function invalidateCachedEntities(baseDir) {
-  const prefix = `${baseDir}\0`;
+  const prefix = entityCacheKeyPrefix(baseDir);
   for (const key of entityCacheByDir.keys()) {
     if (key.startsWith(prefix)) entityCacheByDir.delete(key);
   }
@@ -111,21 +122,75 @@ function setCachedQmdSearch(cacheKey, results) {
     }
   }
 }
+var ALL_CACHE_LAYERS = [
+  {
+    name: "hot-memories",
+    scope: "dir",
+    invalidateForDir: (baseDir) => void hotCacheByDir.delete(baseDir),
+    clearAll: () => hotCacheByDir.clear(),
+    hasEntriesFor: (baseDir) => hotCacheByDir.has(baseDir)
+  },
+  {
+    name: "archive-memories",
+    scope: "dir",
+    invalidateForDir: (baseDir) => void archiveCacheByDir.delete(baseDir),
+    clearAll: () => archiveCacheByDir.clear(),
+    hasEntriesFor: (baseDir) => archiveCacheByDir.has(baseDir)
+  },
+  {
+    name: "entities",
+    scope: "dir",
+    invalidateForDir: (baseDir) => invalidateCachedEntities(baseDir),
+    clearAll: () => entityCacheByDir.clear(),
+    hasEntriesFor: (baseDir) => {
+      const prefix = entityCacheKeyPrefix(baseDir);
+      for (const key of entityCacheByDir.keys()) {
+        if (key.startsWith(prefix)) return true;
+      }
+      return false;
+    }
+  },
+  {
+    name: "derived-episode-map",
+    scope: "dir",
+    invalidateForDir: (baseDir) => void episodeMapByDir.delete(baseDir),
+    clearAll: () => episodeMapByDir.clear(),
+    hasEntriesFor: (baseDir) => episodeMapByDir.has(baseDir)
+  },
+  {
+    name: "derived-rule-memories",
+    scope: "dir",
+    invalidateForDir: (baseDir) => void ruleMemoriesByDir.delete(baseDir),
+    clearAll: () => ruleMemoriesByDir.clear(),
+    hasEntriesFor: (baseDir) => ruleMemoriesByDir.has(baseDir)
+  },
+  {
+    name: "qmd-search",
+    scope: "global",
+    invalidateForDir: () => qmdSearchCache.clear(),
+    clearAll: () => qmdSearchCache.clear(),
+    hasEntriesFor: () => qmdSearchCache.size > 0
+  },
+  {
+    name: "qmd-recall",
+    scope: "global",
+    invalidateForDir: () => clearQmdRecallCache(),
+    clearAll: () => clearQmdRecallCache(),
+    hasEntriesFor: () => qmdRecallCacheSize() > 0
+  }
+];
+function invalidateAllForDir(baseDir) {
+  for (const layer of ALL_CACHE_LAYERS) {
+    layer.invalidateForDir(baseDir);
+  }
+}
 function clearMemoryCache(baseDir) {
   if (baseDir) {
-    hotCacheByDir.delete(baseDir);
-    archiveCacheByDir.delete(baseDir);
-    invalidateCachedEntities(baseDir);
-    episodeMapByDir.delete(baseDir);
-    ruleMemoriesByDir.delete(baseDir);
-    qmdSearchCache.clear();
-  } else {
-    hotCacheByDir.clear();
-    archiveCacheByDir.clear();
-    entityCacheByDir.clear();
-    episodeMapByDir.clear();
-    ruleMemoriesByDir.clear();
-    qmdSearchCache.clear();
+    invalidateAllForDir(baseDir);
+    return;
+  }
+  for (const layer of ALL_CACHE_LAYERS) {
+    layer.clearAll();
   }
 }
 function getMemoryCacheStats(baseDir) {
@@ -155,7 +220,9 @@ export {
   setCachedRuleMemories,
   getCachedQmdSearch,
   setCachedQmdSearch,
+  ALL_CACHE_LAYERS,
+  invalidateAllForDir,
   clearMemoryCache,
   getMemoryCacheStats
 };
-//# sourceMappingURL=chunk-CPPS65WS.js.map
+//# sourceMappingURL=chunk-AWJ2FHCF.js.map

package/dist/chunk-AWJ2FHCF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/memory-cache.ts"],"sourcesContent":["import type { EntityFile, MemoryFile } from \"./types.js\";\nimport { clearQmdRecallCache, qmdRecallCacheSize } from \"./qmd-recall-cache.js\";\n\ninterface CacheEntry {\n  memories: Map<string, MemoryFile>; // keyed by file path\n  version: number;\n  loadedAt: number;\n}\n\n// Module-level singleton — shared across all StorageManager instances and sessions\nconst hotCacheByDir = new Map<string, CacheEntry>();\nconst archiveCacheByDir = new Map<string, CacheEntry>();\n\nexport function getCachedMemories(baseDir: string, currentVersion: number): MemoryFile[] | null {\n  // Don't serve from cache when version tracking is unavailable (version=0).\n  // This ensures tests and fresh installs without a version file always read disk.\n  if (currentVersion === 0) return null;\n  const entry = hotCacheByDir.get(baseDir);\n  if (!entry || entry.version !== currentVersion) return null;\n  return [...entry.memories.values()];\n}\n\nexport function setCachedMemories(baseDir: string, memories: MemoryFile[], version: number): void {\n  const map = new Map<string, MemoryFile>();\n  for (const m of memories) map.set(m.path, m);\n  hotCacheByDir.set(baseDir, { memories: map, version, loadedAt: Date.now() });\n}\n\nexport function updateCacheOnWrite(baseDir: string, memory: MemoryFile): void {\n  const entry = hotCacheByDir.get(baseDir);\n  if (entry) entry.memories.set(memory.path, memory);\n}\n\nexport function updateCacheOnDelete(baseDir: string, filePath: string): void {\n  const entry = hotCacheByDir.get(baseDir);\n  if (entry) entry.memories.delete(filePath);\n}\n\n// Archive cache — same pattern, separate store\nexport function getCachedArchivedMemories(baseDir: string, currentVersion: number): MemoryFile[] | null {\n  if (currentVersion === 0) return null;\n  const entry = archiveCacheByDir.get(baseDir);\n  if (!entry || entry.version !== currentVersion) return null;\n  return [...entry.memories.values()];\n}\n\nexport function setCachedArchivedMemories(baseDir: string, memories: MemoryFile[], version: number): void {\n  const map = new Map<string, MemoryFile>();\n  for (const m of memories) map.set(m.path, m);\n  archiveCacheByDir.set(baseDir, { memories: map, version, loadedAt: Date.now() });\n}\n\n// Entity cache — same pattern as memory cache, but keyed by schema-aware parse inputs.\nconst entityCacheByDir = new Map<string, { entities: EntityFile[]; version: number; loadedAt: number }>();\n\n/**\n * Single normalization point for the entity-cache schema key (issue #1535).\n * BOTH the set/get key builder and the prefix invalidation derive from here so\n * `undefined` vs `\"\"` (or any future normalization rule) can never diverge\n * between the write path and the invalidate path (rule 38 cousin).\n */\nfunction normalizeEntitySchemaKey(schemaKey: string | undefined): string {\n  return schemaKey ?? \"\";\n}\n\n/** Prefix shared by every entity-cache key for a dir, regardless of schemaKey. */\nfunction entityCacheKeyPrefix(baseDir: string): string {\n  return `${baseDir}\\u0000`;\n}\n\nfunction buildEntityCacheKey(baseDir: string, schemaKey?: string): string {\n  return `${entityCacheKeyPrefix(baseDir)}${normalizeEntitySchemaKey(schemaKey)}`;\n}\n\nexport function getCachedEntities(\n  baseDir: string,\n  currentVersion: number,\n  schemaKey: string = \"\",\n): EntityFile[] | null {\n  if (currentVersion === 0) return null;\n  const entry = entityCacheByDir.get(buildEntityCacheKey(baseDir, schemaKey));\n  if (!entry || entry.version !== currentVersion) return null;\n  return entry.entities;\n}\n\nexport function setCachedEntities(\n  baseDir: string,\n  entities: EntityFile[],\n  version: number,\n  schemaKey: string = \"\",\n): void {\n  entityCacheByDir.set(buildEntityCacheKey(baseDir, schemaKey), {\n    entities,\n    version,\n    loadedAt: Date.now(),\n  });\n}\n\nexport function invalidateCachedEntities(baseDir: string): void {\n  const prefix = entityCacheKeyPrefix(baseDir);\n  for (const key of entityCacheByDir.keys()) {\n    if (key.startsWith(prefix)) entityCacheByDir.delete(key);\n  }\n}\n\n// Derived caches — pre-filtered views invalidated alongside the main cache.\n// These avoid O(146K) filter+map on every verified recall/rules call.\ninterface DerivedCacheEntry<T> {\n  data: T;\n  sourceVersion: number; // matches the hot cache version it was derived from\n}\n\nconst episodeMapByDir = new Map<string, DerivedCacheEntry<Map<string, MemoryFile>>>();\nconst ruleMemoriesByDir = new Map<string, DerivedCacheEntry<{ all: MemoryFile[]; byId: Map<string, MemoryFile> }>>();\n\n/** Get a pre-filtered Map of episode memories (keyed by ID). Derived from hot cache. */\nexport function getCachedEpisodeMap(baseDir: string, currentVersion: number): Map<string, MemoryFile> | null {\n  if (currentVersion === 0) return null;\n  const entry = episodeMapByDir.get(baseDir);\n  if (!entry || entry.sourceVersion !== currentVersion) return null;\n  return entry.data;\n}\n\n/** Build and cache the episode memory map from the full memory list. */\nexport function setCachedEpisodeMap(baseDir: string, memories: MemoryFile[], version: number): Map<string, MemoryFile> {\n  const map = new Map<string, MemoryFile>();\n  for (const m of memories) {\n    if (m.frontmatter.status === \"archived\" || m.frontmatter.status === \"forgotten\") continue;\n    if (m.frontmatter.memoryKind !== \"episode\") continue;\n    map.set(m.frontmatter.id, m);\n  }\n  episodeMapByDir.set(baseDir, { data: map, sourceVersion: version });\n  return map;\n}\n\n/** Get pre-filtered rule memories. Derived from hot cache. */\nexport function getCachedRuleMemories(baseDir: string, currentVersion: number): { all: MemoryFile[]; byId: Map<string, MemoryFile> } | null {\n  if (currentVersion === 0) return null;\n  const entry = ruleMemoriesByDir.get(baseDir);\n  if (!entry || entry.sourceVersion !== currentVersion) return null;\n  return entry.data;\n}\n\n/** Build and cache the rule memories from the full memory list. */\nexport function setCachedRuleMemories(baseDir: string, memories: MemoryFile[], version: number): { all: MemoryFile[]; byId: Map<string, MemoryFile> } {\n  const byId = new Map<string, MemoryFile>();\n  const all: MemoryFile[] = [];\n  for (const m of memories) {\n    byId.set(m.frontmatter.id, m);\n    if (\n      m.frontmatter.category === \"rule\" &&\n      m.frontmatter.status !== \"archived\" &&\n      m.frontmatter.status !== \"forgotten\"\n    ) {\n      all.push(m);\n    }\n  }\n  const result = { all, byId };\n  ruleMemoriesByDir.set(baseDir, { data: result, sourceVersion: version });\n  return result;\n}\n\n// QMD search result cache — short-lived (60s TTL) to avoid stale results\n// while reducing redundant daemon calls for repeated/similar queries.\ninterface QmdCacheEntry {\n  results: unknown[];\n  cachedAt: number;\n}\nconst QMD_CACHE_TTL_MS = 60_000;\nconst qmdSearchCache = new Map<string, QmdCacheEntry>();\n\nexport function getCachedQmdSearch(cacheKey: string): unknown[] | null {\n  const entry = qmdSearchCache.get(cacheKey);\n  if (!entry) return null;\n  if (Date.now() - entry.cachedAt > QMD_CACHE_TTL_MS) {\n    qmdSearchCache.delete(cacheKey);\n    return null;\n  }\n  return entry.results;\n}\n\nexport function setCachedQmdSearch(cacheKey: string, results: unknown[]): void {\n  qmdSearchCache.set(cacheKey, { results, cachedAt: Date.now() });\n  // Evict old entries to prevent unbounded growth\n  if (qmdSearchCache.size > 200) {\n    const now = Date.now();\n    for (const [key, entry] of qmdSearchCache) {\n      if (now - entry.cachedAt > QMD_CACHE_TTL_MS) qmdSearchCache.delete(key);\n    }\n  }\n}\n\n/**\n * Cache-layer registry (issue #1535).\n *\n * EVERY process-level cache that can serve memory-derived content is\n * enumerated here, and the single invalidation chokepoint\n * (`invalidateAllForDir`) iterates this list. Adding a new cache layer to\n * this module (or qmd-recall-cache.ts) REQUIRES registering it here —\n * otherwise mutations will never invalidate it (the exact bug this registry\n * exists to prevent) and the enumerate-all-layers fitness test in\n * tests/cache-invalidation-coherence.test.ts fails.\n */\nexport interface MemoryCacheLayer {\n  /** Stable identifier used by tests and diagnostics. */\n  readonly name: string;\n  /** \"dir\" layers evict only entries for the given baseDir. \"global\" layers\n   *  are fully cleared on any mutation: their keys embed queries, namespaces,\n   *  and strategies rather than a storage dir, so a per-dir selective clear\n   *  is not possible without recording the dir in each entry. Full clear is\n   *  the simple-and-correct choice — these caches are re-warmable\n   *  (issue #1535, implementation guide option (b)). */\n  readonly scope: \"dir\" | \"global\";\n  /** Evict entries for baseDir (\"dir\" scope) or everything (\"global\" scope). */\n  readonly invalidateForDir: (baseDir: string) => void;\n  /** Evict every entry across all dirs. */\n  readonly clearAll: () => void;\n  /** True when the layer still holds entries for baseDir (\"dir\" scope) or\n   *  any entries at all (\"global\" scope). */\n  readonly hasEntriesFor: (baseDir: string) => boolean;\n}\n\nexport const ALL_CACHE_LAYERS: readonly MemoryCacheLayer[] = [\n  {\n    name: \"hot-memories\",\n    scope: \"dir\",\n    invalidateForDir: (baseDir) => void hotCacheByDir.delete(baseDir),\n    clearAll: () => hotCacheByDir.clear(),\n    hasEntriesFor: (baseDir) => hotCacheByDir.has(baseDir),\n  },\n  {\n    name: \"archive-memories\",\n    scope: \"dir\",\n    invalidateForDir: (baseDir) => void archiveCacheByDir.delete(baseDir),\n    clearAll: () => archiveCacheByDir.clear(),\n    hasEntriesFor: (baseDir) => archiveCacheByDir.has(baseDir),\n  },\n  {\n    name: \"entities\",\n    scope: \"dir\",\n    invalidateForDir: (baseDir) => invalidateCachedEntities(baseDir),\n    clearAll: () => entityCacheByDir.clear(),\n    hasEntriesFor: (baseDir) => {\n      const prefix = entityCacheKeyPrefix(baseDir);\n      for (const key of entityCacheByDir.keys()) {\n        if (key.startsWith(prefix)) return true;\n      }\n      return false;\n    },\n  },\n  {\n    name: \"derived-episode-map\",\n    scope: \"dir\",\n    invalidateForDir: (baseDir) => void episodeMapByDir.delete(baseDir),\n    clearAll: () => episodeMapByDir.clear(),\n    hasEntriesFor: (baseDir) => episodeMapByDir.has(baseDir),\n  },\n  {\n    name: \"derived-rule-memories\",\n    scope: \"dir\",\n    invalidateForDir: (baseDir) => void ruleMemoriesByDir.delete(baseDir),\n    clearAll: () => ruleMemoriesByDir.clear(),\n    hasEntriesFor: (baseDir) => ruleMemoriesByDir.has(baseDir),\n  },\n  {\n    name: \"qmd-search\",\n    scope: \"global\",\n    invalidateForDir: () => qmdSearchCache.clear(),\n    clearAll: () => qmdSearchCache.clear(),\n    hasEntriesFor: () => qmdSearchCache.size > 0,\n  },\n  {\n    name: \"qmd-recall\",\n    scope: \"global\",\n    invalidateForDir: () => clearQmdRecallCache(),\n    clearAll: () => clearQmdRecallCache(),\n    hasEntriesFor: () => qmdRecallCacheSize() > 0,\n  },\n];\n\n/**\n * The single invalidation chokepoint (issue #1535, rule 37).\n *\n * Every memory/entity mutation path must route through this function —\n * storage.ts calls it from its internal invalidation funnels\n * (invalidateAllMemoriesCache / invalidateColdMemoriesCache /\n * bumpMemoryStatusVersion / setSecureStoreKey). Nothing may clear an\n * individual layer ad hoc: partial clears are how the stale-recall bug\n * happened (qmdRecallCache was never invalidated on mutations, so recall\n * served pre-edit bundles for the remainder of its fresh/stale TTL window).\n */\nexport function invalidateAllForDir(baseDir: string): void {\n  for (const layer of ALL_CACHE_LAYERS) {\n    layer.invalidateForDir(baseDir);\n  }\n}\n\nexport function clearMemoryCache(baseDir?: string): void {\n  if (baseDir) {\n    invalidateAllForDir(baseDir);\n    return;\n  }\n  for (const layer of ALL_CACHE_LAYERS) {\n    layer.clearAll();\n  }\n}\n\nexport function getMemoryCacheStats(baseDir: string): {\n  hotSize: number;\n  archiveSize: number;\n  hotVersion: number | null;\n  archiveVersion: number | null;\n} {\n  const hot = hotCacheByDir.get(baseDir);\n  const archive = archiveCacheByDir.get(baseDir);\n  return {\n    hotSize: hot?.memories.size ?? 0,\n    archiveSize: archive?.memories.size ?? 0,\n    hotVersion: hot?.version ?? null,\n    archiveVersion: archive?.version ?? null,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-4PLOQDBB.js → chunk-AX5O25EF.js}

@@ -16,9 +16,9 @@ import {
 } from "./chunk-AZBV4RRY.js";
 import {
   getCachedEntities,
-  invalidateCachedEntities,
+  invalidateAllForDir,
   setCachedEntities
-} from "./chunk-CPPS65WS.js";
+} from "./chunk-AWJ2FHCF.js";
 import {
   inferMemoryStatus,
   isArchivedMemoryPath,
@@ -1804,7 +1804,7 @@ var StorageManager = class _StorageManager {
   setSecureStoreKey(key, encryptOnWrite = true) {
     this._secureStoreKey = key;
     this._secureStoreEncryptOnWrite = encryptOnWrite;
-    invalidateCachedEntities(this.baseDir);
+    invalidateAllForDir(this.baseDir);
     this.invalidateKnowledgeIndexCache();
   }
   getEntityCacheSecureStoreKey() {
@@ -1941,6 +1941,7 @@ var StorageManager = class _StorageManager {
   }
   bumpMemoryStatusVersion() {
     this.bumpSharedVersion("memory-status", _StorageManager.memoryStatusVersionByDir);
+    invalidateAllForDir(this.baseDir);
   }
   getMemoryStatusVersion() {
     return this.readSharedVersion("memory-status", _StorageManager.memoryStatusVersionByDir);
@@ -2295,7 +2296,6 @@ var StorageManager = class _StorageManager {
   }
   async invalidateAfterOfflineSyncMutation(filePath) {
     this.invalidateAllMemoriesCache();
-    invalidateCachedEntities(this.baseDir);
     this.invalidateKnowledgeIndexCache();
     this.factHashIndexAuthoritative = false;
     await unlink(this.factHashIndexReadyPath).catch((error) => {
@@ -3103,6 +3103,7 @@ ${sanitized.text}
    *  inside cold/, archiveMemory, etc.). */
   invalidateAllMemoriesCache() {
     _StorageManager.allMemoriesInFlight.delete(this.baseDir);
+    invalidateAllForDir(this.baseDir);
   }
   /**
    * Invalidate the cold-scan cache for this storage root and bump the
@@ -3120,6 +3121,7 @@ ${sanitized.text}
     const coldRoot = path2.join(this.baseDir, "cold");
     _StorageManager.coldMemoriesCache.delete(coldRoot);
     this.bumpColdWriteVersion();
+    invalidateAllForDir(this.baseDir);
   }
   /** Return the current cold-write version counter for this storage root.
    *  Reads the on-disk sentinel (state/cold-write.log) so it reflects writes
@@ -5597,4 +5599,4 @@ export {
   serializeEntityFile,
   StorageManager
 };
-//# sourceMappingURL=chunk-4PLOQDBB.js.map
+//# sourceMappingURL=chunk-AX5O25EF.js.map