@dbx-tools/shared-fs 0.6.10

package/lib/src/base-fs.js

@@ -0,0 +1,622 @@
+/**
+ * Abstract {@link FileSystem} base: lifecycle, rooted POSIX paths, encoding, and
+ * portable fallbacks so a concrete backend only implements low-level I/O.
+ *
+ * A new adapter typically overrides:
+ * - {@link onInit} / {@link onClose} (optional)
+ * - {@link createRootDirectory} when {@link BaseFileSystemOptions.createRoot} is set
+ * - {@link toBackendPath} when the backend needs non-POSIX separators
+ * - {@link preparePath} for post-resolve checks (e.g. symlink containment)
+ * - the `*At` primitives and {@link isNotFoundError}
+ * - optional `try*` hooks for native append / copy / move
+ *
+ * @module
+ */
+import { error, functionModule, hash, object } from "@dbx-tools/shared-core";
+import * as posixPath from "./posix-path.js";
+/**
+ * Characters no backend accepts inside a single path component: a separator
+ * (which would silently deepen the path) or a NUL / control character.
+ *
+ * This is a DENY-list on purpose. Spaces, `@`, `&`, `#`, parentheses and
+ * non-ASCII are all legal directory names on POSIX and in a Databricks
+ * workspace, and replacing one with a hash points the filesystem at a
+ * directory that does not exist - a failure that is silent and very hard to
+ * trace back. Only reject what genuinely cannot be a component.
+ */
+const UNSAFE_PATH_SEGMENT = /[\\/\u0000-\u001F\u007F]/;
+/**
+ * Turn {@link root} into a POSIX filesystem root:
+ *
+ * 1. Expand one-or-many input segments
+ * 2. Strings split on `/` (and `\`); objects/arrays FNV-hash as one piece
+ * 3. Each resulting component that cannot be a path component - see
+ *    {@link UNSAFE_PATH_SEGMENT} - is replaced with {@link hash.fnvHash}
+ * 4. Join with `/` and run {@link posixPath.normalizeRoot}
+ *
+ * Defaults to `/`. A leading `/` on the first string segment is preserved.
+ *
+ * @example
+ * normalizeFileSystemRoot("/cool/wow"); // "/cool/wow"
+ * normalizeFileSystemRoot("/Users/me@corp.com/My Notes"); // unchanged
+ * normalizeFileSystemRoot(["/path", { user: 1 }, true]); // "/path/<hash>/true"
+ */
+export function normalizeFileSystemRoot(root) {
+    if (root === undefined)
+        return "/";
+    const segments = object.toOneOrMany(root);
+    const absolute = isAbsoluteRootStart(segments[0]);
+    const parts = [];
+    for (const segment of segments) {
+        if (segment === null || segment === undefined) {
+            throw new TypeError("Filesystem root segments must be non-null");
+        }
+        appendRootParts(parts, segment);
+    }
+    if (parts.length === 0)
+        return "/";
+    const joined = parts.join("/");
+    return posixPath.normalizeRoot(absolute ? `/${joined}` : joined);
+}
+function isAbsoluteRootStart(segment) {
+    return typeof segment === "string" && posixPath.isAbsolute(segment.trim());
+}
+function appendRootParts(parts, segment) {
+    switch (typeof segment) {
+        case "string":
+            for (const piece of splitPathPieces(segment)) {
+                parts.push(sanitizePathSegment(piece));
+            }
+            return;
+        case "number":
+        case "boolean":
+        case "bigint":
+            parts.push(sanitizePathSegment(String(segment)));
+            return;
+        default:
+            parts.push(hash.fnvHash(segment));
+    }
+}
+/**
+ * Split on `/` (after `\` → `/`); drop empty pieces from
+ * leading/trailing/double slashes and no-op `.` pieces.
+ */
+function splitPathPieces(input) {
+    return posixPath
+        .toPosix(input.trim())
+        .split("/")
+        .filter((piece) => piece.length > 0 && piece !== ".");
+}
+/**
+ * Keep a usable path component verbatim; FNV-hash one that cannot be used.
+ *
+ * `..` is hashed rather than dropped so a root can never traverse above
+ * itself while the offending segment stays visible in the resolved root.
+ */
+function sanitizePathSegment(segment) {
+    if (segment === ".." || UNSAFE_PATH_SEGMENT.test(segment)) {
+        return hash.fnvHash(segment);
+    }
+    return segment;
+}
+export class FileSystemError extends Error {
+    code;
+    path;
+    name = "FileSystemError";
+    constructor(code, message, path, options) {
+        super(message, options?.cause !== undefined ? { cause: error.toError(options.cause) } : undefined);
+        this.code = code;
+        this.path = path;
+    }
+}
+/**
+ * Infer a {@link FileSystemErrorCode} from HTTP status / message tokens on an
+ * unknown thrown value (via {@link error.errorContext}).
+ *
+ * Covers common SDK / REST wording so adapters do not reimplement the same
+ * "not found" / "already exists" checks. Returns undefined when nothing matches.
+ */
+export function inferFileSystemErrorCode(err) {
+    const ctx = error.errorContext(err);
+    if (ctx.hasStatusCode(404) || ctx.hasMessage("not", "found") || ctx.hasMessage("not", "exist")) {
+        return "NOT_FOUND";
+    }
+    if (ctx.hasStatusCode(409) || ctx.hasMessage("already", "exists")) {
+        return "ALREADY_EXISTS";
+    }
+    // Before "not"+"directory": "directory not empty" contains both of those tokens.
+    if (ctx.hasMessage("not", "empty")) {
+        return "DIRECTORY_NOT_EMPTY";
+    }
+    if (ctx.hasMessage("not", "directory")) {
+        return "NOT_DIRECTORY";
+    }
+    if (ctx.hasMessage("is", "directory") || ctx.hasMessage("not", "file")) {
+        return "IS_DIRECTORY";
+    }
+    if (ctx.hasStatusCode(401, 403) ||
+        ctx.hasMessage("permission", "denied") ||
+        ctx.hasMessage("access", "denied")) {
+        return "PERMISSION_DENIED";
+    }
+    if (ctx.hasMessage("read", "only")) {
+        return "READ_ONLY";
+    }
+    return undefined;
+}
+/**
+ * Map an unknown backend failure into a {@link FileSystemError}.
+ *
+ * Prefer a backend-specific {@link codeOf} classifier (errno, SDK code). When
+ * it returns undefined, falls back to {@link inferFileSystemErrorCode}. Message
+ * and cause always go through `@dbx-tools/shared-core` {@link error} helpers.
+ */
+export function mapFileSystemError(err, filePath, codeOf) {
+    if (err instanceof FileSystemError)
+        return err;
+    const message = error.errorMessage(err);
+    return new FileSystemError(codeOf?.(err) ?? inferFileSystemErrorCode(err) ?? "IO_ERROR", message || `Filesystem operation failed: ${filePath}`, filePath, { cause: error.toError(err) });
+}
+/**
+ * Base implementation for local, remote, and virtual filesystems.
+ *
+ * Subclasses implement the low-level `*At` primitives. This class provides:
+ *
+ * - Memoized {@link _init} (so an explicit {@link init} call is optional)
+ * - Optional root creation via {@link createRootDirectory}
+ * - POSIX-only rooted path normalization and traversal protection
+ * - {@link toBackendPath} for host/separator conversion at the boundary
+ * - Text encoding and decoding
+ * - {@link exists}
+ * - Parent-directory creation on write / append / copy / move
+ * - Append / copy / move fallbacks (override `try*` for native ops)
+ * - Recursive mkdir, readdir, and rmdir
+ * - Extension filtering for {@link readdir}
+ *
+ * Namespace paths always use `/`. Host adapters convert with
+ * {@link posixPath.toPosix} / {@link posixPath.toHost} in {@link toBackendPath}.
+ */
+export class BaseFileSystem {
+    id;
+    backend;
+    /** POSIX-normalized root (see {@link posixPath.normalizeRoot}). */
+    root;
+    readOnly;
+    createRoot;
+    /**
+     * Memoized initialization. Every operation that needs a ready backend awaits
+     * this, so callers (e.g. Mastra) may call {@link init} every time or never;
+     * both are fine.
+     */
+    _init;
+    initStarted = false;
+    constructor(options) {
+        this.id = options.id;
+        this.backend = options.backend;
+        this.root = normalizeFileSystemRoot(options.root);
+        this.readOnly = options.readOnly ?? false;
+        this.createRoot = options.createRoot ?? false;
+        this._init = this.createInit();
+    }
+    /* ------------------------------------------------------------------ */
+    /* Lifecycle                                                          */
+    /* ------------------------------------------------------------------ */
+    createInit() {
+        return functionModule.memoize(async () => {
+            this.initStarted = true;
+            if (this.createRoot) {
+                await this.guard(this.root, () => this.createRootDirectory());
+            }
+            await this.onInit();
+        });
+    }
+    async init() {
+        await this._init();
+    }
+    async close() {
+        if (!this.initStarted)
+            return;
+        try {
+            await this._init();
+        }
+        catch {
+            this.initStarted = false;
+            this._init = this.createInit();
+            return;
+        }
+        await this.onClose();
+        this.initStarted = false;
+        this._init = this.createInit();
+    }
+    /**
+     * Ensure {@link root} exists when {@link createRoot} is true.
+     *
+     * Default is a no-op. Local adapters typically `mkdir -p`; remote adapters
+     * leave the default when the root is provisioned out of band.
+     */
+    async createRootDirectory() { }
+    /** Override when the backend requires connection or validation work. */
+    async onInit() { }
+    /** Override when the backend owns connections or other resources. */
+    async onClose() { }
+    assertWritable(operation) {
+        if (this.readOnly) {
+            throw new FileSystemError("READ_ONLY", `Cannot ${operation}: filesystem is read-only`);
+        }
+    }
+    /* ------------------------------------------------------------------ */
+    /* Paths (POSIX only)                                                 */
+    /* ------------------------------------------------------------------ */
+    /**
+     * Normalize an input path into an absolute POSIX path inside the virtual
+     * filesystem namespace (`/a/b`). Backslashes are converted; `..` escaping
+     * the root throws {@link FileSystemError} `PERMISSION_DENIED`.
+     */
+    normalizePath(inputPath) {
+        if (inputPath.includes("\0")) {
+            throw new FileSystemError("INVALID_PATH", "Paths cannot contain null characters", inputPath);
+        }
+        const result = posixPath.normalize(inputPath);
+        if (!result.ok) {
+            throw new FileSystemError("PERMISSION_DENIED", "Path escapes the filesystem root", inputPath);
+        }
+        return result.path;
+    }
+    /**
+     * Convert a POSIX backend path (under {@link root}) into the form the
+     * underlying API expects.
+     *
+     * Default is identity. Local disk overrides with {@link posixPath.toHost}.
+     * Databricks / object-store adapters usually leave the default.
+     */
+    toBackendPath(posixBackendPath) {
+        return posixBackendPath;
+    }
+    /**
+     * Convert a normalized namespace path (`/a/b`) into a backend path.
+     *
+     * Joins {@link root} with the namespace using POSIX `/`, then applies
+     * {@link toBackendPath}. Override {@link toBackendPath} instead of this
+     * method unless the join itself must change.
+     */
+    resolveBackendPath(namespacePath) {
+        const posix = namespacePath === "/" ? this.root : posixPath.join(this.root, namespacePath.slice(1));
+        return this.toBackendPath(posix);
+    }
+    resolvePath(inputPath) {
+        return this.resolveBackendPath(this.normalizePath(inputPath));
+    }
+    /**
+     * Resolve {@link inputPath}, ensure init, and run {@link preparePath}.
+     */
+    async resolveFor(inputPath, options) {
+        await this._init();
+        return this.resolveNamespaceFor(this.normalizePath(inputPath), options);
+    }
+    /**
+     * {@link resolveFor} for a path that is ALREADY a normalized namespace path
+     * (`/a/b`). The single spelling for "namespace path to prepared backend
+     * path", so no call site has to re-derive the chain by hand.
+     */
+    resolveNamespaceFor(namespacePath, options) {
+        return this.preparePath(this.resolveBackendPath(namespacePath), options);
+    }
+    /**
+     * Hook after lexical resolution. Override for realpath containment or
+     * similar backend-specific checks. Default is a no-op.
+     */
+    async preparePath(resolvedPath, _options) {
+        return resolvedPath;
+    }
+    joinNamespace(parent, child) {
+        return this.normalizePath(posixPath.join(parent, child));
+    }
+    /** Namespace path without a leading slash (`.` for the root). */
+    toRelativePath(namespacePath) {
+        return namespacePath === "/" ? "." : namespacePath.slice(1);
+    }
+    toBytes(content) {
+        return typeof content === "string" ? new TextEncoder().encode(content) : content;
+    }
+    /** Create parent directories for {@link inputPath} when it is nested. */
+    async ensureParentDirectory(inputPath) {
+        const namespacePath = this.normalizePath(inputPath);
+        const parent = posixPath.dirname(namespacePath);
+        if (parent === "/" || parent === namespacePath)
+            return;
+        await this.mkdir(parent, { recursive: true });
+    }
+    /**
+     * Recognize the backend's not-found error.
+     *
+     * Default accepts {@link FileSystemError} `NOT_FOUND` plus common SDK / HTTP
+     * "not found" shapes via {@link inferFileSystemErrorCode}. Override for
+     * backend-specific codes (e.g. Node `ENOENT`) that do not carry a message.
+     */
+    isNotFoundError(err) {
+        if (err instanceof FileSystemError)
+            return err.code === "NOT_FOUND";
+        return inferFileSystemErrorCode(err) === "NOT_FOUND";
+    }
+    /**
+     * Normalize a backend failure into a {@link FileSystemError}.
+     *
+     * Every `*At` / `try*` primitive is invoked through {@link guard}, so an
+     * adapter never writes its own try/catch and cannot forget to normalize.
+     * Override only to classify backend-specific codes (e.g. Node errno).
+     */
+    mapError(err, filePath) {
+        return mapFileSystemError(err, filePath);
+    }
+    /** Run a backend primitive, routing any failure through {@link mapError}. */
+    async guard(resolvedPath, operation) {
+        try {
+            return await operation();
+        }
+        catch (err) {
+            throw this.mapError(err, resolvedPath);
+        }
+    }
+    /* ------------------------------------------------------------------ */
+    /* Optional native-operation hooks                                    */
+    /* ------------------------------------------------------------------ */
+    /**
+     * Override when the backend supports native append.
+     *
+     * Parent directories are already created by {@link appendFile}. Return true
+     * when the operation was performed. The default causes {@link BaseFileSystem}
+     * to use read-concatenate-write.
+     */
+    async tryAppendFileAt(_resolvedPath, _content) {
+        return false;
+    }
+    /**
+     * Override when the backend supports native server-side copying.
+     *
+     * Parent directories of the destination are already created by {@link copyFile}.
+     */
+    async tryCopyFileAt(_sourcePath, _destinationPath, _options) {
+        return false;
+    }
+    /**
+     * Override for native rename or move support.
+     *
+     * Parent directories of the destination are already created by {@link moveFile}.
+     */
+    async tryMoveFileAt(_sourcePath, _destinationPath, _options) {
+        return false;
+    }
+    async readFile(inputPath, options) {
+        const resolvedPath = await this.resolveFor(inputPath);
+        const content = await this.guard(resolvedPath, () => this.readBytesAt(resolvedPath));
+        if (options?.encoding) {
+            return new TextDecoder(options.encoding).decode(content);
+        }
+        return content;
+    }
+    async writeFile(inputPath, content, options = {}) {
+        await this._init();
+        this.assertWritable("write file");
+        const overwrite = await this.resolveOverwrite(inputPath, options, "File");
+        await this.ensureParentDirectory(inputPath);
+        const resolvedPath = await this.resolveFor(inputPath, { allowMissing: true });
+        await this.guard(resolvedPath, () => this.writeBytesAt(resolvedPath, this.toBytes(content), { overwrite }));
+    }
+    async appendFile(inputPath, content) {
+        await this._init();
+        this.assertWritable("append file");
+        const bytes = this.toBytes(content);
+        await this.ensureParentDirectory(inputPath);
+        const resolvedPath = await this.resolveFor(inputPath, { allowMissing: true });
+        if (await this.guard(resolvedPath, () => this.tryAppendFileAt(resolvedPath, bytes))) {
+            return;
+        }
+        const existing = (await this.exists(inputPath))
+            ? await this.readFile(inputPath)
+            : new Uint8Array();
+        const combined = new Uint8Array(existing.byteLength + bytes.byteLength);
+        combined.set(existing);
+        combined.set(bytes, existing.byteLength);
+        await this.writeFile(inputPath, combined, { overwrite: true });
+    }
+    async deleteFile(inputPath, options = {}) {
+        await this._init();
+        this.assertWritable("delete file");
+        await this.ignoringMissing(options, async () => {
+            const entry = await this.stat(inputPath);
+            if (entry.type === "directory") {
+                throw new FileSystemError("IS_DIRECTORY", `Path is a directory: ${inputPath}`, inputPath);
+            }
+            const resolvedPath = await this.resolveFor(inputPath);
+            await this.guard(resolvedPath, () => this.deleteFileAt(resolvedPath));
+        });
+    }
+    async copyFile(sourcePath, destinationPath, options = {}) {
+        const { source, destination, resolved } = await this.prepareTransfer("copy file", sourcePath, destinationPath, options);
+        if (await this.guard(destination, () => this.tryCopyFileAt(source, destination, resolved))) {
+            return;
+        }
+        await this.writeFile(destinationPath, await this.readFile(sourcePath), resolved);
+    }
+    async moveFile(sourcePath, destinationPath, options = {}) {
+        const { source, destination, resolved } = await this.prepareTransfer("move file", sourcePath, destinationPath, options);
+        if (await this.guard(destination, () => this.tryMoveFileAt(source, destination, resolved))) {
+            return;
+        }
+        await this.copyFile(sourcePath, destinationPath, resolved);
+        const sourceStat = await this.stat(sourcePath);
+        if (sourceStat.type === "directory") {
+            await this.rmdir(sourcePath, { recursive: true });
+        }
+        else {
+            await this.deleteFile(sourcePath);
+        }
+    }
+    /**
+     * Resolve the effective `overwrite` flag, rejecting when the target exists
+     * and overwriting was refused. Shared by write / copy / move so the three
+     * cannot disagree about what `overwrite: false` means.
+     */
+    async resolveOverwrite(inputPath, options, label) {
+        const overwrite = options.overwrite ?? true;
+        if (!overwrite && (await this.exists(inputPath))) {
+            throw new FileSystemError("ALREADY_EXISTS", `${label} already exists: ${inputPath}`, inputPath);
+        }
+        return overwrite;
+    }
+    /** Shared copy / move prologue: writability, overwrite policy, both ends resolved. */
+    async prepareTransfer(operation, sourcePath, destinationPath, options) {
+        await this._init();
+        this.assertWritable(operation);
+        const overwrite = await this.resolveOverwrite(destinationPath, options, "Destination");
+        await this.ensureParentDirectory(destinationPath);
+        return {
+            source: await this.resolveFor(sourcePath),
+            destination: await this.resolveFor(destinationPath, { allowMissing: true }),
+            resolved: { overwrite },
+        };
+    }
+    /** Run a removal, swallowing a not-found failure when `force` is set. */
+    async ignoringMissing(options, operation) {
+        try {
+            await operation();
+        }
+        catch (err) {
+            if (options.force && this.isNotFoundError(err))
+                return;
+            throw err;
+        }
+    }
+    /* ------------------------------------------------------------------ */
+    /* Directory operations                                               */
+    /* ------------------------------------------------------------------ */
+    async mkdir(inputPath, options = {}) {
+        await this._init();
+        this.assertWritable("create directory");
+        const namespacePath = this.normalizePath(inputPath);
+        if (!options.recursive) {
+            await this.createDirectory(namespacePath);
+            return;
+        }
+        let currentPath = "";
+        for (const segment of namespacePath.split("/").filter(Boolean)) {
+            currentPath = `${currentPath}/${segment}`;
+            try {
+                const entry = await this.stat(currentPath);
+                if (entry.type !== "directory") {
+                    throw new FileSystemError("NOT_DIRECTORY", `Path component is not a directory: ${currentPath}`, currentPath);
+                }
+            }
+            catch (error) {
+                if (!this.isNotFoundError(error))
+                    throw error;
+                await this.createDirectory(currentPath);
+            }
+        }
+    }
+    async rmdir(inputPath, options = {}) {
+        await this._init();
+        this.assertWritable("remove directory");
+        await this.ignoringMissing(options, async () => {
+            const entry = await this.stat(inputPath);
+            if (entry.type !== "directory") {
+                throw new FileSystemError("NOT_DIRECTORY", `Path is not a directory: ${inputPath}`, inputPath);
+            }
+            const namespacePath = this.normalizePath(inputPath);
+            if (options.recursive) {
+                await this.removeDirectoryContents(namespacePath);
+            }
+            await this.removeDirectory(namespacePath);
+        });
+    }
+    async removeDirectoryContents(namespacePath) {
+        for (const entry of await this.listDirectory(namespacePath)) {
+            const childPath = this.joinNamespace(namespacePath, entry.name);
+            if (entry.type === "directory") {
+                await this.removeDirectoryContents(childPath);
+                await this.removeDirectory(childPath);
+            }
+            else {
+                const resolvedPath = await this.resolveNamespaceFor(childPath);
+                await this.guard(resolvedPath, () => this.deleteFileAt(resolvedPath));
+            }
+        }
+    }
+    /** {@link createDirectoryAt} for a namespace path, resolved and guarded. */
+    async createDirectory(namespacePath) {
+        const resolvedPath = await this.resolveNamespaceFor(namespacePath, { allowMissing: true });
+        await this.guard(resolvedPath, () => this.createDirectoryAt(resolvedPath));
+    }
+    /** {@link removeDirectoryAt} for a namespace path, resolved and guarded. */
+    async removeDirectory(namespacePath) {
+        const resolvedPath = await this.resolveNamespaceFor(namespacePath);
+        await this.guard(resolvedPath, () => this.removeDirectoryAt(resolvedPath));
+    }
+    /** {@link listDirectoryAt} for a namespace path, resolved and guarded. */
+    async listDirectory(namespacePath) {
+        const resolvedPath = await this.resolveNamespaceFor(namespacePath);
+        return this.guard(resolvedPath, () => this.listDirectoryAt(resolvedPath));
+    }
+    async readdir(inputPath, options = {}) {
+        await this._init();
+        const namespacePath = this.normalizePath(inputPath);
+        if (!options.recursive) {
+            return this.filterEntries(await this.listDirectory(namespacePath), options);
+        }
+        return this.listDirectoryRecursive(namespacePath, options, 0, "");
+    }
+    async listDirectoryRecursive(namespacePath, options, depth, prefix) {
+        const maximumDepth = options.maxDepth ?? Number.POSITIVE_INFINITY;
+        const entries = this.filterEntries(await this.listDirectory(namespacePath), options);
+        const results = [];
+        for (const entry of entries) {
+            const relativeName = prefix ? `${prefix}/${entry.name}` : entry.name;
+            results.push({ ...entry, name: relativeName });
+            if (entry.type === "directory" && depth < maximumDepth) {
+                results.push(...(await this.listDirectoryRecursive(this.joinNamespace(namespacePath, entry.name), options, depth + 1, relativeName)));
+            }
+        }
+        return results;
+    }
+    filterEntries(entries, options) {
+        if (!options.extension) {
+            return entries;
+        }
+        const extensions = (Array.isArray(options.extension) ? options.extension : [options.extension]).map((extension) => {
+            const normalized = extension.toLowerCase();
+            return normalized.startsWith(".") ? normalized : `.${normalized}`;
+        });
+        return entries.filter((entry) => {
+            if (entry.type !== "file")
+                return true;
+            const lower = entry.name.toLowerCase();
+            return extensions.some((ext) => lower.endsWith(ext));
+        });
+    }
+    async exists(inputPath) {
+        await this._init();
+        try {
+            await this.stat(inputPath);
+            return true;
+        }
+        catch (error) {
+            if (this.isNotFoundError(error))
+                return false;
+            if (error instanceof FileSystemError && error.code === "PERMISSION_DENIED") {
+                return false;
+            }
+            throw error;
+        }
+    }
+    async stat(inputPath) {
+        await this._init();
+        const namespacePath = this.normalizePath(inputPath);
+        const resolvedPath = await this.resolveNamespaceFor(namespacePath);
+        const entry = await this.guard(resolvedPath, () => this.statAt(resolvedPath));
+        return {
+            ...entry,
+            path: this.toRelativePath(namespacePath),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-fs.js","sourceRoot":"","sources":["../../src/base-fs.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Abstract {@link FileSystem} base: lifecycle, rooted POSIX paths, encoding, and\n * portable fallbacks so a concrete backend only implements low-level I/O.\n *\n * A new adapter typically overrides:\n * - {@link onInit} / {@link onClose} (optional)\n * - {@link createRootDirectory} when {@link BaseFileSystemOptions.createRoot} is set\n * - {@link toBackendPath} when the backend needs non-POSIX separators\n * - {@link preparePath} for post-resolve checks (e.g. symlink containment)\n * - the `*At` primitives and {@link isNotFoundError}\n * - optional `try*` hooks for native append / copy / move\n *\n * @module\n */\n\nimport { error, functionModule, hash, object, type OneOrMany } from \"@dbx-tools/shared-core\";\nimport type {\n  CopyOptions,\n  FileContent,\n  FileEntry,\n  FileStat,\n  FileSystem,\n  ListOptions,\n  MakeDirectoryOptions,\n  ReadFileOptions,\n  RemoveOptions,\n  WriteFileOptions,\n} from \"./fs.ts\";\nimport * as posixPath from \"./posix-path.ts\";\n\n/**\n * One root path segment. Strings are split on `/` and sanitized; numbers /\n * booleans / bigints stringify then sanitize; objects and arrays are FNV-hashed\n * as a single segment.\n */\nexport type FileSystemRootSegment = string | number | boolean | bigint | object;\n\n/**\n * A single {@link FileSystemRootSegment} or a non-empty list of them. Nested\n * arrays/objects inside the list are one hashed segment each (not flattened).\n */\nexport type FileSystemRootInput = FileSystemRootSegment | OneOrMany<FileSystemRootSegment>;\n\n/**\n * Characters no backend accepts inside a single path component: a separator\n * (which would silently deepen the path) or a NUL / control character.\n *\n * This is a DENY-list on purpose. Spaces, `@`, `&`, `#`, parentheses and\n * non-ASCII are all legal directory names on POSIX and in a Databricks\n * workspace, and replacing one with a hash points the filesystem at a\n * directory that does not exist - a failure that is silent and very hard to\n * trace back. Only reject what genuinely cannot be a component.\n */\nconst UNSAFE_PATH_SEGMENT = /[\\\\/\\u0000-\\u001F\\u007F]/;\n\n/**\n * Turn {@link root} into a POSIX filesystem root:\n *\n * 1. Expand one-or-many input segments\n * 2. Strings split on `/` (and `\\`); objects/arrays FNV-hash as one piece\n * 3. Each resulting component that cannot be a path component - see\n *    {@link UNSAFE_PATH_SEGMENT} - is replaced with {@link hash.fnvHash}\n * 4. Join with `/` and run {@link posixPath.normalizeRoot}\n *\n * Defaults to `/`. A leading `/` on the first string segment is preserved.\n *\n * @example\n * normalizeFileSystemRoot(\"/cool/wow\"); // \"/cool/wow\"\n * normalizeFileSystemRoot(\"/Users/me@corp.com/My Notes\"); // unchanged\n * normalizeFileSystemRoot([\"/path\", { user: 1 }, true]); // \"/path/<hash>/true\"\n */\nexport function normalizeFileSystemRoot(root?: FileSystemRootInput): string {\n  if (root === undefined) return \"/\";\n  const segments = object.toOneOrMany(root);\n  const absolute = isAbsoluteRootStart(segments[0]);\n  const parts: string[] = [];\n  for (const segment of segments) {\n    if (segment === null || segment === undefined) {\n      throw new TypeError(\"Filesystem root segments must be non-null\");\n    }\n    appendRootParts(parts, segment);\n  }\n  if (parts.length === 0) return \"/\";\n  const joined = parts.join(\"/\");\n  return posixPath.normalizeRoot(absolute ? `/${joined}` : joined);\n}\n\nfunction isAbsoluteRootStart(segment: FileSystemRootSegment): boolean {\n  return typeof segment === \"string\" && posixPath.isAbsolute(segment.trim());\n}\n\nfunction appendRootParts(parts: string[], segment: FileSystemRootSegment): void {\n  switch (typeof segment) {\n    case \"string\":\n      for (const piece of splitPathPieces(segment)) {\n        parts.push(sanitizePathSegment(piece));\n      }\n      return;\n    case \"number\":\n    case \"boolean\":\n    case \"bigint\":\n      parts.push(sanitizePathSegment(String(segment)));\n      return;\n    default:\n      parts.push(hash.fnvHash(segment));\n  }\n}\n\n/**\n * Split on `/` (after `\\` → `/`); drop empty pieces from\n * leading/trailing/double slashes and no-op `.` pieces.\n */\nfunction splitPathPieces(input: string): string[] {\n  return posixPath\n    .toPosix(input.trim())\n    .split(\"/\")\n    .filter((piece) => piece.length > 0 && piece !== \".\");\n}\n\n/**\n * Keep a usable path component verbatim; FNV-hash one that cannot be used.\n *\n * `..` is hashed rather than dropped so a root can never traverse above\n * itself while the offending segment stays visible in the resolved root.\n */\nfunction sanitizePathSegment(segment: string): string {\n  if (segment === \"..\" || UNSAFE_PATH_SEGMENT.test(segment)) {\n    return hash.fnvHash(segment);\n  }\n  return segment;\n}\n\nexport type FileSystemErrorCode =\n  | \"NOT_FOUND\"\n  | \"ALREADY_EXISTS\"\n  | \"NOT_DIRECTORY\"\n  | \"IS_DIRECTORY\"\n  | \"DIRECTORY_NOT_EMPTY\"\n  | \"PERMISSION_DENIED\"\n  | \"READ_ONLY\"\n  | \"INVALID_PATH\"\n  | \"NOT_SUPPORTED\"\n  | \"IO_ERROR\";\n\nexport class FileSystemError extends Error {\n  readonly name = \"FileSystemError\";\n\n  constructor(\n    readonly code: FileSystemErrorCode,\n    message: string,\n    readonly path?: string,\n    options?: { cause?: unknown },\n  ) {\n    super(\n      message,\n      options?.cause !== undefined ? { cause: error.toError(options.cause) } : undefined,\n    );\n  }\n}\n\n/**\n * Infer a {@link FileSystemErrorCode} from HTTP status / message tokens on an\n * unknown thrown value (via {@link error.errorContext}).\n *\n * Covers common SDK / REST wording so adapters do not reimplement the same\n * \"not found\" / \"already exists\" checks. Returns undefined when nothing matches.\n */\nexport function inferFileSystemErrorCode(err: unknown): FileSystemErrorCode | undefined {\n  const ctx = error.errorContext(err);\n  if (ctx.hasStatusCode(404) || ctx.hasMessage(\"not\", \"found\") || ctx.hasMessage(\"not\", \"exist\")) {\n    return \"NOT_FOUND\";\n  }\n  if (ctx.hasStatusCode(409) || ctx.hasMessage(\"already\", \"exists\")) {\n    return \"ALREADY_EXISTS\";\n  }\n  // Before \"not\"+\"directory\": \"directory not empty\" contains both of those tokens.\n  if (ctx.hasMessage(\"not\", \"empty\")) {\n    return \"DIRECTORY_NOT_EMPTY\";\n  }\n  if (ctx.hasMessage(\"not\", \"directory\")) {\n    return \"NOT_DIRECTORY\";\n  }\n  if (ctx.hasMessage(\"is\", \"directory\") || ctx.hasMessage(\"not\", \"file\")) {\n    return \"IS_DIRECTORY\";\n  }\n  if (\n    ctx.hasStatusCode(401, 403) ||\n    ctx.hasMessage(\"permission\", \"denied\") ||\n    ctx.hasMessage(\"access\", \"denied\")\n  ) {\n    return \"PERMISSION_DENIED\";\n  }\n  if (ctx.hasMessage(\"read\", \"only\")) {\n    return \"READ_ONLY\";\n  }\n  return undefined;\n}\n\n/**\n * Map an unknown backend failure into a {@link FileSystemError}.\n *\n * Prefer a backend-specific {@link codeOf} classifier (errno, SDK code). When\n * it returns undefined, falls back to {@link inferFileSystemErrorCode}. Message\n * and cause always go through `@dbx-tools/shared-core` {@link error} helpers.\n */\nexport function mapFileSystemError(\n  err: unknown,\n  filePath: string,\n  codeOf?: (err: unknown) => FileSystemErrorCode | undefined,\n): FileSystemError {\n  if (err instanceof FileSystemError) return err;\n  const message = error.errorMessage(err);\n  return new FileSystemError(\n    codeOf?.(err) ?? inferFileSystemErrorCode(err) ?? \"IO_ERROR\",\n    message || `Filesystem operation failed: ${filePath}`,\n    filePath,\n    { cause: error.toError(err) },\n  );\n}\n\nexport interface BaseFileSystemOptions<TBackend extends string = string> {\n  id: string;\n  backend: TBackend;\n  /**\n   * Filesystem root. One segment or a list of segments ({@link FileSystemRootInput}):\n   * primitives stringify, objects/arrays are FNV-hashed, then joined with `/`\n   * and normalized via {@link posixPath.normalizeRoot}. Defaults to `/`.\n   */\n  root?: FileSystemRootInput;\n  readOnly?: boolean;\n  /**\n   * Ensure {@link root} exists during init by calling {@link createRootDirectory}.\n   * Defaults to false (remote roots usually already exist). Local disk adapters\n   * typically pass true and override {@link createRootDirectory}.\n   */\n  createRoot?: boolean;\n}\n\n/**\n * Base implementation for local, remote, and virtual filesystems.\n *\n * Subclasses implement the low-level `*At` primitives. This class provides:\n *\n * - Memoized {@link _init} (so an explicit {@link init} call is optional)\n * - Optional root creation via {@link createRootDirectory}\n * - POSIX-only rooted path normalization and traversal protection\n * - {@link toBackendPath} for host/separator conversion at the boundary\n * - Text encoding and decoding\n * - {@link exists}\n * - Parent-directory creation on write / append / copy / move\n * - Append / copy / move fallbacks (override `try*` for native ops)\n * - Recursive mkdir, readdir, and rmdir\n * - Extension filtering for {@link readdir}\n *\n * Namespace paths always use `/`. Host adapters convert with\n * {@link posixPath.toPosix} / {@link posixPath.toHost} in {@link toBackendPath}.\n */\nexport abstract class BaseFileSystem<\n  TBackend extends string = string,\n> implements FileSystem<TBackend> {\n  readonly id: string;\n  readonly backend: TBackend;\n  /** POSIX-normalized root (see {@link posixPath.normalizeRoot}). */\n  readonly root: string;\n  readonly readOnly: boolean;\n  protected readonly createRoot: boolean;\n\n  /**\n   * Memoized initialization. Every operation that needs a ready backend awaits\n   * this, so callers (e.g. Mastra) may call {@link init} every time or never;\n   * both are fine.\n   */\n  protected _init: () => Promise<void>;\n\n  private initStarted = false;\n\n  protected constructor(options: BaseFileSystemOptions<TBackend>) {\n    this.id = options.id;\n    this.backend = options.backend;\n    this.root = normalizeFileSystemRoot(options.root);\n    this.readOnly = options.readOnly ?? false;\n    this.createRoot = options.createRoot ?? false;\n    this._init = this.createInit();\n  }\n\n  /* ------------------------------------------------------------------ */\n  /* Lifecycle                                                          */\n  /* ------------------------------------------------------------------ */\n\n  private createInit(): () => Promise<void> {\n    return functionModule.memoize(async () => {\n      this.initStarted = true;\n      if (this.createRoot) {\n        await this.guard(this.root, () => this.createRootDirectory());\n      }\n      await this.onInit();\n    });\n  }\n\n  async init(): Promise<void> {\n    await this._init();\n  }\n\n  async close(): Promise<void> {\n    if (!this.initStarted) return;\n    try {\n      await this._init();\n    } catch {\n      this.initStarted = false;\n      this._init = this.createInit();\n      return;\n    }\n    await this.onClose();\n    this.initStarted = false;\n    this._init = this.createInit();\n  }\n\n  /**\n   * Ensure {@link root} exists when {@link createRoot} is true.\n   *\n   * Default is a no-op. Local adapters typically `mkdir -p`; remote adapters\n   * leave the default when the root is provisioned out of band.\n   */\n  protected async createRootDirectory(): Promise<void> {}\n\n  /** Override when the backend requires connection or validation work. */\n  protected async onInit(): Promise<void> {}\n\n  /** Override when the backend owns connections or other resources. */\n  protected async onClose(): Promise<void> {}\n\n  protected assertWritable(operation: string): void {\n    if (this.readOnly) {\n      throw new FileSystemError(\"READ_ONLY\", `Cannot ${operation}: filesystem is read-only`);\n    }\n  }\n\n  /* ------------------------------------------------------------------ */\n  /* Paths (POSIX only)                                                 */\n  /* ------------------------------------------------------------------ */\n\n  /**\n   * Normalize an input path into an absolute POSIX path inside the virtual\n   * filesystem namespace (`/a/b`). Backslashes are converted; `..` escaping\n   * the root throws {@link FileSystemError} `PERMISSION_DENIED`.\n   */\n  protected normalizePath(inputPath: string): string {\n    if (inputPath.includes(\"\\0\")) {\n      throw new FileSystemError(\"INVALID_PATH\", \"Paths cannot contain null characters\", inputPath);\n    }\n\n    const result = posixPath.normalize(inputPath);\n    if (!result.ok) {\n      throw new FileSystemError(\"PERMISSION_DENIED\", \"Path escapes the filesystem root\", inputPath);\n    }\n    return result.path;\n  }\n\n  /**\n   * Convert a POSIX backend path (under {@link root}) into the form the\n   * underlying API expects.\n   *\n   * Default is identity. Local disk overrides with {@link posixPath.toHost}.\n   * Databricks / object-store adapters usually leave the default.\n   */\n  protected toBackendPath(posixBackendPath: string): string {\n    return posixBackendPath;\n  }\n\n  /**\n   * Convert a normalized namespace path (`/a/b`) into a backend path.\n   *\n   * Joins {@link root} with the namespace using POSIX `/`, then applies\n   * {@link toBackendPath}. Override {@link toBackendPath} instead of this\n   * method unless the join itself must change.\n   */\n  protected resolveBackendPath(namespacePath: string): string {\n    const posix =\n      namespacePath === \"/\" ? this.root : posixPath.join(this.root, namespacePath.slice(1));\n    return this.toBackendPath(posix);\n  }\n\n  resolvePath(inputPath: string): string {\n    return this.resolveBackendPath(this.normalizePath(inputPath));\n  }\n\n  /**\n   * Resolve {@link inputPath}, ensure init, and run {@link preparePath}.\n   */\n  protected async resolveFor(\n    inputPath: string,\n    options?: { allowMissing?: boolean },\n  ): Promise<string> {\n    await this._init();\n    return this.resolveNamespaceFor(this.normalizePath(inputPath), options);\n  }\n\n  /**\n   * {@link resolveFor} for a path that is ALREADY a normalized namespace path\n   * (`/a/b`). The single spelling for \"namespace path to prepared backend\n   * path\", so no call site has to re-derive the chain by hand.\n   */\n  private resolveNamespaceFor(\n    namespacePath: string,\n    options?: { allowMissing?: boolean },\n  ): Promise<string> {\n    return this.preparePath(this.resolveBackendPath(namespacePath), options);\n  }\n\n  /**\n   * Hook after lexical resolution. Override for realpath containment or\n   * similar backend-specific checks. Default is a no-op.\n   */\n  protected async preparePath(\n    resolvedPath: string,\n    _options?: { allowMissing?: boolean },\n  ): Promise<string> {\n    return resolvedPath;\n  }\n\n  protected joinNamespace(parent: string, child: string): string {\n    return this.normalizePath(posixPath.join(parent, child));\n  }\n\n  /** Namespace path without a leading slash (`.` for the root). */\n  protected toRelativePath(namespacePath: string): string {\n    return namespacePath === \"/\" ? \".\" : namespacePath.slice(1);\n  }\n\n  protected toBytes(content: FileContent): Uint8Array {\n    return typeof content === \"string\" ? new TextEncoder().encode(content) : content;\n  }\n\n  /** Create parent directories for {@link inputPath} when it is nested. */\n  protected async ensureParentDirectory(inputPath: string): Promise<void> {\n    const namespacePath = this.normalizePath(inputPath);\n    const parent = posixPath.dirname(namespacePath);\n    if (parent === \"/\" || parent === namespacePath) return;\n    await this.mkdir(parent, { recursive: true });\n  }\n\n  /* ------------------------------------------------------------------ */\n  /* Backend primitives                                                 */\n  /* ------------------------------------------------------------------ */\n\n  protected abstract readBytesAt(resolvedPath: string): Promise<Uint8Array>;\n\n  protected abstract writeBytesAt(\n    resolvedPath: string,\n    content: Uint8Array,\n    options: Required<WriteFileOptions>,\n  ): Promise<void>;\n\n  protected abstract deleteFileAt(resolvedPath: string): Promise<void>;\n\n  protected abstract createDirectoryAt(resolvedPath: string): Promise<void>;\n\n  /**\n   * Remove an empty directory.\n   *\n   * Recursive deletion is implemented by {@link BaseFileSystem}.\n   */\n  protected abstract removeDirectoryAt(resolvedPath: string): Promise<void>;\n\n  /** Return only the direct children of a directory (`name` is the basename). */\n  protected abstract listDirectoryAt(resolvedPath: string): Promise<FileEntry[]>;\n\n  protected abstract statAt(resolvedPath: string): Promise<Omit<FileStat, \"path\">>;\n\n  /**\n   * Recognize the backend's not-found error.\n   *\n   * Default accepts {@link FileSystemError} `NOT_FOUND` plus common SDK / HTTP\n   * \"not found\" shapes via {@link inferFileSystemErrorCode}. Override for\n   * backend-specific codes (e.g. Node `ENOENT`) that do not carry a message.\n   */\n  protected isNotFoundError(err: unknown): boolean {\n    if (err instanceof FileSystemError) return err.code === \"NOT_FOUND\";\n    return inferFileSystemErrorCode(err) === \"NOT_FOUND\";\n  }\n\n  /**\n   * Normalize a backend failure into a {@link FileSystemError}.\n   *\n   * Every `*At` / `try*` primitive is invoked through {@link guard}, so an\n   * adapter never writes its own try/catch and cannot forget to normalize.\n   * Override only to classify backend-specific codes (e.g. Node errno).\n   */\n  protected mapError(err: unknown, filePath: string): FileSystemError {\n    return mapFileSystemError(err, filePath);\n  }\n\n  /** Run a backend primitive, routing any failure through {@link mapError}. */\n  private async guard<T>(resolvedPath: string, operation: () => Promise<T>): Promise<T> {\n    try {\n      return await operation();\n    } catch (err) {\n      throw this.mapError(err, resolvedPath);\n    }\n  }\n\n  /* ------------------------------------------------------------------ */\n  /* Optional native-operation hooks                                    */\n  /* ------------------------------------------------------------------ */\n\n  /**\n   * Override when the backend supports native append.\n   *\n   * Parent directories are already created by {@link appendFile}. Return true\n   * when the operation was performed. The default causes {@link BaseFileSystem}\n   * to use read-concatenate-write.\n   */\n  protected async tryAppendFileAt(_resolvedPath: string, _content: Uint8Array): Promise<boolean> {\n    return false;\n  }\n\n  /**\n   * Override when the backend supports native server-side copying.\n   *\n   * Parent directories of the destination are already created by {@link copyFile}.\n   */\n  protected async tryCopyFileAt(\n    _sourcePath: string,\n    _destinationPath: string,\n    _options: Required<CopyOptions>,\n  ): Promise<boolean> {\n    return false;\n  }\n\n  /**\n   * Override for native rename or move support.\n   *\n   * Parent directories of the destination are already created by {@link moveFile}.\n   */\n  protected async tryMoveFileAt(\n    _sourcePath: string,\n    _destinationPath: string,\n    _options: Required<CopyOptions>,\n  ): Promise<boolean> {\n    return false;\n  }\n\n  /* ------------------------------------------------------------------ */\n  /* File operations                                                    */\n  /* ------------------------------------------------------------------ */\n\n  async readFile(inputPath: string): Promise<Uint8Array>;\n  async readFile(\n    inputPath: string,\n    options: ReadFileOptions & { encoding: string },\n  ): Promise<string>;\n  async readFile(inputPath: string, options?: ReadFileOptions): Promise<string | Uint8Array> {\n    const resolvedPath = await this.resolveFor(inputPath);\n    const content = await this.guard(resolvedPath, () => this.readBytesAt(resolvedPath));\n    if (options?.encoding) {\n      return new TextDecoder(options.encoding).decode(content);\n    }\n    return content;\n  }\n\n  async writeFile(\n    inputPath: string,\n    content: FileContent,\n    options: WriteFileOptions = {},\n  ): Promise<void> {\n    await this._init();\n    this.assertWritable(\"write file\");\n\n    const overwrite = await this.resolveOverwrite(inputPath, options, \"File\");\n    await this.ensureParentDirectory(inputPath);\n    const resolvedPath = await this.resolveFor(inputPath, { allowMissing: true });\n    await this.guard(resolvedPath, () =>\n      this.writeBytesAt(resolvedPath, this.toBytes(content), { overwrite }),\n    );\n  }\n\n  async appendFile(inputPath: string, content: FileContent): Promise<void> {\n    await this._init();\n    this.assertWritable(\"append file\");\n\n    const bytes = this.toBytes(content);\n    await this.ensureParentDirectory(inputPath);\n    const resolvedPath = await this.resolveFor(inputPath, { allowMissing: true });\n\n    if (await this.guard(resolvedPath, () => this.tryAppendFileAt(resolvedPath, bytes))) {\n      return;\n    }\n\n    const existing = (await this.exists(inputPath))\n      ? await this.readFile(inputPath)\n      : new Uint8Array();\n    const combined = new Uint8Array(existing.byteLength + bytes.byteLength);\n    combined.set(existing);\n    combined.set(bytes, existing.byteLength);\n    await this.writeFile(inputPath, combined, { overwrite: true });\n  }\n\n  async deleteFile(inputPath: string, options: RemoveOptions = {}): Promise<void> {\n    await this._init();\n    this.assertWritable(\"delete file\");\n\n    await this.ignoringMissing(options, async () => {\n      const entry = await this.stat(inputPath);\n      if (entry.type === \"directory\") {\n        throw new FileSystemError(\"IS_DIRECTORY\", `Path is a directory: ${inputPath}`, inputPath);\n      }\n      const resolvedPath = await this.resolveFor(inputPath);\n      await this.guard(resolvedPath, () => this.deleteFileAt(resolvedPath));\n    });\n  }\n\n  async copyFile(\n    sourcePath: string,\n    destinationPath: string,\n    options: CopyOptions = {},\n  ): Promise<void> {\n    const { source, destination, resolved } = await this.prepareTransfer(\n      \"copy file\",\n      sourcePath,\n      destinationPath,\n      options,\n    );\n\n    if (await this.guard(destination, () => this.tryCopyFileAt(source, destination, resolved))) {\n      return;\n    }\n\n    await this.writeFile(destinationPath, await this.readFile(sourcePath), resolved);\n  }\n\n  async moveFile(\n    sourcePath: string,\n    destinationPath: string,\n    options: CopyOptions = {},\n  ): Promise<void> {\n    const { source, destination, resolved } = await this.prepareTransfer(\n      \"move file\",\n      sourcePath,\n      destinationPath,\n      options,\n    );\n\n    if (await this.guard(destination, () => this.tryMoveFileAt(source, destination, resolved))) {\n      return;\n    }\n\n    await this.copyFile(sourcePath, destinationPath, resolved);\n    const sourceStat = await this.stat(sourcePath);\n    if (sourceStat.type === \"directory\") {\n      await this.rmdir(sourcePath, { recursive: true });\n    } else {\n      await this.deleteFile(sourcePath);\n    }\n  }\n\n  /**\n   * Resolve the effective `overwrite` flag, rejecting when the target exists\n   * and overwriting was refused. Shared by write / copy / move so the three\n   * cannot disagree about what `overwrite: false` means.\n   */\n  private async resolveOverwrite(\n    inputPath: string,\n    options: { overwrite?: boolean },\n    label: string,\n  ): Promise<boolean> {\n    const overwrite = options.overwrite ?? true;\n    if (!overwrite && (await this.exists(inputPath))) {\n      throw new FileSystemError(\n        \"ALREADY_EXISTS\",\n        `${label} already exists: ${inputPath}`,\n        inputPath,\n      );\n    }\n    return overwrite;\n  }\n\n  /** Shared copy / move prologue: writability, overwrite policy, both ends resolved. */\n  private async prepareTransfer(\n    operation: string,\n    sourcePath: string,\n    destinationPath: string,\n    options: CopyOptions,\n  ): Promise<{ source: string; destination: string; resolved: Required<CopyOptions> }> {\n    await this._init();\n    this.assertWritable(operation);\n\n    const overwrite = await this.resolveOverwrite(destinationPath, options, \"Destination\");\n    await this.ensureParentDirectory(destinationPath);\n\n    return {\n      source: await this.resolveFor(sourcePath),\n      destination: await this.resolveFor(destinationPath, { allowMissing: true }),\n      resolved: { overwrite },\n    };\n  }\n\n  /** Run a removal, swallowing a not-found failure when `force` is set. */\n  private async ignoringMissing(\n    options: RemoveOptions,\n    operation: () => Promise<void>,\n  ): Promise<void> {\n    try {\n      await operation();\n    } catch (err) {\n      if (options.force && this.isNotFoundError(err)) return;\n      throw err;\n    }\n  }\n\n  /* ------------------------------------------------------------------ */\n  /* Directory operations                                               */\n  /* ------------------------------------------------------------------ */\n\n  async mkdir(inputPath: string, options: MakeDirectoryOptions = {}): Promise<void> {\n    await this._init();\n    this.assertWritable(\"create directory\");\n\n    const namespacePath = this.normalizePath(inputPath);\n\n    if (!options.recursive) {\n      await this.createDirectory(namespacePath);\n      return;\n    }\n\n    let currentPath = \"\";\n    for (const segment of namespacePath.split(\"/\").filter(Boolean)) {\n      currentPath = `${currentPath}/${segment}`;\n      try {\n        const entry = await this.stat(currentPath);\n        if (entry.type !== \"directory\") {\n          throw new FileSystemError(\n            \"NOT_DIRECTORY\",\n            `Path component is not a directory: ${currentPath}`,\n            currentPath,\n          );\n        }\n      } catch (error) {\n        if (!this.isNotFoundError(error)) throw error;\n        await this.createDirectory(currentPath);\n      }\n    }\n  }\n\n  async rmdir(inputPath: string, options: RemoveOptions = {}): Promise<void> {\n    await this._init();\n    this.assertWritable(\"remove directory\");\n\n    await this.ignoringMissing(options, async () => {\n      const entry = await this.stat(inputPath);\n      if (entry.type !== \"directory\") {\n        throw new FileSystemError(\n          \"NOT_DIRECTORY\",\n          `Path is not a directory: ${inputPath}`,\n          inputPath,\n        );\n      }\n\n      const namespacePath = this.normalizePath(inputPath);\n      if (options.recursive) {\n        await this.removeDirectoryContents(namespacePath);\n      }\n      await this.removeDirectory(namespacePath);\n    });\n  }\n\n  private async removeDirectoryContents(namespacePath: string): Promise<void> {\n    for (const entry of await this.listDirectory(namespacePath)) {\n      const childPath = this.joinNamespace(namespacePath, entry.name);\n      if (entry.type === \"directory\") {\n        await this.removeDirectoryContents(childPath);\n        await this.removeDirectory(childPath);\n      } else {\n        const resolvedPath = await this.resolveNamespaceFor(childPath);\n        await this.guard(resolvedPath, () => this.deleteFileAt(resolvedPath));\n      }\n    }\n  }\n\n  /** {@link createDirectoryAt} for a namespace path, resolved and guarded. */\n  private async createDirectory(namespacePath: string): Promise<void> {\n    const resolvedPath = await this.resolveNamespaceFor(namespacePath, { allowMissing: true });\n    await this.guard(resolvedPath, () => this.createDirectoryAt(resolvedPath));\n  }\n\n  /** {@link removeDirectoryAt} for a namespace path, resolved and guarded. */\n  private async removeDirectory(namespacePath: string): Promise<void> {\n    const resolvedPath = await this.resolveNamespaceFor(namespacePath);\n    await this.guard(resolvedPath, () => this.removeDirectoryAt(resolvedPath));\n  }\n\n  /** {@link listDirectoryAt} for a namespace path, resolved and guarded. */\n  private async listDirectory(namespacePath: string): Promise<FileEntry[]> {\n    const resolvedPath = await this.resolveNamespaceFor(namespacePath);\n    return this.guard(resolvedPath, () => this.listDirectoryAt(resolvedPath));\n  }\n\n  async readdir(inputPath: string, options: ListOptions = {}): Promise<FileEntry[]> {\n    await this._init();\n\n    const namespacePath = this.normalizePath(inputPath);\n\n    if (!options.recursive) {\n      return this.filterEntries(await this.listDirectory(namespacePath), options);\n    }\n\n    return this.listDirectoryRecursive(namespacePath, options, 0, \"\");\n  }\n\n  private async listDirectoryRecursive(\n    namespacePath: string,\n    options: ListOptions,\n    depth: number,\n    prefix: string,\n  ): Promise<FileEntry[]> {\n    const maximumDepth = options.maxDepth ?? Number.POSITIVE_INFINITY;\n    const entries = this.filterEntries(await this.listDirectory(namespacePath), options);\n\n    const results: FileEntry[] = [];\n\n    for (const entry of entries) {\n      const relativeName = prefix ? `${prefix}/${entry.name}` : entry.name;\n      results.push({ ...entry, name: relativeName });\n\n      if (entry.type === \"directory\" && depth < maximumDepth) {\n        results.push(\n          ...(await this.listDirectoryRecursive(\n            this.joinNamespace(namespacePath, entry.name),\n            options,\n            depth + 1,\n            relativeName,\n          )),\n        );\n      }\n    }\n\n    return results;\n  }\n\n  private filterEntries(entries: FileEntry[], options: ListOptions): FileEntry[] {\n    if (!options.extension) {\n      return entries;\n    }\n\n    const extensions = (\n      Array.isArray(options.extension) ? options.extension : [options.extension]\n    ).map((extension) => {\n      const normalized = extension.toLowerCase();\n      return normalized.startsWith(\".\") ? normalized : `.${normalized}`;\n    });\n\n    return entries.filter((entry) => {\n      if (entry.type !== \"file\") return true;\n      const lower = entry.name.toLowerCase();\n      return extensions.some((ext) => lower.endsWith(ext));\n    });\n  }\n\n  async exists(inputPath: string): Promise<boolean> {\n    await this._init();\n    try {\n      await this.stat(inputPath);\n      return true;\n    } catch (error) {\n      if (this.isNotFoundError(error)) return false;\n      if (error instanceof FileSystemError && error.code === \"PERMISSION_DENIED\") {\n        return false;\n      }\n      throw error;\n    }\n  }\n\n  async stat(inputPath: string): Promise<FileStat> {\n    await this._init();\n    const namespacePath = this.normalizePath(inputPath);\n    const resolvedPath = await this.resolveNamespaceFor(namespacePath);\n    const entry = await this.guard(resolvedPath, () => this.statAt(resolvedPath));\n    return {\n      ...entry,\n      path: this.toRelativePath(namespacePath),\n    };\n  }\n}\n"]}