@fgv/ts-json-base 5.0.2 → 5.1.0-1

package/lib/packlets/file-tree/fsTree.js

@@ -30,9 +30,10 @@ const fs_1 = __importDefault(require("fs"));
 const ts_utils_1 = require("@fgv/ts-utils");
 const directoryItem_1 = require("./directoryItem");
 const fileItem_1 = require("./fileItem");
+const filterSpec_1 = require("./filterSpec");
 /**
- * Implementation of {@link FileTree.IFileTreeAccessors} that uses the
- * file system to access files and directories.
+ * Implementation of {@link FileTree.IMutableFileTreeAccessors} that uses the
+ * file system to access and modify files and directories.
  * @public
  */
 class FsFileTreeAccessors {
@@ -42,12 +43,14 @@ class FsFileTreeAccessors {
      * @public
      */
     constructor(params) {
-        var _a;
+        var _a, _b;
         this.prefix = params === null || params === void 0 ? void 0 : params.prefix;
         this._inferContentType = (_a = params === null || params === void 0 ? void 0 : params.inferContentType) !== null && _a !== void 0 ? _a : fileItem_1.FileItem.defaultInferContentType;
+        /* c8 ignore next 1 - defensive default when params is undefined */
+        this._mutable = (_b = params === null || params === void 0 ? void 0 : params.mutable) !== null && _b !== void 0 ? _b : false;
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
+     * {@inheritDoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
      */
     resolveAbsolutePath(...paths) {
         if (this.prefix && !path_1.default.isAbsolute(paths[0])) {
@@ -56,25 +59,25 @@ class FsFileTreeAccessors {
         return path_1.default.resolve(...paths);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getExtension}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getExtension}
      */
     getExtension(itemPath) {
         return path_1.default.extname(itemPath);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getBaseName}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getBaseName}
      */
     getBaseName(itemPath, suffix) {
         return path_1.default.basename(itemPath, suffix);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.joinPaths}
+     * {@inheritDoc FileTree.IFileTreeAccessors.joinPaths}
      */
     joinPaths(...paths) {
         return path_1.default.join(...paths);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getItem}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getItem}
      */
     getItem(itemPath) {
         return (0, ts_utils_1.captureResult)(() => {
@@ -90,13 +93,13 @@ class FsFileTreeAccessors {
         });
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContents}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getFileContents}
      */
     getFileContents(filePath) {
         return (0, ts_utils_1.captureResult)(() => fs_1.default.readFileSync(this.resolveAbsolutePath(filePath), 'utf8'));
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContentType}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getFileContentType}
      */
     getFileContentType(filePath, provided) {
         if (provided !== undefined) {
@@ -106,7 +109,7 @@ class FsFileTreeAccessors {
         return this._inferContentType(filePath);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getChildren}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getChildren}
      */
     getChildren(dirPath) {
         return (0, ts_utils_1.captureResult)(() => {
@@ -124,6 +127,98 @@ class FsFileTreeAccessors {
             return children;
         });
     }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.fileIsMutable}
+     */
+    fileIsMutable(path) {
+        const absolutePath = this.resolveAbsolutePath(path);
+        // Check if mutability is disabled
+        if (this._mutable === false) {
+            return (0, ts_utils_1.failWithDetail)(`${absolutePath}: mutability is disabled`, 'not-mutable');
+        }
+        // Check if path is excluded by filter
+        if (!(0, filterSpec_1.isPathMutable)(absolutePath, this._mutable)) {
+            return (0, ts_utils_1.failWithDetail)(`${absolutePath}: path is excluded by filter`, 'path-excluded');
+        }
+        // Check file system permissions
+        try {
+            // Check if file exists
+            if (fs_1.default.existsSync(absolutePath)) {
+                fs_1.default.accessSync(absolutePath, fs_1.default.constants.W_OK);
+            }
+            else {
+                // Check if parent directory is writable
+                const parentDir = absolutePath.substring(0, absolutePath.lastIndexOf('/'));
+                if (parentDir && fs_1.default.existsSync(parentDir)) {
+                    fs_1.default.accessSync(parentDir, fs_1.default.constants.W_OK);
+                }
+            }
+            return (0, ts_utils_1.succeedWithDetail)(true, 'persistent');
+            /* c8 ignore next 3 - unreachable when running as root (CI), tested in mutableFsTree.test.ts */
+        }
+        catch (_a) {
+            return (0, ts_utils_1.failWithDetail)(`${absolutePath}: permission denied`, 'permission-denied');
+        }
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.saveFileContents}
+     */
+    saveFileContents(path, contents) {
+        return this.fileIsMutable(path).asResult.onSuccess(() => {
+            const absolutePath = this.resolveAbsolutePath(path);
+            return (0, ts_utils_1.captureResult)(() => {
+                fs_1.default.writeFileSync(absolutePath, contents, 'utf8');
+                return contents;
+            });
+        });
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.deleteFile}
+     */
+    deleteFile(path) {
+        return this.fileIsMutable(path).asResult.onSuccess(() => {
+            const absolutePath = this.resolveAbsolutePath(path);
+            return (0, ts_utils_1.captureResult)(() => {
+                const stat = fs_1.default.statSync(absolutePath);
+                if (!stat.isFile()) {
+                    throw new Error(`${absolutePath}: not a file`);
+                }
+                fs_1.default.unlinkSync(absolutePath);
+                return true;
+            });
+        });
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.createDirectory}
+     */
+    createDirectory(dirPath) {
+        const absolutePath = this.resolveAbsolutePath(dirPath);
+        // Check if mutability is disabled
+        if (this._mutable === false) {
+            return (0, ts_utils_1.fail)(`${absolutePath}: mutability is disabled`);
+        }
+        return (0, ts_utils_1.captureResult)(() => {
+            fs_1.default.mkdirSync(absolutePath, { recursive: true });
+            return absolutePath;
+        });
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.deleteDirectory}
+     */
+    deleteDirectory(dirPath) {
+        return this.fileIsMutable(dirPath).asResult.onSuccess(() => {
+            const absolutePath = this.resolveAbsolutePath(dirPath);
+            return (0, ts_utils_1.captureResult)(() => {
+                const stat = fs_1.default.statSync(absolutePath);
+                if (!stat.isDirectory()) {
+                    throw new Error(`${absolutePath}: not a directory`);
+                }
+                // fs.rmdirSync fails if directory is non-empty (desired behavior)
+                fs_1.default.rmdirSync(absolutePath);
+                return true;
+            });
+        });
+    }
 }
 exports.FsFileTreeAccessors = FsFileTreeAccessors;
 //# sourceMappingURL=fsTree.js.map

package/lib/packlets/file-tree/in-memory/inMemoryTree.d.ts

@@ -1,5 +1,5 @@
-import { Result } from '@fgv/ts-utils';
-import { FileTreeItem, IFileTreeAccessors, IFileTreeInitParams } from '../fileTreeAccessors';
+import { DetailedResult, Result } from '@fgv/ts-utils';
+import { FileTreeItem, IFileTreeInitParams, IMutableFileTreeAccessors, SaveDetail } from '../fileTreeAccessors';
 /**
  * Represents a single file in an in-memory {@link FileTree | file tree}.
  * @public
@@ -19,13 +19,16 @@ export interface IInMemoryFile<TCT extends string = string> {
     readonly contentType?: TCT;
 }
 /**
- * Implementation of {@link FileTree.IFileTreeAccessors} that uses an in-memory
- * tree to access files and directories.
+ * Implementation of {@link FileTree.IMutableFileTreeAccessors} that uses an in-memory
+ * tree to access and modify files and directories.
  * @public
  */
-export declare class InMemoryTreeAccessors<TCT extends string = string> implements IFileTreeAccessors<TCT> {
+export declare class InMemoryTreeAccessors<TCT extends string = string> implements IMutableFileTreeAccessors<TCT> {
     private readonly _tree;
     private readonly _inferContentType;
+    private readonly _mutable;
+    private readonly _mutableByPath;
+    private readonly _mutableRoot;
     /**
      * Protected constructor for derived classes.
      * @param files - An array of {@link FileTree.IInMemoryFile | in-memory files} to include in the tree.
@@ -48,36 +51,57 @@ export declare class InMemoryTreeAccessors<TCT extends string = string> implemen
      */
     static create<TCT extends string = string>(files: IInMemoryFile<TCT>[], params?: IFileTreeInitParams<TCT>): Result<InMemoryTreeAccessors<TCT>>;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
+     * {@inheritDoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
      */
     resolveAbsolutePath(...paths: string[]): string;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getExtension}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getExtension}
      */
     getExtension(path: string): string;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getBaseName}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getBaseName}
      */
     getBaseName(path: string, suffix?: string): string;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.joinPaths}
