@fgv/ts-agent-memory 5.1.0-51 → 5.1.0-52

package/lib/packlets/store/fileTreeMemoryStore.js

@@ -6,12 +6,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileTreeMemoryStore = void 0;
 const ts_utils_1 = require("@fgv/ts-utils");
-const ts_json_base_1 = require("@fgv/ts-json-base");
 const types_1 = require("../types");
 const converters_1 = require("../converters");
 const vectorMaintenance_1 = require("./vectorMaintenance");
 const storeCoverage_1 = require("./storeCoverage");
 const storeIdentity_1 = require("./storeIdentity");
+const storeFileAccess_1 = require("./storeFileAccess");
 const storeReconcile_1 = require("./storeReconcile");
 const index_1 = require("../index");
 const scopeEncoding_1 = require("./scopeEncoding");
@@ -132,9 +132,9 @@ class FileTreeMemoryStore {
                 // version whose `invalid_at` is null/absent) from the entity subtree,
                 // read off the derived index. `asOf` resolution is via `list({ asOf })`
                 // and the temporal retrievers.
-                return this._readVersionedCurrent(addr.scope);
+                return this._readVersionedCurrent(addr.scope, kind);
             }
-            return this._readRecord(addr.scope, addr.idStem);
+            return this._readRecord(addr.scope, addr.idStem, kind);
         }));
         await this._fireObservation('read', kind, entityId, {
             outcome: result.isSuccess() ? 'success' : 'failure',
@@ -493,7 +493,7 @@ class FileTreeMemoryStore {
                 return (0, ts_utils_1.succeed)({ record: duplicate.value, evicted: [] });
             }
         }
-        return this._readRecord(scope, idStem).thenOnSuccess((existing) => {
+        return this._readRecord(scope, idStem, record.envelope.kind).thenOnSuccess((existing) => {
             // Same-id re-put is a no-op ONLY when the content hash matches AND the
             // mutable metadata is also unchanged. The content hash covers
             // { kind, body, links }; a matching hash with revised tags/provenance is a
@@ -619,7 +619,7 @@ class FileTreeMemoryStore {
     /** Serialize and write a fully-stamped record, then patch the index. */
     _persist(record, scope, idStem) {
         return (0, converters_1.serializeMemoryFile)(record.envelope, record.body)
-            .onSuccess((raw) => this._writeFile(scope, idStem, raw))
+            .onSuccess((raw) => (0, storeFileAccess_1.writeRecordFile)(this._root, this._scopeEncoding, scope, idStem, raw))
             .onSuccess(() => this._index.patch('put', { scope, record }))
             .onSuccess(() => (0, ts_utils_1.succeed)(record));
     }
@@ -629,9 +629,9 @@ class FileTreeMemoryStore {
                 if (!(0, types_1.isTemporalIdentityCodec)(codec)) {
                     return Promise.resolve((0, ts_utils_1.fail)(`memory delete '${entityId}': codec for versioned kind '${kind}' does not implement the temporal codec interface`));
                 }
-                return this._deleteVersioned(entityId, addr.scope);
+                return this._deleteVersioned(entityId, addr.scope, kind);
             }
-            return this._deleteFlat(entityId, addr.scope, addr.idStem);
+            return this._deleteFlat(entityId, addr.scope, addr.idStem, kind);
         }));
     }
     /**
@@ -639,15 +639,15 @@ class FileTreeMemoryStore {
      * entry, then prune the vector best-effort. Structurally unchanged from the
      * pre-temporal delete path.
      */
-    async _deleteFlat(entityId, scope, idStem) {
-        return this._readRecord(scope, idStem).thenOnSuccess((existing) => {
+    async _deleteFlat(entityId, scope, idStem, kind) {
+        return this._readRecord(scope, idStem, kind).thenOnSuccess((existing) => {
             if (existing === undefined) {
                 return Promise.resolve((0, ts_utils_1.fail)(`memory delete '${entityId}': no record found`));
             }
             // Delete the record file + index entry (authoritative), then prune the
             // vector best-effort: a committed delete must not fail because the
             // derived index could not be pruned.
-            return this._deleteFile(scope, idStem)
+            return (0, storeFileAccess_1.deleteRecordFile)(this._root, this._scopeEncoding, scope, idStem)
                 .onSuccess(() => this._index.patch('delete', { scope, record: existing }))
                 .thenOnSuccess(async () => {
                 await this._vectors.removeAll({ scope, id: existing.envelope.id });
@@ -661,7 +661,7 @@ class FileTreeMemoryStore {
      * null/absent. `undefined` when the entity has no current version (never
      * written, or fully invalidated / soft-deleted).
      */
-    _readVersionedCurrent(scope) {
+    _readVersionedCurrent(scope, expectedKind) {
         // Select over ENVELOPES, then materialize the one winner — which is what
         // `IMemoryStore.get`'s docstring promises and what `selectCurrentVersion`
         // being generic over `IEnvelopeCarrier` exists for. Materializing every
@@ -671,21 +671,21 @@ class FileTreeMemoryStore {
         if (current === undefined) {
             return (0, ts_utils_1.succeed)(undefined);
         }
-        return this._resolveRequired(current);
+        return this._resolveRequired(current).onSuccess((materialized) => (0, storeIdentity_1.verifyOccupantKind)(expectedKind, scope, materialized.envelope.id, materialized));
     }
     /**
      * Every persisted version of the entity whose subtree is `scope`. All version
      * files for one entity live under exactly that scope (which encodes the
      * entityId), so a scope filter over the index isolates one entity's versions.
      */
-    _versionsForEntity(scope) {
+    _versionsForEntity(scope, expectedKind) {
         // Selected on the envelope (scope), materialized after — so a versioned write
         // reads only that entity's versions, never the vault. Bounded by the entity's
         // version count.
         return (0, ts_utils_1.mapResults)(this._index
             .entries()
             .filter((entry) => entry.scope === scope)
-            .map((entry) => this._resolveRequired(entry)));
+            .map((entry) => this._resolveRequired(entry).onSuccess((r) => (0, storeIdentity_1.verifyOccupantKind)(expectedKind, scope, r.envelope.id, r))));
     }
     /**
      * Versioned write (invalidate-don't-delete). Builds the new version's content
@@ -707,7 +707,7 @@ class FileTreeMemoryStore {
         // still-current version at snapshot time — normally one, but two-or-more if a
         // prior invalidation partially failed; invalidating all of them lets the write
         // self-heal a stuck state (P2-7).
-        const snapshot = this._versionsForEntity(scope);
+        const snapshot = this._versionsForEntity(scope, kind);
         if (snapshot.isFailure()) {
             return (0, ts_utils_1.fail)(snapshot.message);
         }
@@ -836,8 +836,8 @@ class FileTreeMemoryStore {
      * kinds exist to preserve the audit trail (and the L3 `contradicts` interlock
      * builds on it), so a hard delete would defeat the purpose.
      */
-    async _deleteVersioned(entityId, scope) {
-        const snapshot = this._versionsForEntity(scope);
+    async _deleteVersioned(entityId, scope, kind) {
+        const snapshot = this._versionsForEntity(scope, kind);
         if (snapshot.isFailure()) {
             return (0, ts_utils_1.fail)(snapshot.message);
         }
@@ -860,7 +860,7 @@ class FileTreeMemoryStore {
             if (existing === undefined) {
                 return (0, ts_utils_1.fail)(`memory put: cannot evict '${id}' in scope '${scope}': not found`);
             }
-            return this._deleteFile(scope, id)
+            return (0, storeFileAccess_1.deleteRecordFile)(this._root, this._scopeEncoding, scope, id)
                 .onSuccess(() => this._index.patch('delete', { scope, record: existing }))
                 .onSuccess(() => (0, ts_utils_1.succeed)(id));
         });
@@ -1010,7 +1010,7 @@ class FileTreeMemoryStore {
      * already-consistent store touches no files.
      */
     _rewriteEnvelope(scope, id, mutate) {
-        return this._resolveScopeDir(scope).onSuccess((scopeDir) => {
+        return (0, storeFileAccess_1.resolveScopeDir)(this._root, this._scopeEncoding, scope).onSuccess((scopeDir) => {
             /* c8 ignore next 3 - defensive: the scope dir exists for any indexed record */
             if (scopeDir === undefined) {
                 return (0, ts_utils_1.fail)(`'${id}': scope '${scope}' not found`);
@@ -1105,8 +1105,8 @@ class FileTreeMemoryStore {
      * when the scope directory or file is absent. Verifies the on-disk id ↔
      * filename round-trip on every load.
      */
-    _readRecord(scope, idStem) {
-        return this._resolveScopeDir(scope).onSuccess((scopeDir) => {
+    _readRecord(scope, idStem, expectedKind) {
+        return (0, storeFileAccess_1.resolveScopeDir)(this._root, this._scopeEncoding, scope).onSuccess((scopeDir) => {
             if (scopeDir === undefined) {
                 return (0, ts_utils_1.succeed)(undefined);
             }
@@ -1119,7 +1119,8 @@ class FileTreeMemoryStore {
                 return file
                     .getRawContents()
                     .onSuccess((raw) => (0, converters_1.parseMemoryFile)(raw, this._registry))
-                    .onSuccess((parsedRecord) => this._verifyLoaded(scope, file, parsedRecord));
+                    .onSuccess((parsedRecord) => this._verifyLoaded(scope, file, parsedRecord))
+                    .onSuccess((loaded) => (0, storeIdentity_1.verifyOccupantKind)(expectedKind, scope, idStem, loaded));
             });
         });
     }
@@ -1135,83 +1136,6 @@ class FileTreeMemoryStore {
     _verifyLoaded(scope, file, record) {
         return (0, storeIdentity_1.verifyLoadedIdentity)(this._codec(record.envelope.kind), scope, file, record);
     }
-    /**
-     * Resolve the directory for a scope, returning `undefined` when it does not
-     * exist. Navigation only — does not create. Folds the path segments through
-     * `getChildren` so an absent segment short-circuits to `undefined`.
-     */
-    _resolveScopeDir(scope) {
-        return this._scopeEncoding(scope).onSuccess((encoded) => {
-            const segments = encoded.split('/').filter((s) => s.length > 0);
-            return segments.reduce((acc, segment) => acc.onSuccess((current) => {
-                if (current === undefined) {
-                    return (0, ts_utils_1.succeed)(undefined);
-                }
-                return current
-                    .getChildren()
-                    .onSuccess((children) => (0, ts_utils_1.succeed)(children.find((c) => c.type === 'directory' && c.name === segment)));
-            }), (0, ts_utils_1.succeed)(this._root));
-        });
-    }
-    /** Ensure the scope directory exists, creating segments as needed. */
-    _ensureScopeDir(scope) {
-        return this._scopeEncoding(scope).onSuccess((encoded) => {
-            const segments = encoded.split('/').filter((s) => s.length > 0);
-            return segments.reduce((acc, segment) => acc.onSuccess((current) => current.getChildren().onSuccess((children) => {
-                const existing = children.find((c) => c.type === 'directory' && c.name === segment);
-                if (existing === undefined) {
-                    return current.createChildDirectory(segment);
-                }
-                /* c8 ignore next 3 -- defensive: a child of a mutable in-memory/fs tree is itself mutable; the guard protects against a read-only adapter handed in as root */
-                if (!ts_json_base_1.FileTree.isMutableDirectoryItem(existing)) {
-                    return (0, ts_utils_1.fail)(`${existing.absolutePath}: directory is not mutable`);
-                }
-                return (0, ts_utils_1.succeed)(existing);
-            })), (0, ts_utils_1.succeed)(this._root));
-        });
-    }
-    /** Write (create or overwrite) `<scope>/<idStem>.md` with `raw`. */
-    _writeFile(scope, idStem, raw) {
-        return this._ensureScopeDir(scope).onSuccess((scopeDir) => scopeDir.getChildren().onSuccess((children) => {
-            const fileName = `${idStem}${MEMORY_FILE_EXTENSION}`;
-            const existing = children.find((c) => c.type === 'file' && c.name === fileName);
-            if (existing === undefined) {
-                return scopeDir.createChildFile(fileName, raw).onSuccess(() => (0, ts_utils_1.succeed)(true));
-            }
-            /* c8 ignore next 3 -- defensive: a file in a mutable tree is mutable; guards a read-only adapter */
-            if (!ts_json_base_1.FileTree.isMutableFileItem(existing)) {
-                return (0, ts_utils_1.fail)(`${existing.absolutePath}: file is not mutable`);
-            }
-            return existing.setRawContents(raw).onSuccess(() => (0, ts_utils_1.succeed)(true));
-        }));
-    }
-    /**
-     * Physically delete `<scope>/<idStem>.md`. The scope-missing and file-missing
-     * guards are unreachable through the callers (`delete` / `_evict` both read the
-     * record first, so the directory and file exist) but are kept so a future
-     * direct caller degrades loudly rather than silently.
-     */
-    _deleteFile(scope, idStem) {
-        return this._resolveScopeDir(scope).onSuccess((scopeDir) => {
-            /* c8 ignore next 3 -- unreachable: callers read the record (hence the scope dir) first */
-            if (scopeDir === undefined) {
-                return (0, ts_utils_1.fail)(`memory delete: scope '${scope}' not found`);
-            }
-            const fileName = `${idStem}${MEMORY_FILE_EXTENSION}`;
-            return scopeDir.getChildren().onSuccess((children) => {
-                const file = children.find((c) => c.type === 'file' && c.name === fileName);
-                /* c8 ignore next 3 -- unreachable: callers read the record (hence the file) first */
-                if (file === undefined) {
-                    return (0, ts_utils_1.fail)(`memory delete: file '${fileName}' not found in scope '${scope}'`);
-                }
-                /* c8 ignore next 3 -- defensive: a file in a mutable tree is mutable; guards a read-only adapter */
-                if (!ts_json_base_1.FileTree.isMutableFileItem(file)) {
-                    return (0, ts_utils_1.fail)(`${file.absolutePath}: file is not mutable`);
-                }
-                return file.delete().onSuccess(() => (0, ts_utils_1.succeed)(true));
-            });
-        });
-    }
     /**
      * Walk the FileTree once and rebuild the index. Also resumes the `seq`
      * counter past the highest persisted `seq` so new writes stay monotonic.