+     * {@inheritDoc FileTree.IFileTreeAccessors.joinPaths}
      */
     joinPaths(...paths: string[]): string;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getItem}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getItem}
      */
     getItem(itemPath: string): Result<FileTreeItem<TCT>>;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContents}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getFileContents}
      */
     getFileContents(path: string): Result<string>;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContentType}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getFileContentType}
      */
     getFileContentType(path: string, provided?: string): Result<TCT | undefined>;
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getChildren}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getChildren}
      */
     getChildren(path: string): Result<ReadonlyArray<FileTreeItem<TCT>>>;
+    private _addMutableFile;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.createDirectory}
+     */
+    createDirectory(dirPath: string): Result<string>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.fileIsMutable}
+     */
+    fileIsMutable(path: string): DetailedResult<boolean, SaveDetail>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.deleteFile}
+     */
+    deleteFile(path: string): Result<boolean>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.deleteDirectory}
+     */
+    deleteDirectory(path: string): Result<boolean>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.saveFileContents}
+     */
+    saveFileContents(path: string, contents: string): Result<string>;
 }
 //# sourceMappingURL=inMemoryTree.d.ts.map

package/lib/packlets/file-tree/in-memory/inMemoryTree.js

@@ -26,9 +26,82 @@ const ts_utils_1 = require("@fgv/ts-utils");
 const directoryItem_1 = require("../directoryItem");
 const fileItem_1 = require("../fileItem");
 const treeBuilder_1 = require("./treeBuilder");
+const filterSpec_1 = require("../filterSpec");
 /**
- * Implementation of {@link FileTree.IFileTreeAccessors} that uses an in-memory
- * tree to access files and directories.
+ * A mutable in-memory file that allows updating contents.
+ * @internal
+ */
+class MutableInMemoryFile {
+    constructor(absolutePath, contents, contentType) {
+        this.absolutePath = absolutePath;
+        this._contents = contents;
+        this.contentType = contentType;
+    }
+    get contents() {
+        return this._contents;
+    }
+    setContents(contents) {
+        this._contents = contents;
+    }
+}
+/**
+ * A mutable in-memory directory that creates mutable files.
+ * @internal
+ */
+class MutableInMemoryDirectory {
+    /* c8 ignore next 3 - internal getter used by tree traversal */
+    get children() {
+        return this._children;
+    }
+    constructor(absolutePath) {
+        this.absolutePath = absolutePath;
+        this._children = new Map();
+    }
+    getChildPath(name) {
+        if (this.absolutePath === '/') {
+            return `/${name}`;
+        }
+        return [this.absolutePath, name].join('/');
+    }
+    addFile(name, contents, contentType) {
+        /* c8 ignore next 3 - defensive: duplicate detection during construction */
+        if (this._children.has(name)) {
+            return (0, ts_utils_1.fail)(`${name}: already exists`);
+        }
+        const child = new MutableInMemoryFile(this.getChildPath(name), contents, contentType);
+        this._children.set(name, child);
+        return (0, ts_utils_1.succeed)(child);
+    }
+    getOrAddDirectory(name) {
+        const existing = this._children.get(name);
+        if (existing) {
+            if (existing instanceof MutableInMemoryDirectory) {
+                return (0, ts_utils_1.succeed)(existing);
+            }
+            return (0, ts_utils_1.fail)(`${name}: not a directory`);
+        }
+        const child = new MutableInMemoryDirectory(this.getChildPath(name));
+        this._children.set(name, child);
+        return (0, ts_utils_1.succeed)(child);
+    }
+    updateOrAddFile(name, contents, contentType) {
+        const existing = this._children.get(name);
+        if (existing) {
+            if (existing instanceof MutableInMemoryFile) {
+                existing.setContents(contents);
+                return (0, ts_utils_1.succeed)(existing);
+            }
+            return (0, ts_utils_1.fail)(`${name}: not a file`);
+        }
+        return this.addFile(name, contents, contentType);
+    }
+    removeChild(name) {
+        return this._children.delete(name);
+    }
+}
+/**
+ * Implementation of {@link FileTree.IMutableFileTreeAccessors} that uses an in-memory
+ * tree to access and modify files and directories.
  * @public
  */
 class InMemoryTreeAccessors {
@@ -39,12 +112,18 @@ class InMemoryTreeAccessors {
      * @public
      */
     constructor(files, params) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         this._tree = treeBuilder_1.TreeBuilder.create(params === null || params === void 0 ? void 0 : params.prefix).orThrow();
         this._inferContentType = (_a = params === null || params === void 0 ? void 0 : params.inferContentType) !== null && _a !== void 0 ? _a : fileItem_1.FileItem.defaultInferContentType;
+        this._mutable = (_b = params === null || params === void 0 ? void 0 : params.mutable) !== null && _b !== void 0 ? _b : false;
+        this._mutableByPath = new Map();
+        const prefix = (_c = params === null || params === void 0 ? void 0 : params.prefix) !== null && _c !== void 0 ? _c : '/';
+        this._mutableRoot = new MutableInMemoryDirectory(prefix.endsWith('/') ? prefix.slice(0, -1) || '/' : prefix);
+        this._mutableByPath.set(this._mutableRoot.absolutePath, this._mutableRoot);
         for (const file of files) {
-            const contentType = (_b = file.contentType) !== null && _b !== void 0 ? _b : this._inferContentType(file.path).orDefault();
+            const contentType = (_d = file.contentType) !== null && _d !== void 0 ? _d : this._inferContentType(file.path).orDefault();
             this._tree.addFile(file.path, file.contents, contentType).orThrow();
+            this._addMutableFile(file.path, file.contents, contentType);
         }
     }
     /**
@@ -59,7 +138,7 @@ class InMemoryTreeAccessors {
         return (0, ts_utils_1.captureResult)(() => new InMemoryTreeAccessors(files, params));
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
+     * {@inheritDoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
      */
     resolveAbsolutePath(...paths) {
         const parts = paths[0].startsWith('/') ? paths : [this._tree.prefix, ...paths];
@@ -67,7 +146,7 @@ class InMemoryTreeAccessors {
         return `/${joined}`;
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getExtension}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getExtension}
      */
     getExtension(path) {
         const parts = path.split('.');
@@ -77,7 +156,7 @@ class InMemoryTreeAccessors {
         return `.${parts.pop()}`;
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getBaseName}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getBaseName}
      */
     getBaseName(path, suffix) {
         var _a;
@@ -89,13 +168,15 @@ class InMemoryTreeAccessors {
         return base;
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.joinPaths}
+     * {@inheritDoc FileTree.IFileTreeAccessors.joinPaths}
      */
     joinPaths(...paths) {
-        return paths.join('/');
+        var _a;
+        const joined = paths.flatMap((p) => p.split('/').filter((s) => s.length > 0)).join('/');
+        return ((_a = paths[0]) === null || _a === void 0 ? void 0 : _a.startsWith('/')) ? `/${joined}` : joined;
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getItem}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getItem}
      */
     getItem(itemPath) {
         const existing = this._tree.byAbsolutePath.get(itemPath);
@@ -110,26 +191,24 @@ class InMemoryTreeAccessors {
         return (0, ts_utils_1.fail)(`${itemPath}: not found`);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContents}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getFileContents}
      */
     getFileContents(path) {
-        const item = this._tree.byAbsolutePath.get(path);
+        const absolutePath = this.resolveAbsolutePath(path);
+        const item = this._mutableByPath.get(absolutePath);
         if (item === undefined) {
-            return (0, ts_utils_1.fail)(`${path}: not found`);
+            return (0, ts_utils_1.fail)(`${absolutePath}: not found`);
         }
-        /* c8 ignore next 3 - local coverage is 100% but build coverage has intermittent issues */
-        if (!(item instanceof treeBuilder_1.InMemoryFile)) {
-            return (0, ts_utils_1.fail)(`${path}: not a file`);
+        if (!(item instanceof MutableInMemoryFile)) {
+            return (0, ts_utils_1.fail)(`${absolutePath}: not a file`);
         }
-        // if the body is a string we don't want to add quotes
         if (typeof item.contents === 'string') {
             return (0, ts_utils_1.succeed)(item.contents);
         }
-        /* c8 ignore next 2 - local coverage is 100% but build coverage has intermittent issues */
         return (0, ts_utils_1.captureResult)(() => JSON.stringify(item.contents));
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContentType}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getFileContentType}
      */
     getFileContentType(path, provided) {
         // If provided contentType is given, use it directly (highest priority)
@@ -152,7 +231,7 @@ class InMemoryTreeAccessors {
         return this._inferContentType(path);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getChildren}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getChildren}
      */
     getChildren(path) {
         const item = this._tree.byAbsolutePath.get(path);
@@ -176,6 +255,185 @@ class InMemoryTreeAccessors {
             return children;
         });
     }
+    _addMutableFile(path, contents, contentType) {
+        const absolutePath = this.resolveAbsolutePath(path);
+        const parts = absolutePath.split('/').filter((p) => p.length > 0);
+        /* c8 ignore next 3 - defensive: invalid path detection */
+        if (parts.length === 0) {
+            return (0, ts_utils_1.fail)(`${absolutePath}: invalid file path`);
+        }
+        let dir = this._mutableRoot;
+        while (parts.length > 1) {
+            const part = parts.shift();
+            const result = dir.getOrAddDirectory(part);
+            /* c8 ignore next 3 - defensive: directory conflict during construction */
+            if (result.isFailure()) {
+                return (0, ts_utils_1.fail)(result.message);
+            }
+            dir = result.value;
+            if (!this._mutableByPath.has(dir.absolutePath)) {
+                this._mutableByPath.set(dir.absolutePath, dir);
+            }
+        }
+        return dir.addFile(parts[0], contents, contentType).onSuccess((file) => {
+            this._mutableByPath.set(file.absolutePath, file);
+            return (0, ts_utils_1.succeed)(file);
+        });
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.createDirectory}
+     */
+    createDirectory(dirPath) {
+        const absolutePath = this.resolveAbsolutePath(dirPath);
+        // Check if mutability is disabled
+        if (this._mutable === false) {
+            return (0, ts_utils_1.fail)(`${absolutePath}: mutability is disabled`);
+        }
+        // Add to the TreeBuilder (read layer)
+        const treeResult = this._tree.addDirectory(absolutePath);
+        /* c8 ignore next 3 - defensive: read layer failure would indicate internal inconsistency */
+        if (treeResult.isFailure()) {
+            return (0, ts_utils_1.fail)(treeResult.message);
+        }
+        // Add to the mutable layer
+        const parts = absolutePath.split('/').filter((p) => p.length > 0);
+        let dir = this._mutableRoot;
+        for (const part of parts) {
+            const result = dir.getOrAddDirectory(part);
+            /* c8 ignore next 3 - defensive: mutable layer should match read layer state */
+            if (result.isFailure()) {
+                return (0, ts_utils_1.fail)(result.message);
+            }
+            dir = result.value;
+            if (!this._mutableByPath.has(dir.absolutePath)) {
+                this._mutableByPath.set(dir.absolutePath, dir);
+            }
+        }
+        return (0, ts_utils_1.succeed)(absolutePath);
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.fileIsMutable}
+     */
+    fileIsMutable(path) {
+        const absolutePath = this.resolveAbsolutePath(path);
+        // Check if mutability is disabled
+        if (this._mutable === false) {
+            return (0, ts_utils_1.failWithDetail)(`${absolutePath}: mutability is disabled`, 'not-mutable');
+        }
+        // Check if path is excluded by filter
+        if (!(0, filterSpec_1.isPathMutable)(absolutePath, this._mutable)) {
+            return (0, ts_utils_1.failWithDetail)(`${absolutePath}: path is excluded by filter`, 'path-excluded');
+        }
+        return (0, ts_utils_1.succeedWithDetail)(true, 'transient');
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.deleteFile}
+     */
+    deleteFile(path) {
+        const absolutePath = this.resolveAbsolutePath(path);
+        const parts = absolutePath.split('/').filter((p) => p.length > 0);
+        if (parts.length === 0) {
+            return (0, ts_utils_1.fail)(`${absolutePath}: invalid file path`);
+        }
+        const fileName = parts.pop();
+        // Navigate to parent directory
+        let dir = this._mutableRoot;
+        for (const part of parts) {
+            const child = dir.children.get(part);
+            if (!child || !(child instanceof MutableInMemoryDirectory)) {
+                return (0, ts_utils_1.fail)(`${absolutePath}: parent directory not found`);
+            }
+            dir = child;
+        }
+        if (!dir.removeChild(fileName)) {
+            return (0, ts_utils_1.fail)(`${absolutePath}: file not found`);
+        }
+        // Also remove from the read layer's directory children and path index
+        const parentPath = parts.length === 0 ? '/' : '/' + parts.join('/');
+        const readParent = this._tree.byAbsolutePath.get(parentPath);
+        if (readParent instanceof treeBuilder_1.InMemoryDirectory) {
+            readParent.removeChild(fileName);
+        }
+        this._tree.byAbsolutePath.delete(absolutePath);
+        this._mutableByPath.delete(absolutePath);
+        return (0, ts_utils_1.succeed)(true);
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.deleteDirectory}
+     */
+    deleteDirectory(path) {
+        const absolutePath = this.resolveAbsolutePath(path);
+        const parts = absolutePath.split('/').filter((p) => p.length > 0);
+        if (parts.length === 0) {
+            return (0, ts_utils_1.fail)(`${absolutePath}: invalid directory path`);
+        }
+        const dirName = parts.pop();
+        // Navigate to parent directory
+        let parentDir = this._mutableRoot;
+        for (const part of parts) {
+            const child = parentDir.children.get(part);
+            if (!child || !(child instanceof MutableInMemoryDirectory)) {
+                return (0, ts_utils_1.fail)(`${absolutePath}: parent directory not found`);
+            }
+            parentDir = child;
+        }
+        // Verify target is a directory
+        const target = parentDir.children.get(dirName);
+        if (!target || !(target instanceof MutableInMemoryDirectory)) {
+            return (0, ts_utils_1.fail)(`${absolutePath}: not a directory`);
+        }
+        // Check non-empty
+        if (target.children.size > 0) {
+            return (0, ts_utils_1.fail)(`${absolutePath}: directory is not empty`);
+        }
+        parentDir.removeChild(dirName);
+        // Also remove from the read layer
+        /* c8 ignore next 1 - defensive: branch for top-level directory deletion */
+        const readParentPath = parts.length === 0 ? '/' : '/' + parts.join('/');
+        const readParent = this._tree.byAbsolutePath.get(readParentPath);
+        if (readParent instanceof treeBuilder_1.InMemoryDirectory) {
+            readParent.removeChild(dirName);
+        }
+        this._tree.byAbsolutePath.delete(absolutePath);
+        this._mutableByPath.delete(absolutePath);
+        return (0, ts_utils_1.succeed)(true);
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.saveFileContents}
+     */
+    saveFileContents(path, contents) {
+        const isMutable = this.fileIsMutable(path);
+        if (isMutable.isFailure()) {
+            return (0, ts_utils_1.fail)(isMutable.message);
+        }
+        const absolutePath = this.resolveAbsolutePath(path);
+        const parts = absolutePath.split('/').filter((p) => p.length > 0);
+        if (parts.length === 0) {
+            return (0, ts_utils_1.fail)(`${absolutePath}: invalid file path`);
+        }
+        // Navigate to parent directory, creating directories as needed
+        let dir = this._mutableRoot;
+        while (parts.length > 1) {
+            const part = parts.shift();
+            const result = dir.getOrAddDirectory(part);
+            if (result.isFailure()) {
+                return (0, ts_utils_1.fail)(result.message);
+            }
+            dir = result.value;
+            if (!this._mutableByPath.has(dir.absolutePath)) {
+                this._mutableByPath.set(dir.absolutePath, dir);
+            }
+        }
+        // Update or add the file in the mutable layer
+        return dir.updateOrAddFile(parts[0], contents).onSuccess((file) => {
+            this._mutableByPath.set(file.absolutePath, file);
+            // Also register in the read layer so getItem/getChildren can find it
+            if (!this._tree.byAbsolutePath.has(file.absolutePath)) {
+                this._tree.addFile(file.absolutePath, contents);
+            }
+            return (0, ts_utils_1.succeed)(contents);
+        });
+    }
 }
 exports.InMemoryTreeAccessors = InMemoryTreeAccessors;
 //# sourceMappingURL=inMemoryTree.js.map

package/lib/packlets/file-tree/in-memory/treeBuilder.d.ts

@@ -59,6 +59,12 @@ export declare class InMemoryDirectory<TCT extends string = string> {
      * `Failure` with an error message otherwise.
      */
     addFile(name: string, contents: unknown, contentType?: TCT): Result<InMemoryFile<TCT>>;
+    /**
+     * Removes a child from the directory.
+     * @param name - The name of the child to remove.
+     * @returns `true` if the child was found and removed, `false` otherwise.
+     */
+    removeChild(name: string): boolean;
     /**
      * Gets the absolute path for a child of this directory with the supplied
      * name.
@@ -109,5 +115,14 @@ export declare class TreeBuilder<TCT extends string = string> {
      * @public
      */
     addFile(absolutePath: string, contents: unknown, contentType?: TCT): Result<InMemoryFile<TCT>>;
+    /**
+     * Ensures a directory exists at the given absolute path, creating
+     * intermediate directories as needed.
+     * @param absolutePath - The absolute path of the directory.
+     * @returns `Success` with the directory if successful, or
+     * `Failure` with an error message otherwise.
+     * @public
+     */
+    addDirectory(absolutePath: string): Result<InMemoryDirectory<TCT>>;
 }
 //# sourceMappingURL=treeBuilder.d.ts.map