@dbx-tools/appkit-mastra 0.3.44 → 0.4.1

package/lib/src/filesystems.js

@@ -0,0 +1,958 @@
+/**
+ * Mastra {@link WorkspaceFilesystem} implementations for Databricks Apps.
+ *
+ * {@link DatabricksWorkspaceFilesystem} maps a Mastra workspace namespace onto
+ * an absolute Databricks path (Unity Catalog volume, workspace object tree, or
+ * DBFS). {@link emptyFilesystem} is a read-only no-op mount used when no
+ * dynamic mounts resolve for a request.
+ *
+ * Path helpers ({@link normalizeDatabricksBasePath}, {@link isDbfsPath}, …)
+ * are exported for tests and callers that need to reason about Databricks
+ * paths without constructing a filesystem.
+ *
+ * @module
+ */
+import { posix as path } from "node:path";
+import { ExecutionError, getExecutionContext, ValidationError } from "@databricks/appkit";
+import { error, functionModule, hash, log } from "@dbx-tools/shared-core";
+import { DirectoryNotEmptyError, DirectoryNotFoundError, FileExistsError, FileNotFoundError, IsDirectoryError, MastraFilesystem, NotDirectoryError, PermissionError, WorkspaceReadOnlyError, } from "@mastra/core/workspace";
+/* ------------------------------ constants ------------------------------ */
+const DBFS_READ_CHUNK_BYTES = 1024 * 1024;
+const DBFS_PUT_MAX_BYTES = 1024 * 1024;
+const EMPTY_FILESYSTEM_EPOCH = new Date(0);
+/** Mastra error constructor for a known SDK filesystem failure, if any. */
+function filesystemSdkErrorType(err) {
+    if (err) {
+        const ctx = error.errorContext(err);
+        if (ctx.notAccessible) {
+            return FileNotFoundError;
+        }
+        else if (ctx.hasMessage("already", "exists")) {
+            return FileExistsError;
+        }
+        else if (ctx.hasMessage("not", "directory")) {
+            return NotDirectoryError;
+        }
+        else if (ctx.hasMessage("not", "file")) {
+            return IsDirectoryError;
+        }
+    }
+    return undefined;
+}
+const logger = log.logger("mastra/filesystems");
+/* ------------------------- exported path helpers ------------------------- */
+/** Normalize a Databricks base path (POSIX, no trailing slash). */
+export function normalizeDatabricksBasePath(basePath) {
+    const trimmed = basePath.trim();
+    if (!trimmed.startsWith("/")) {
+        throw ValidationError.invalidValue("basePath", basePath, "an absolute Databricks path, e.g. /Volumes/catalog/schema/volume");
+    }
+    return trimmed.replace(/\/+$/, "") || "/";
+}
+/** True when `absolutePath` is served by DBFS rather than the UC Files API. */
+export function isDbfsPath(absolutePath) {
+    return absolutePath === "/dbfs" || absolutePath.startsWith("/dbfs/");
+}
+/** True when `absolutePath` is a Databricks workspace object path. */
+export function isWorkspaceFilesPath(absolutePath) {
+    return (absolutePath === "/Workspace" ||
+        absolutePath.startsWith("/Workspace/") ||
+        absolutePath.startsWith("/Users/") ||
+        absolutePath.startsWith("/Repos/"));
+}
+/**
+ * Resolve a workspace-relative path to an absolute Databricks path under
+ * `basePath`.
+ */
+export function resolveDatabricksAbsolutePath(basePath, inputPath) {
+    const root = normalizeDatabricksBasePath(basePath);
+    const trimmed = inputPath.trim();
+    if (!trimmed || trimmed === "/")
+        return root;
+    const normalized = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+    if (normalized === root || normalized.startsWith(`${root}/`)) {
+        return path.normalize(normalized);
+    }
+    return path.normalize(path.join(root, normalized));
+}
+/** Map an absolute Databricks path back to the workspace namespace. */
+export function toDatabricksWorkspacePath(basePath, absolutePath) {
+    const root = normalizeDatabricksBasePath(basePath);
+    const normalized = path.normalize(absolutePath);
+    if (normalized === root)
+        return "/";
+    if (normalized.startsWith(`${root}/`)) {
+        return normalized.slice(root.length) || "/";
+    }
+    return normalized;
+}
+/* ---------------------------- private helpers ---------------------------- */
+/** Pick the Databricks Files API backend for an absolute path. */
+function resolveFilesBackend(absolutePath) {
+    if (isDbfsPath(absolutePath))
+        return "dbfs";
+    if (isWorkspaceFilesPath(absolutePath))
+        return "workspace";
+    return "uc-files";
+}
+/** Run the handler that matches `absolutePath`'s Databricks backend. */
+async function dispatchFilesBackend(absolutePath, handlers) {
+    const backend = resolveFilesBackend(absolutePath);
+    if (backend === "dbfs")
+        return handlers.dbfs();
+    if (backend === "workspace")
+        return handlers.workspace();
+    return handlers.ucFiles();
+}
+/** Return `buffer` as a string when `encoding` is set, otherwise unchanged. */
+function formatReadResult(buffer, encoding) {
+    return encoding ? buffer.toString(encoding) : buffer;
+}
+/** Drain a fetch `ReadableStream` into a single `Buffer`. */
+async function readResponseBody(contents) {
+    if (!contents)
+        return Buffer.alloc(0);
+    const reader = contents.getReader();
+    const chunks = [];
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (value)
+            chunks.push(value);
+    }
+    return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)));
+}
+/** Coerce Mastra {@link FileContent} to a `Buffer`. */
+function toBuffer(content) {
+    if (typeof content === "string")
+        return Buffer.from(content, "utf8");
+    return Buffer.from(content);
+}
+/** Decode a DBFS read payload from base64. */
+function decodeDbfsPayload(data) {
+    if (!data)
+        return Buffer.alloc(0);
+    return Buffer.from(data, "base64");
+}
+/** Wrap a `Buffer` as a one-shot `ReadableStream` for UC file uploads. */
+function bufferToReadableStream(buffer) {
+    return new ReadableStream({
+        start(controller) {
+            controller.enqueue(new Uint8Array(buffer));
+            controller.close();
+        },
+    });
+}
+/** Parse an HTTP date header; returns epoch when missing or invalid. */
+function parseHttpDate(value) {
+    if (!value)
+        return new Date(0);
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? new Date(parsed) : new Date(0);
+}
+/* ---------------- DatabricksWorkspaceFilesystem ---------------- */
+/**
+ * Mastra filesystem provider that reads and writes through a Databricks
+ * {@link WorkspaceClient}.
+ *
+ * Workspace paths are absolute within the namespace (`/notes.md` maps to
+ * `<basePath>/notes.md`). Unity Catalog volumes use the Files API;
+ * `/dbfs/...` paths use DBFS.
+ */
+export class DatabricksWorkspaceFilesystem extends MastraFilesystem {
+    id;
+    name = "DatabricksWorkspaceFilesystem";
+    provider = "databricks";
+    basePath;
+    status = "pending";
+    client;
+    mkdirs;
+    _readOnly;
+    _basePathMissing;
+    get readOnly() {
+        return this._readOnly;
+    }
+    /**
+     * @param options.client - Defaults to the AppKit execution-context client.
+     * @param options.mkdirs - Default `"try"`; see {@link DatabricksMkdirsMode}.
+     * @param options.readOnly - When omitted, {@link init} probes write access.
+     */
+    constructor(options) {
+        super({ name: "DatabricksWorkspaceFilesystem", ...options });
+        this.id = options.id ?? `databricks-fs-${hash.fnvHash(options.basePath)}`;
+        this.client = options.client ?? getExecutionContext().client;
+        this.basePath = normalizeDatabricksBasePath(options.basePath);
+        this.mkdirs = options.mkdirs ?? "try";
+        this._readOnly = options.readOnly;
+    }
+    /* --- path resolution --- */
+    /** Resolve and sandbox a workspace-relative path under {@link basePath}. */
+    resolvePath(inputPath) {
+        const resolved = resolveDatabricksAbsolutePath(this.basePath, inputPath);
+        if (resolved !== this.basePath && !resolved.startsWith(`${this.basePath}/`)) {
+            throw new PermissionError(inputPath, "access");
+        }
+        return resolved;
+    }
+    /** Map a Databricks absolute path back to the workspace namespace. */
+    workspacePath(absolutePath) {
+        return toDatabricksWorkspacePath(this.basePath, absolutePath);
+    }
+    /** Throw when the filesystem is read-only. */
+    assertWritable(operation) {
+        if (this.readOnly) {
+            throw new WorkspaceReadOnlyError(operation);
+        }
+    }
+    /** Map SDK / HTTP errors to Mastra workspace filesystem errors. */
+    rethrow(err, inputPath) {
+        const workspacePath = inputPath.startsWith("/")
+            ? inputPath
+            : this.workspacePath(this.resolvePath(inputPath));
+        const ErrorType = filesystemSdkErrorType(err);
+        if (ErrorType) {
+            throw new ErrorType(workspacePath);
+        }
+        // The upstream message is logged rather than raised: it reaches the model
+        // (and from there the chat transcript) as the tool's failure text.
+        logger.warn("operation-failed", {
+            path: workspacePath,
+            error: error.errorMessage(err),
+        });
+        throw new ExecutionError(`Databricks filesystem operation failed for ${workspacePath}`, {
+            cause: error.toError(err),
+            context: { path: workspacePath },
+        });
+    }
+    /* --- lifecycle --- */
+    /**
+     * Probe whether {@link basePath} exists and cache the result on
+     * {@link _basePathMissing}.
+     */
+    async resolveBasePathStatus() {
+        if (this._basePathMissing !== undefined)
+            return;
+        try {
+            await this.assertAbsoluteReadable(this.basePath);
+            this._basePathMissing = false;
+        }
+        catch (err) {
+            if (error.errorContext(err).notAccessible) {
+                this._basePathMissing = true;
+                return;
+            }
+            this.rethrow(err, "/");
+        }
+    }
+    /** Delegate to {@link emptyFilesystem} when the base path is missing. */
+    async emptyFallback() {
+        await this.resolveBasePathStatus();
+        return this._basePathMissing ? emptyFilesystem() : undefined;
+    }
+    async init() {
+        await this.resolveBasePathStatus();
+        if (this._basePathMissing) {
+            if (this.mkdirs === false) {
+                return;
+            }
+            try {
+                await this.mkdirAbsolute(this.basePath);
+                this._basePathMissing = false;
+                if (this._readOnly === undefined) {
+                    this._readOnly = false;
+                }
+            }
+            catch (err) {
+                if (this.mkdirs === true) {
+                    this.rethrow(err, "/");
+                }
+                logger.debug("mkdirs:try-failed", {
+                    basePath: this.basePath,
+                    error: error.errorMessage(err),
+                });
+            }
+            return;
+        }
+        if (this._readOnly === undefined) {
+            await this.probeReadOnly();
+        }
+    }
+    /**
+     * Write and delete a ephemeral probe file to detect read-only access when
+     * {@link DatabricksWorkspaceFilesystemOptions.readOnly} was not set.
+     *
+     * @returns `true` when the probe write (and cleanup) succeeded.
+     */
+    async probeReadOnly() {
+        const absolutePath = this.resolvePath(`/.__dbx_fs_probe_${hash.id()}`);
+        try {
+            await this.writeAbsolute(absolutePath, Buffer.from("probe\n"), true);
+            this._readOnly = false;
+        }
+        catch {
+            this._readOnly = true;
+            return false;
+        }
+        try {
+            await this.deleteAbsoluteFile(absolutePath);
+        }
+        catch {
+            // Writable; leave a hidden probe file rather than failing init.
+        }
+        return true;
+    }
+    async destroy() {
+        // Remote filesystem; nothing to tear down locally.
+    }
+    /* --- backend I/O --- */
+    /** Probe that `absolutePath` exists (file or directory metadata). */
+    async assertAbsoluteReadable(absolutePath) {
+        await dispatchFilesBackend(absolutePath, {
+            dbfs: () => this.client.dbfs.getStatus({ path: absolutePath }),
+            workspace: () => this.client.workspace.getStatus({ path: absolutePath }),
+            ucFiles: () => this.client.files.getDirectoryMetadata({ directory_path: absolutePath }),
+        });
+    }
+    /** Read the full contents of `absolutePath` from the matching backend. */
+    async readAbsolute(absolutePath) {
+        return dispatchFilesBackend(absolutePath, {
+            dbfs: () => this.readDbfsFile(absolutePath),
+            workspace: () => this.readWorkspaceFile(absolutePath),
+            ucFiles: async () => {
+                const response = await this.client.files.download({ file_path: absolutePath });
+                return readResponseBody(response.contents);
+            },
+        });
+    }
+    /** Write `buffer` to `absolutePath` on the matching backend. */
+    async writeAbsolute(absolutePath, buffer, overwrite) {
+        await dispatchFilesBackend(absolutePath, {
+            dbfs: () => this.writeDbfsFile(absolutePath, buffer, overwrite),
+            workspace: () => this.writeWorkspaceFile(absolutePath, buffer, overwrite),
+            ucFiles: () => this.uploadUcFile(absolutePath, buffer, overwrite),
+        });
+    }
+    /** Upload a buffer to a Unity Catalog Files API path. */
+    uploadUcFile(absolutePath, buffer, overwrite) {
+        return this.client.files.upload({
+            file_path: absolutePath,
+            contents: bufferToReadableStream(buffer),
+            overwrite,
+        });
+    }
+    /** Delete a single file at `absolutePath` (non-recursive). */
+    async deleteAbsoluteFile(absolutePath) {
+        await dispatchFilesBackend(absolutePath, {
+            dbfs: () => this.client.dbfs.delete({ path: absolutePath, recursive: false }),
+            workspace: () => this.client.workspace.delete({ path: absolutePath, recursive: false }),
+            ucFiles: () => this.client.files.delete({ file_path: absolutePath }),
+        });
+    }
+    /**
+     * Delete a file or directory at `absolutePath`.
+     *
+     * DBFS and workspace APIs accept `recursive`; UC volumes recurse manually.
+     */
+    async deleteAbsolutePath(absolutePath, recursive) {
+        await dispatchFilesBackend(absolutePath, {
+            dbfs: async () => {
+                await this.client.dbfs.delete({ path: absolutePath, recursive });
+            },
+            workspace: async () => {
+                await this.client.workspace.delete({ path: absolutePath, recursive });
+            },
+            ucFiles: async () => {
+                if (recursive) {
+                    await this.deleteUcDirectoryRecursive(absolutePath);
+                    return;
+                }
+                const children = await this.listAbsoluteDirectory(absolutePath);
+                if (children.length > 0) {
+                    throw new DirectoryNotEmptyError(this.workspacePath(absolutePath));
+                }
+                await this.client.files.deleteDirectory({ directory_path: absolutePath });
+            },
+        });
+    }
+    /** Create `absolutePath` and any missing parents on the matching backend. */
+    async mkdirAbsolute(absolutePath) {
+        await dispatchFilesBackend(absolutePath, {
+            dbfs: () => this.client.dbfs.mkdirs({ path: absolutePath }),
+            workspace: () => this.client.workspace.mkdirs({ path: absolutePath }),
+            ucFiles: () => this.client.files.createDirectory({ directory_path: absolutePath }),
+        });
+    }
+    async readDbfsFile(absolutePath) {
+        const chunks = [];
+        let offset = 0;
+        while (true) {
+            const response = await this.client.dbfs.read({
+                path: absolutePath,
+                offset,
+                length: DBFS_READ_CHUNK_BYTES,
+            });
+            const chunk = decodeDbfsPayload(response.data);
+            if (chunk.length === 0)
+                break;
+            chunks.push(chunk);
+            offset += chunk.length;
+            if (chunk.length < DBFS_READ_CHUNK_BYTES)
+                break;
+        }
+        return Buffer.concat(chunks);
+    }
+    async readWorkspaceFile(absolutePath) {
+        const response = await this.client.workspace.export({
+            path: absolutePath,
+            format: "AUTO",
+        });
+        return decodeDbfsPayload(response.content);
+    }
+    async writeDbfsFile(absolutePath, buffer, overwrite) {
+        if (buffer.length <= DBFS_PUT_MAX_BYTES) {
+            await this.client.dbfs.put({
+                path: absolutePath,
+                contents: buffer.toString("base64"),
+                overwrite,
+            });
+            return;
+        }
+        const created = await this.client.dbfs.create({ path: absolutePath, overwrite });
+        const handle = created.handle;
+        if (handle === undefined) {
+            throw ExecutionError.missingData("DBFS upload handle");
+        }
+        for (let offset = 0; offset < buffer.length; offset += DBFS_PUT_MAX_BYTES) {
+            const slice = buffer.subarray(offset, offset + DBFS_PUT_MAX_BYTES);
+            await this.client.dbfs.addBlock({
+                handle,
+                data: slice.toString("base64"),
+            });
+        }
+        await this.client.dbfs.close({ handle });
+    }
+    async writeWorkspaceFile(absolutePath, buffer, overwrite) {
+        await this.client.workspace.import({
+            path: absolutePath,
+            format: "AUTO",
+            content: buffer.toString("base64"),
+            overwrite,
+        });
+    }
+    /* --- MastraFilesystem API --- */
+    getInfo() {
+        return {
+            id: this.id,
+            name: this.name,
+            provider: this.provider,
+            status: this.status,
+            readOnly: this.readOnly,
+            metadata: { basePath: this.basePath },
+        };
+    }
+    getInstructions() {
+        return [
+            `Files live in Databricks under ${this.basePath}.`,
+            "Workspace paths are absolute within this root (for example `/notes/report.md`).",
+            "Workspace paths use `/Workspace/...`, `/Users/...`, or `/Repos/...` base paths.",
+            "Unity Catalog volumes use `/Volumes/<catalog>/<schema>/<volume>/...` base paths.",
+        ].join(" ");
+    }
+    /** Map a workspace-relative path to the backing Databricks absolute path. */
+    resolveAbsolutePath(inputPath) {
+        return this.resolvePath(inputPath);
+    }
+    /** Read file contents from the workspace namespace. */
+    async readFile(inputPath, options) {
+        await this.ensureReady();
+        const empty = await this.emptyFallback();
+        if (empty)
+            return empty.readFile(inputPath, options);
+        const absolutePath = this.resolvePath(inputPath);
+        try {
+            const buffer = await this.readAbsolute(absolutePath);
+            return formatReadResult(buffer, options?.encoding);
+        }
+        catch (err) {
+            this.rethrow(err, inputPath);
+        }
+    }
+    /** Write file contents into the workspace namespace. */
+    async writeFile(inputPath, content, options) {
+        await this.ensureReady();
+        const empty = await this.emptyFallback();
+        if (empty)
+            return empty.writeFile(inputPath, content, options);
+        this.assertWritable("writeFile");
+        const absolutePath = this.resolvePath(inputPath);
+        const buffer = toBuffer(content);
+        const overwrite = options?.overwrite ?? true;
+        try {
+            if (!overwrite && (await this.exists(inputPath))) {
+                throw new FileExistsError(inputPath);
+            }
+            await this.writeAbsolute(absolutePath, buffer, overwrite);
+        }
+        catch (err) {
+            if (err instanceof FileExistsError)
+                throw err;
+            this.rethrow(err, inputPath);
+        }
+    }
+    /** Append to an existing file, creating it when missing. */
+    async appendFile(inputPath, content) {
+        await this.ensureReady();
+        const empty = await this.emptyFallback();
+        if (empty)
+            return empty.appendFile(inputPath, content);
+        this.assertWritable("appendFile");
+        const existing = (await this.exists(inputPath))
+            ? await this.readFile(inputPath)
+            : Buffer.alloc(0);
+        const merged = Buffer.concat([
+            Buffer.isBuffer(existing) ? existing : Buffer.from(existing, "utf8"),
+            toBuffer(content),
+        ]);
+        await this.writeFile(inputPath, merged, { overwrite: true });
+    }
+    /** Delete a file in the workspace namespace. */
+    async deleteFile(inputPath, options) {
+        await this.ensureReady();
+        const empty = await this.emptyFallback();
+        if (empty)
+            return empty.deleteFile(inputPath, options);
+        this.assertWritable("deleteFile");
+        const absolutePath = this.resolvePath(inputPath);
+        try {
+            if (!(await this.exists(inputPath))) {
+                if (options?.force)
+                    return;
+                throw new FileNotFoundError(inputPath);
+            }
+            const entry = await this.stat(inputPath);
+            if (entry.type === "directory") {
+                throw new IsDirectoryError(inputPath);
+            }
+            await this.deleteAbsoluteFile(absolutePath);
+        }
+        catch (err) {
+            if (err instanceof FileNotFoundError || err instanceof IsDirectoryError)
+                throw err;
+            this.rethrow(err, inputPath);
+        }
+    }
+    /** Copy a file within the workspace namespace. */
+    async copyFile(src, dest, options) {
+        await this.ensureReady();
+        const empty = await this.emptyFallback();
+        if (empty)
+            return empty.copyFile(src, dest, options);
+        this.assertWritable("copyFile");
+        const overwrite = options?.overwrite ?? true;
+        if (!overwrite && (await this.exists(dest))) {
+            throw new FileExistsError(dest);
+        }
+        const content = await this.readFile(src);
+        await this.writeFile(dest, content, { overwrite: true });
+    }
+    /** Move or rename a file within the workspace namespace. */
+    async moveFile(src, dest, options) {
+        await this.ensureReady();
+        const empty = await this.emptyFallback();
+        if (empty)
+            return empty.moveFile(src, dest, options);
+        this.assertWritable("moveFile");
+        const srcAbsolute = this.resolvePath(src);
+        const destAbsolute = this.resolvePath(dest);
+        const overwrite = options?.overwrite ?? true;
+        try {
+            if (!overwrite && (await this.exists(dest))) {
+                throw new FileExistsError(dest);
+            }
+            if (resolveFilesBackend(srcAbsolute) === "dbfs" &&
+                resolveFilesBackend(destAbsolute) === "dbfs") {
+                await this.client.dbfs.move({
+                    source_path: srcAbsolute,
+                    destination_path: destAbsolute,
+                });
+                return;
+            }
+            await this.copyFile(src, dest, { overwrite: true });
+            await this.deleteFile(src, { force: true });
+        }
+        catch (err) {
+            if (err instanceof FileExistsError)
+                throw err;
+            this.rethrow(err, dest);
+        }
+    }
+    /** Create a directory in the workspace namespace. */
+    async mkdir(inputPath, options) {
+        await this.ensureReady();
+        const empty = await this.emptyFallback();
+        if (empty)
+            return empty.mkdir(inputPath, options);
+        this.assertWritable("mkdir");
+        const absolutePath = this.resolvePath(inputPath);
+        try {
+            await this.mkdirAbsolute(absolutePath);
+            if (!options?.recursive) {
+                return;
+            }
+        }
+        catch (err) {
+            this.rethrow(err, inputPath);
+        }
+    }
+    /** Remove a directory from the workspace namespace. */
+    async rmdir(inputPath, options) {
+        await this.ensureReady();
+        const empty = await this.emptyFallback();
+        if (empty)
+            return empty.rmdir(inputPath, options);
+        this.assertWritable("rmdir");
+        const absolutePath = this.resolvePath(inputPath);
+        try {
+            if (!(await this.exists(inputPath))) {
+                if (options?.force)
+                    return;
+                throw new DirectoryNotFoundError(inputPath);
+            }
+            const entry = await this.stat(inputPath);
+            if (entry.type !== "directory") {
+                throw new NotDirectoryError(inputPath);
+            }
+            await this.deleteAbsolutePath(absolutePath, options?.recursive ?? false);
+        }
+        catch (err) {
+            if (err instanceof DirectoryNotFoundError ||
+                err instanceof NotDirectoryError ||
+                err instanceof DirectoryNotEmptyError) {
+                throw err;
+            }
+            this.rethrow(err, inputPath);
+        }
+    }
+    /**
+     * Recursively delete a Unity Catalog directory tree.
+     *
+     * DBFS and workspace trees use native recursive delete via
+     * {@link deleteAbsolutePath} instead.
+     */
+    async deleteUcDirectoryRecursive(absolutePath) {
+        for (const child of await this.listAbsoluteDirectory(absolutePath)) {
+            const childAbsolute = path.join(absolutePath, child.name);
+            if (child.type === "directory") {
+                await this.deleteUcDirectoryRecursive(childAbsolute);
+            }
+            else {
+                await this.deleteAbsoluteFile(childAbsolute);
+            }
+        }
+        await this.client.files.deleteDirectory({ directory_path: absolutePath });
+    }
+    /* --- directory listing --- */
+    /** List entries in a workspace directory. */
+    async readdir(inputPath, options) {
+        await this.ensureReady();
+        const empty = await this.emptyFallback();
+        if (empty)
+            return empty.readdir(inputPath, options);
+        const absolutePath = this.resolvePath(inputPath);
+        try {
+            const entries = await this.listAbsoluteDirectory(absolutePath);
+            const filtered = this.filterEntries(entries, options);
+            if (!options?.recursive)
+                return filtered;
+            return await this.readDirectoryRecursive(absolutePath, options, 0);
+        }
+        catch (err) {
+            this.rethrow(err, inputPath);
+        }
+    }
+    async readDirectoryRecursive(absolutePath, options, depth, relativePrefix = "") {
+        const maxDepth = options.maxDepth ?? Number.POSITIVE_INFINITY;
+        const entries = this.filterEntries(await this.listAbsoluteDirectory(absolutePath), options);
+        const collected = [];
+        for (const entry of entries) {
+            const relativeName = relativePrefix ? path.join(relativePrefix, entry.name) : entry.name;
+            collected.push({ ...entry, name: relativeName });
+            if (entry.type !== "directory" || depth >= maxDepth)
+                continue;
+            collected.push(...(await this.readDirectoryRecursive(path.join(absolutePath, entry.name), options, depth + 1, relativeName)));
+        }
+        return collected;
+    }
+    async listAbsoluteDirectory(absolutePath) {
+        return dispatchFilesBackend(absolutePath, {
+            dbfs: async () => {
+                const entries = [];
+                for await (const info of this.client.dbfs.list({ path: absolutePath })) {
+                    entries.push({
+                        name: path.basename(info.path ?? ""),
+                        type: info.is_dir ? "directory" : "file",
+                        size: info.file_size,
+                    });
+                }
+                return entries;
+            },
+            workspace: async () => {
+                const entries = [];
+                for await (const info of this.client.workspace.list({ path: absolutePath })) {
+                    entries.push({
+                        name: path.basename(info.path ?? ""),
+                        type: info.object_type === "DIRECTORY" ? "directory" : "file",
+                    });
+                }
+                return entries;
+            },
+            ucFiles: async () => {
+                const entries = [];
+                for await (const entry of this.client.files.listDirectoryContents({
+                    directory_path: absolutePath,
+                })) {
+                    entries.push({
+                        name: entry.name ?? path.basename(entry.path ?? ""),
+                        type: entry.is_directory ? "directory" : "file",
+                        size: entry.file_size,
+                    });
+                }
+                return entries;
+            },
+        });
+    }
+    /** Apply Mastra list filters (`extension`, etc.) to directory entries. */
+    filterEntries(entries, options) {
+        if (!options?.extension)
+            return entries;
+        const extensions = Array.isArray(options.extension) ? options.extension : [options.extension];
+        const normalized = extensions.map((ext) => ext.startsWith(".") ? ext.toLowerCase() : `.${ext.toLowerCase()}`);
+        return entries.filter((entry) => {
+            if (entry.type !== "file")
+                return true;
+            const lower = entry.name.toLowerCase();
+            return normalized.some((ext) => lower.endsWith(ext));
+        });
+    }
+    /* --- metadata --- */
+    /** Return whether `inputPath` exists in the workspace namespace. */
+    async exists(inputPath) {
+        await this.ensureReady();
+        const empty = await this.emptyFallback();
+        if (empty)
+            return empty.exists(inputPath);
+        try {
+            await this.stat(inputPath);
+            return true;
+        }
+        catch (err) {
+            if (err instanceof FileNotFoundError)
+                return false;
+            throw err;
+        }
+    }
+    /** Return file or directory metadata for `inputPath`. */
+    async stat(inputPath) {
+        await this.ensureReady();
+        const empty = await this.emptyFallback();
+        if (empty)
+            return empty.stat(inputPath);
+        const absolutePath = this.resolvePath(inputPath);
+        const workspacePath = this.workspacePath(absolutePath);
+        try {
+            return await dispatchFilesBackend(absolutePath, {
+                dbfs: async () => {
+                    const info = await this.client.dbfs.getStatus({ path: absolutePath });
+                    return {
+                        name: path.basename(info.path ?? absolutePath),
+                        path: workspacePath,
+                        type: info.is_dir ? "directory" : "file",
+                        size: info.file_size ?? 0,
+                        createdAt: new Date(info.modification_time ?? 0),
+                        modifiedAt: new Date(info.modification_time ?? 0),
+                    };
+                },
+                workspace: async () => {
+                    const info = await this.client.workspace.getStatus({ path: absolutePath });
+                    return {
+                        name: path.basename(info.path ?? absolutePath),
+                        path: workspacePath,
+                        type: info.object_type === "DIRECTORY" ? "directory" : "file",
+                        size: 0,
+                        createdAt: new Date(info.created_at ?? 0),
+                        modifiedAt: new Date(info.modified_at ?? 0),
+                    };
+                },
+                ucFiles: () => this.statUcAbsolute(absolutePath, workspacePath, inputPath),
+            });
+        }
+        catch (err) {
+            this.rethrow(err, inputPath);
+        }
+    }
+    /**
+     * Stat a Unity Catalog path by probing file metadata first, then
+     * directory metadata.
+     */
+    async statUcAbsolute(absolutePath, workspacePath, inputPath) {
+        try {
+            const metadata = await this.client.files.getMetadata({
+                file_path: absolutePath,
+            });
+            return {
+                name: path.basename(absolutePath),
+                path: workspacePath,
+                type: "file",
+                size: Number(metadata["content-length"] ?? 0),
+                createdAt: parseHttpDate(metadata["last-modified"]),
+                modifiedAt: parseHttpDate(metadata["last-modified"]),
+                mimeType: metadata["content-type"],
+            };
+        }
+        catch (fileErr) {
+            if (!error.errorContext(fileErr).notAccessible) {
+                this.rethrow(fileErr, inputPath);
+            }
+            await this.client.files.getDirectoryMetadata({
+                directory_path: absolutePath,
+            });
+            return {
+                name: path.basename(absolutePath),
+                path: workspacePath,
+                type: "directory",
+                size: 0,
+                createdAt: new Date(0),
+                modifiedAt: new Date(0),
+            };
+        }
+    }
+}
+/* --------------------------- empty filesystem --------------------------- */
+/** Normalize paths for the in-memory empty filesystem namespace. */
+function normalizeEmptyFilesystemPath(inputPath) {
+    const trimmed = inputPath.trim();
+    if (!trimmed || trimmed === ".")
+        return "/";
+    const normalized = trimmed.startsWith("/")
+        ? path.normalize(trimmed)
+        : path.normalize(`/${trimmed}`);
+    return normalized === "." ? "/" : normalized;
+}
+/**
+ * Read-only in-memory {@link WorkspaceFilesystem} with a single empty root.
+ * Use {@link emptyFilesystem} rather than constructing directly.
+ */
+class EmptyFilesystem extends MastraFilesystem {
+    id = "empty-fs";
+    name = "EmptyFilesystem";
+    provider = "empty";
+    readOnly = true;
+    status = "pending";
+    constructor() {
+        super({ name: "EmptyFilesystem" });
+    }
+    async init() {
+        // No remote or on-disk resources to provision.
+    }
+    async destroy() {
+        // Stateless; nothing to release.
+    }
+    getInfo() {
+        return {
+            id: this.id,
+            name: this.name,
+            provider: this.provider,
+            status: this.status,
+            readOnly: this.readOnly,
+        };
+    }
+    getInstructions() {
+        return "This filesystem is empty and read-only.";
+    }
+    rootStat() {
+        return {
+            name: "/",
+            path: "/",
+            type: "directory",
+            size: 0,
+            createdAt: EMPTY_FILESYSTEM_EPOCH,
+            modifiedAt: EMPTY_FILESYSTEM_EPOCH,
+        };
+    }
+    assertWritable(operation) {
+        throw new WorkspaceReadOnlyError(operation);
+    }
+    async readFile(inputPath, _options) {
+        await this.ensureReady();
+        const normalized = normalizeEmptyFilesystemPath(inputPath);
+        if (normalized === "/") {
+            throw new IsDirectoryError(normalized);
+        }
+        throw new FileNotFoundError(normalized);
+    }
+    async writeFile(_inputPath, _content, _options) {
+        await this.ensureReady();
+        this.assertWritable("writeFile");
+    }
+    async appendFile(_inputPath, _content) {
+        await this.ensureReady();
+        this.assertWritable("appendFile");
+    }
+    async deleteFile(inputPath, options) {
+        await this.ensureReady();
+        const normalized = normalizeEmptyFilesystemPath(inputPath);
+        if (normalized === "/") {
+            throw new IsDirectoryError(normalized);
+        }
+        if (options?.force)
+            return;
+        throw new FileNotFoundError(normalized);
+    }
+    async copyFile(src, _dest, _options) {
+        await this.ensureReady();
+        const normalizedSrc = normalizeEmptyFilesystemPath(src);
+        if (normalizedSrc !== "/") {
+            throw new FileNotFoundError(normalizedSrc);
+        }
+        throw new IsDirectoryError(normalizedSrc);
+    }
+    async moveFile(src, dest, options) {
+        await this.copyFile(src, dest, options);
+    }
+    async mkdir(_inputPath, _options) {
+        await this.ensureReady();
+        this.assertWritable("mkdir");
+    }
+    async rmdir(inputPath, options) {
+        await this.ensureReady();
+        const normalized = normalizeEmptyFilesystemPath(inputPath);
+        if (normalized === "/") {
+            throw new DirectoryNotEmptyError(normalized);
+        }
+        if (options?.force)
+            return;
+        throw new DirectoryNotFoundError(normalized);
+    }
+    async readdir(inputPath, _options) {
+        await this.ensureReady();
+        const normalized = normalizeEmptyFilesystemPath(inputPath);
+        if (normalized === "/")
+            return [];
+        throw new DirectoryNotFoundError(normalized);
+    }
+    async exists(inputPath) {
+        await this.ensureReady();
+        return normalizeEmptyFilesystemPath(inputPath) === "/";
+    }
+    async stat(inputPath) {
+        await this.ensureReady();
+        const normalized = normalizeEmptyFilesystemPath(inputPath);
+        if (normalized === "/")
+            return this.rootStat();
+        throw new FileNotFoundError(normalized);
+    }
+}
+/** Memoized singleton empty read-only filesystem for no-op mounts. */
+export const emptyFilesystem = functionModule.memoize(() => new EmptyFilesystem());
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filesystems.js","sourceRoot":"","sources":["../../src/filesystems.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Mastra {@link WorkspaceFilesystem} implementations for Databricks Apps.\n *\n * {@link DatabricksWorkspaceFilesystem} maps a Mastra workspace namespace onto\n * an absolute Databricks path (Unity Catalog volume, workspace object tree, or\n * DBFS). {@link emptyFilesystem} is a read-only no-op mount used when no\n * dynamic mounts resolve for a request.\n *\n * Path helpers ({@link normalizeDatabricksBasePath}, {@link isDbfsPath}, …)\n * are exported for tests and callers that need to reason about Databricks\n * paths without constructing a filesystem.\n *\n * @module\n */\n\nimport { posix as path } from \"node:path\";\nimport { ExecutionError, getExecutionContext, ValidationError } from \"@databricks/appkit\";\nimport { WorkspaceClient } from \"@databricks/sdk-experimental\";\nimport { error, functionModule, hash, log } from \"@dbx-tools/shared-core\";\nimport {\n  DirectoryNotEmptyError,\n  DirectoryNotFoundError,\n  FileExistsError,\n  FileNotFoundError,\n  IsDirectoryError,\n  MastraFilesystem,\n  NotDirectoryError,\n  PermissionError,\n  WorkspaceReadOnlyError,\n} from \"@mastra/core/workspace\";\nimport type {\n  CopyOptions,\n  FileContent,\n  FileEntry,\n  FileStat,\n  FilesystemInfo,\n  ListOptions,\n  MastraFilesystemOptions,\n  ProviderStatus,\n  ReadOptions,\n  RemoveOptions,\n  WriteOptions,\n} from \"@mastra/core/workspace\";\n\n/* ------------------------------ constants ------------------------------ */\n\nconst DBFS_READ_CHUNK_BYTES = 1024 * 1024;\nconst DBFS_PUT_MAX_BYTES = 1024 * 1024;\nconst EMPTY_FILESYSTEM_EPOCH = new Date(0);\n\n/** Mastra error constructor for a known SDK filesystem failure, if any. */\nfunction filesystemSdkErrorType(err: unknown): (new (path: string) => Error) | undefined {\n  if (err) {\n    const ctx = error.errorContext(err);\n    if (ctx.notAccessible) {\n      return FileNotFoundError;\n    } else if (ctx.hasMessage(\"already\", \"exists\")) {\n      return FileExistsError;\n    } else if (ctx.hasMessage(\"not\", \"directory\")) {\n      return NotDirectoryError;\n    } else if (ctx.hasMessage(\"not\", \"file\")) {\n      return IsDirectoryError;\n    }\n  }\n  return undefined;\n}\n\nconst logger = log.logger(\"mastra/filesystems\");\n\n/** How {@link DatabricksWorkspaceFilesystem.init} handles a missing {@link basePath}. */\nexport type DatabricksMkdirsMode = boolean | \"try\";\n\n/** Options for {@link DatabricksWorkspaceFilesystem}. */\nexport interface DatabricksWorkspaceFilesystemOptions extends MastraFilesystemOptions {\n  /** Unique identifier for this filesystem instance. */\n  id?: string;\n  /** Auth-scoped Databricks workspace client. */\n  client?: WorkspaceClient;\n  /**\n   * Absolute Databricks path that roots the workspace namespace, e.g.\n   * `/Volumes/catalog/schema/volume` or `/dbfs/FileStore/shared`.\n   */\n  basePath: string;\n  /**\n   * When the {@link basePath} is missing at {@link init}, create it with the\n   * matching Databricks `mkdirs` API. `\"try\"` (default) logs at debug and\n   * falls back to an empty read-only namespace on failure; `true` fails init;\n   * `false` skips creation and uses the empty namespace.\n   *\n   * A successful mkdir also satisfies the write-access probe when\n   * {@link readOnly} is omitted.\n   */\n  mkdirs?: DatabricksMkdirsMode;\n  /** Block writes while still allowing reads. When omitted, {@link init} probes write access. */\n  readOnly?: boolean;\n}\n\n/* ------------------------- exported path helpers ------------------------- */\n\n/** Normalize a Databricks base path (POSIX, no trailing slash). */\nexport function normalizeDatabricksBasePath(basePath: string): string {\n  const trimmed = basePath.trim();\n  if (!trimmed.startsWith(\"/\")) {\n    throw ValidationError.invalidValue(\n      \"basePath\",\n      basePath,\n      \"an absolute Databricks path, e.g. /Volumes/catalog/schema/volume\",\n    );\n  }\n  return trimmed.replace(/\\/+$/, \"\") || \"/\";\n}\n\n/** True when `absolutePath` is served by DBFS rather than the UC Files API. */\nexport function isDbfsPath(absolutePath: string): boolean {\n  return absolutePath === \"/dbfs\" || absolutePath.startsWith(\"/dbfs/\");\n}\n\n/** True when `absolutePath` is a Databricks workspace object path. */\nexport function isWorkspaceFilesPath(absolutePath: string): boolean {\n  return (\n    absolutePath === \"/Workspace\" ||\n    absolutePath.startsWith(\"/Workspace/\") ||\n    absolutePath.startsWith(\"/Users/\") ||\n    absolutePath.startsWith(\"/Repos/\")\n  );\n}\n\ntype FilesBackend = \"dbfs\" | \"workspace\" | \"uc-files\";\n\n/** Per-backend async handler used by {@link dispatchFilesBackend}. */\ntype FilesBackendHandlers<T = unknown> = {\n  dbfs: () => Promise<T>;\n  workspace: () => Promise<T>;\n  ucFiles: () => Promise<T>;\n};\n\n/**\n * Resolve a workspace-relative path to an absolute Databricks path under\n * `basePath`.\n */\nexport function resolveDatabricksAbsolutePath(basePath: string, inputPath: string): string {\n  const root = normalizeDatabricksBasePath(basePath);\n  const trimmed = inputPath.trim();\n  if (!trimmed || trimmed === \"/\") return root;\n  const normalized = trimmed.startsWith(\"/\") ? trimmed : `/${trimmed}`;\n  if (normalized === root || normalized.startsWith(`${root}/`)) {\n    return path.normalize(normalized);\n  }\n  return path.normalize(path.join(root, normalized));\n}\n\n/** Map an absolute Databricks path back to the workspace namespace. */\nexport function toDatabricksWorkspacePath(basePath: string, absolutePath: string): string {\n  const root = normalizeDatabricksBasePath(basePath);\n  const normalized = path.normalize(absolutePath);\n  if (normalized === root) return \"/\";\n  if (normalized.startsWith(`${root}/`)) {\n    return normalized.slice(root.length) || \"/\";\n  }\n  return normalized;\n}\n\n/* ---------------------------- private helpers ---------------------------- */\n\n/** Pick the Databricks Files API backend for an absolute path. */\nfunction resolveFilesBackend(absolutePath: string): FilesBackend {\n  if (isDbfsPath(absolutePath)) return \"dbfs\";\n  if (isWorkspaceFilesPath(absolutePath)) return \"workspace\";\n  return \"uc-files\";\n}\n\n/** Run the handler that matches `absolutePath`'s Databricks backend. */\nasync function dispatchFilesBackend<T>(\n  absolutePath: string,\n  handlers: FilesBackendHandlers<T>,\n): Promise<T> {\n  const backend = resolveFilesBackend(absolutePath);\n  if (backend === \"dbfs\") return handlers.dbfs();\n  if (backend === \"workspace\") return handlers.workspace();\n  return handlers.ucFiles();\n}\n\n/** Return `buffer` as a string when `encoding` is set, otherwise unchanged. */\nfunction formatReadResult(buffer: Buffer, encoding?: BufferEncoding): string | Buffer {\n  return encoding ? buffer.toString(encoding) : buffer;\n}\n\n/** Drain a fetch `ReadableStream` into a single `Buffer`. */\nasync function readResponseBody(\n  contents: globalThis.ReadableStream<Uint8Array> | undefined,\n): Promise<Buffer> {\n  if (!contents) return Buffer.alloc(0);\n  const reader = contents.getReader();\n  const chunks: Uint8Array[] = [];\n  while (true) {\n    const { done, value } = await reader.read();\n    if (done) break;\n    if (value) chunks.push(value);\n  }\n  return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)));\n}\n\n/** Coerce Mastra {@link FileContent} to a `Buffer`. */\nfunction toBuffer(content: FileContent): Buffer {\n  if (typeof content === \"string\") return Buffer.from(content, \"utf8\");\n  return Buffer.from(content);\n}\n\n/** Decode a DBFS read payload from base64. */\nfunction decodeDbfsPayload(data: string | undefined): Buffer {\n  if (!data) return Buffer.alloc(0);\n  return Buffer.from(data, \"base64\");\n}\n\n/** Wrap a `Buffer` as a one-shot `ReadableStream` for UC file uploads. */\nfunction bufferToReadableStream(buffer: Buffer): globalThis.ReadableStream<Uint8Array> {\n  return new ReadableStream<Uint8Array>({\n    start(controller) {\n      controller.enqueue(new Uint8Array(buffer));\n      controller.close();\n    },\n  });\n}\n\n/** Parse an HTTP date header; returns epoch when missing or invalid. */\nfunction parseHttpDate(value: string | undefined): Date {\n  if (!value) return new Date(0);\n  const parsed = Date.parse(value);\n  return Number.isFinite(parsed) ? new Date(parsed) : new Date(0);\n}\n\n/* ---------------- DatabricksWorkspaceFilesystem ---------------- */\n\n/**\n * Mastra filesystem provider that reads and writes through a Databricks\n * {@link WorkspaceClient}.\n *\n * Workspace paths are absolute within the namespace (`/notes.md` maps to\n * `<basePath>/notes.md`). Unity Catalog volumes use the Files API;\n * `/dbfs/...` paths use DBFS.\n */\nexport class DatabricksWorkspaceFilesystem extends MastraFilesystem {\n  readonly id: string;\n  readonly name = \"DatabricksWorkspaceFilesystem\";\n  readonly provider = \"databricks\";\n  readonly basePath: string;\n  status: ProviderStatus = \"pending\";\n\n  private readonly client: WorkspaceClient;\n  private readonly mkdirs: DatabricksMkdirsMode;\n  private _readOnly: boolean | undefined;\n  private _basePathMissing: boolean | undefined;\n\n  get readOnly(): boolean | undefined {\n    return this._readOnly;\n  }\n\n  /**\n   * @param options.client - Defaults to the AppKit execution-context client.\n   * @param options.mkdirs - Default `\"try\"`; see {@link DatabricksMkdirsMode}.\n   * @param options.readOnly - When omitted, {@link init} probes write access.\n   */\n  constructor(options: DatabricksWorkspaceFilesystemOptions) {\n    super({ name: \"DatabricksWorkspaceFilesystem\", ...options });\n    this.id = options.id ?? `databricks-fs-${hash.fnvHash(options.basePath)}`;\n    this.client = options.client ?? getExecutionContext().client;\n    this.basePath = normalizeDatabricksBasePath(options.basePath);\n    this.mkdirs = options.mkdirs ?? \"try\";\n    this._readOnly = options.readOnly;\n  }\n\n  /* --- path resolution --- */\n\n  /** Resolve and sandbox a workspace-relative path under {@link basePath}. */\n  private resolvePath(inputPath: string): string {\n    const resolved = resolveDatabricksAbsolutePath(this.basePath, inputPath);\n    if (resolved !== this.basePath && !resolved.startsWith(`${this.basePath}/`)) {\n      throw new PermissionError(inputPath, \"access\");\n    }\n    return resolved;\n  }\n\n  /** Map a Databricks absolute path back to the workspace namespace. */\n  private workspacePath(absolutePath: string): string {\n    return toDatabricksWorkspacePath(this.basePath, absolutePath);\n  }\n\n  /** Throw when the filesystem is read-only. */\n  private assertWritable(operation: string): void {\n    if (this.readOnly) {\n      throw new WorkspaceReadOnlyError(operation);\n    }\n  }\n\n  /** Map SDK / HTTP errors to Mastra workspace filesystem errors. */\n  private rethrow(err: unknown, inputPath: string): never {\n    const workspacePath = inputPath.startsWith(\"/\")\n      ? inputPath\n      : this.workspacePath(this.resolvePath(inputPath));\n    const ErrorType = filesystemSdkErrorType(err);\n    if (ErrorType) {\n      throw new ErrorType(workspacePath);\n    }\n    // The upstream message is logged rather than raised: it reaches the model\n    // (and from there the chat transcript) as the tool's failure text.\n    logger.warn(\"operation-failed\", {\n      path: workspacePath,\n      error: error.errorMessage(err),\n    });\n    throw new ExecutionError(`Databricks filesystem operation failed for ${workspacePath}`, {\n      cause: error.toError(err),\n      context: { path: workspacePath },\n    });\n  }\n\n  /* --- lifecycle --- */\n\n  /**\n   * Probe whether {@link basePath} exists and cache the result on\n   * {@link _basePathMissing}.\n   */\n  private async resolveBasePathStatus(): Promise<void> {\n    if (this._basePathMissing !== undefined) return;\n    try {\n      await this.assertAbsoluteReadable(this.basePath);\n      this._basePathMissing = false;\n    } catch (err) {\n      if (error.errorContext(err).notAccessible) {\n        this._basePathMissing = true;\n        return;\n      }\n      this.rethrow(err, \"/\");\n    }\n  }\n\n  /** Delegate to {@link emptyFilesystem} when the base path is missing. */\n  private async emptyFallback(): Promise<ReturnType<typeof emptyFilesystem> | undefined> {\n    await this.resolveBasePathStatus();\n    return this._basePathMissing ? emptyFilesystem() : undefined;\n  }\n\n  override async init(): Promise<void> {\n    await this.resolveBasePathStatus();\n\n    if (this._basePathMissing) {\n      if (this.mkdirs === false) {\n        return;\n      }\n      try {\n        await this.mkdirAbsolute(this.basePath);\n        this._basePathMissing = false;\n        if (this._readOnly === undefined) {\n          this._readOnly = false;\n        }\n      } catch (err) {\n        if (this.mkdirs === true) {\n          this.rethrow(err, \"/\");\n        }\n        logger.debug(\"mkdirs:try-failed\", {\n          basePath: this.basePath,\n          error: error.errorMessage(err),\n        });\n      }\n      return;\n    }\n\n    if (this._readOnly === undefined) {\n      await this.probeReadOnly();\n    }\n  }\n\n  /**\n   * Write and delete a ephemeral probe file to detect read-only access when\n   * {@link DatabricksWorkspaceFilesystemOptions.readOnly} was not set.\n   *\n   * @returns `true` when the probe write (and cleanup) succeeded.\n   */\n  private async probeReadOnly(): Promise<boolean> {\n    const absolutePath = this.resolvePath(`/.__dbx_fs_probe_${hash.id()}`);\n    try {\n      await this.writeAbsolute(absolutePath, Buffer.from(\"probe\\n\"), true);\n      this._readOnly = false;\n    } catch {\n      this._readOnly = true;\n      return false;\n    }\n    try {\n      await this.deleteAbsoluteFile(absolutePath);\n    } catch {\n      // Writable; leave a hidden probe file rather than failing init.\n    }\n    return true;\n  }\n\n  override async destroy(): Promise<void> {\n    // Remote filesystem; nothing to tear down locally.\n  }\n\n  /* --- backend I/O --- */\n\n  /** Probe that `absolutePath` exists (file or directory metadata). */\n  private async assertAbsoluteReadable(absolutePath: string): Promise<void> {\n    await dispatchFilesBackend(absolutePath, {\n      dbfs: () => this.client.dbfs.getStatus({ path: absolutePath }),\n      workspace: () => this.client.workspace.getStatus({ path: absolutePath }),\n      ucFiles: () => this.client.files.getDirectoryMetadata({ directory_path: absolutePath }),\n    });\n  }\n\n  /** Read the full contents of `absolutePath` from the matching backend. */\n  private async readAbsolute(absolutePath: string): Promise<Buffer> {\n    return dispatchFilesBackend(absolutePath, {\n      dbfs: () => this.readDbfsFile(absolutePath),\n      workspace: () => this.readWorkspaceFile(absolutePath),\n      ucFiles: async () => {\n        const response = await this.client.files.download({ file_path: absolutePath });\n        return readResponseBody(\n          response.contents as globalThis.ReadableStream<Uint8Array> | undefined,\n        );\n      },\n    });\n  }\n\n  /** Write `buffer` to `absolutePath` on the matching backend. */\n  private async writeAbsolute(\n    absolutePath: string,\n    buffer: Buffer,\n    overwrite: boolean,\n  ): Promise<void> {\n    await dispatchFilesBackend(absolutePath, {\n      dbfs: () => this.writeDbfsFile(absolutePath, buffer, overwrite),\n      workspace: () => this.writeWorkspaceFile(absolutePath, buffer, overwrite),\n      ucFiles: () => this.uploadUcFile(absolutePath, buffer, overwrite),\n    });\n  }\n\n  /** Upload a buffer to a Unity Catalog Files API path. */\n  private uploadUcFile(absolutePath: string, buffer: Buffer, overwrite: boolean): Promise<unknown> {\n    return this.client.files.upload({\n      file_path: absolutePath,\n      contents: bufferToReadableStream(buffer) as never,\n      overwrite,\n    });\n  }\n\n  /** Delete a single file at `absolutePath` (non-recursive). */\n  private async deleteAbsoluteFile(absolutePath: string): Promise<void> {\n    await dispatchFilesBackend(absolutePath, {\n      dbfs: () => this.client.dbfs.delete({ path: absolutePath, recursive: false }),\n      workspace: () => this.client.workspace.delete({ path: absolutePath, recursive: false }),\n      ucFiles: () => this.client.files.delete({ file_path: absolutePath }),\n    });\n  }\n\n  /**\n   * Delete a file or directory at `absolutePath`.\n   *\n   * DBFS and workspace APIs accept `recursive`; UC volumes recurse manually.\n   */\n  private async deleteAbsolutePath(absolutePath: string, recursive: boolean): Promise<void> {\n    await dispatchFilesBackend(absolutePath, {\n      dbfs: async () => {\n        await this.client.dbfs.delete({ path: absolutePath, recursive });\n      },\n      workspace: async () => {\n        await this.client.workspace.delete({ path: absolutePath, recursive });\n      },\n      ucFiles: async () => {\n        if (recursive) {\n          await this.deleteUcDirectoryRecursive(absolutePath);\n          return;\n        }\n        const children = await this.listAbsoluteDirectory(absolutePath);\n        if (children.length > 0) {\n          throw new DirectoryNotEmptyError(this.workspacePath(absolutePath));\n        }\n        await this.client.files.deleteDirectory({ directory_path: absolutePath });\n      },\n    });\n  }\n\n  /** Create `absolutePath` and any missing parents on the matching backend. */\n  private async mkdirAbsolute(absolutePath: string): Promise<void> {\n    await dispatchFilesBackend(absolutePath, {\n      dbfs: () => this.client.dbfs.mkdirs({ path: absolutePath }),\n      workspace: () => this.client.workspace.mkdirs({ path: absolutePath }),\n      ucFiles: () => this.client.files.createDirectory({ directory_path: absolutePath }),\n    });\n  }\n\n  private async readDbfsFile(absolutePath: string): Promise<Buffer> {\n    const chunks: Buffer[] = [];\n    let offset = 0;\n    while (true) {\n      const response = await this.client.dbfs.read({\n        path: absolutePath,\n        offset,\n        length: DBFS_READ_CHUNK_BYTES,\n      });\n      const chunk = decodeDbfsPayload(response.data);\n      if (chunk.length === 0) break;\n      chunks.push(chunk);\n      offset += chunk.length;\n      if (chunk.length < DBFS_READ_CHUNK_BYTES) break;\n    }\n    return Buffer.concat(chunks);\n  }\n\n  private async readWorkspaceFile(absolutePath: string): Promise<Buffer> {\n    const response = await this.client.workspace.export({\n      path: absolutePath,\n      format: \"AUTO\",\n    });\n    return decodeDbfsPayload(response.content);\n  }\n\n  private async writeDbfsFile(\n    absolutePath: string,\n    buffer: Buffer,\n    overwrite: boolean,\n  ): Promise<void> {\n    if (buffer.length <= DBFS_PUT_MAX_BYTES) {\n      await this.client.dbfs.put({\n        path: absolutePath,\n        contents: buffer.toString(\"base64\"),\n        overwrite,\n      });\n      return;\n    }\n    const created = await this.client.dbfs.create({ path: absolutePath, overwrite });\n    const handle = created.handle;\n    if (handle === undefined) {\n      throw ExecutionError.missingData(\"DBFS upload handle\");\n    }\n    for (let offset = 0; offset < buffer.length; offset += DBFS_PUT_MAX_BYTES) {\n      const slice = buffer.subarray(offset, offset + DBFS_PUT_MAX_BYTES);\n      await this.client.dbfs.addBlock({\n        handle,\n        data: slice.toString(\"base64\"),\n      });\n    }\n    await this.client.dbfs.close({ handle });\n  }\n\n  private async writeWorkspaceFile(\n    absolutePath: string,\n    buffer: Buffer,\n    overwrite: boolean,\n  ): Promise<void> {\n    await this.client.workspace.import({\n      path: absolutePath,\n      format: \"AUTO\",\n      content: buffer.toString(\"base64\"),\n      overwrite,\n    });\n  }\n\n  /* --- MastraFilesystem API --- */\n\n  getInfo(): FilesystemInfo<{ basePath: string }> {\n    return {\n      id: this.id,\n      name: this.name,\n      provider: this.provider,\n      status: this.status,\n      readOnly: this.readOnly,\n      metadata: { basePath: this.basePath },\n    };\n  }\n\n  getInstructions(): string {\n    return [\n      `Files live in Databricks under ${this.basePath}.`,\n      \"Workspace paths are absolute within this root (for example `/notes/report.md`).\",\n      \"Workspace paths use `/Workspace/...`, `/Users/...`, or `/Repos/...` base paths.\",\n      \"Unity Catalog volumes use `/Volumes/<catalog>/<schema>/<volume>/...` base paths.\",\n    ].join(\" \");\n  }\n\n  /** Map a workspace-relative path to the backing Databricks absolute path. */\n  resolveAbsolutePath(inputPath: string): string | undefined {\n    return this.resolvePath(inputPath);\n  }\n\n  /** Read file contents from the workspace namespace. */\n  async readFile(inputPath: string, options?: ReadOptions): Promise<string | Buffer> {\n    await this.ensureReady();\n    const empty = await this.emptyFallback();\n    if (empty) return empty.readFile(inputPath, options);\n    const absolutePath = this.resolvePath(inputPath);\n    try {\n      const buffer = await this.readAbsolute(absolutePath);\n      return formatReadResult(buffer, options?.encoding);\n    } catch (err) {\n      this.rethrow(err, inputPath);\n    }\n  }\n\n  /** Write file contents into the workspace namespace. */\n  async writeFile(inputPath: string, content: FileContent, options?: WriteOptions): Promise<void> {\n    await this.ensureReady();\n    const empty = await this.emptyFallback();\n    if (empty) return empty.writeFile(inputPath, content, options);\n    this.assertWritable(\"writeFile\");\n    const absolutePath = this.resolvePath(inputPath);\n    const buffer = toBuffer(content);\n    const overwrite = options?.overwrite ?? true;\n    try {\n      if (!overwrite && (await this.exists(inputPath))) {\n        throw new FileExistsError(inputPath);\n      }\n      await this.writeAbsolute(absolutePath, buffer, overwrite);\n    } catch (err) {\n      if (err instanceof FileExistsError) throw err;\n      this.rethrow(err, inputPath);\n    }\n  }\n\n  /** Append to an existing file, creating it when missing. */\n  async appendFile(inputPath: string, content: FileContent): Promise<void> {\n    await this.ensureReady();\n    const empty = await this.emptyFallback();\n    if (empty) return empty.appendFile(inputPath, content);\n    this.assertWritable(\"appendFile\");\n    const existing = (await this.exists(inputPath))\n      ? await this.readFile(inputPath)\n      : Buffer.alloc(0);\n    const merged = Buffer.concat([\n      Buffer.isBuffer(existing) ? existing : Buffer.from(existing, \"utf8\"),\n      toBuffer(content),\n    ]);\n    await this.writeFile(inputPath, merged, { overwrite: true });\n  }\n\n  /** Delete a file in the workspace namespace. */\n  async deleteFile(inputPath: string, options?: RemoveOptions): Promise<void> {\n    await this.ensureReady();\n    const empty = await this.emptyFallback();\n    if (empty) return empty.deleteFile(inputPath, options);\n    this.assertWritable(\"deleteFile\");\n    const absolutePath = this.resolvePath(inputPath);\n    try {\n      if (!(await this.exists(inputPath))) {\n        if (options?.force) return;\n        throw new FileNotFoundError(inputPath);\n      }\n      const entry = await this.stat(inputPath);\n      if (entry.type === \"directory\") {\n        throw new IsDirectoryError(inputPath);\n      }\n      await this.deleteAbsoluteFile(absolutePath);\n    } catch (err) {\n      if (err instanceof FileNotFoundError || err instanceof IsDirectoryError) throw err;\n      this.rethrow(err, inputPath);\n    }\n  }\n\n  /** Copy a file within the workspace namespace. */\n  async copyFile(src: string, dest: string, options?: CopyOptions): Promise<void> {\n    await this.ensureReady();\n    const empty = await this.emptyFallback();\n    if (empty) return empty.copyFile(src, dest, options);\n    this.assertWritable(\"copyFile\");\n    const overwrite = options?.overwrite ?? true;\n    if (!overwrite && (await this.exists(dest))) {\n      throw new FileExistsError(dest);\n    }\n    const content = await this.readFile(src);\n    await this.writeFile(dest, content, { overwrite: true });\n  }\n\n  /** Move or rename a file within the workspace namespace. */\n  async moveFile(src: string, dest: string, options?: CopyOptions): Promise<void> {\n    await this.ensureReady();\n    const empty = await this.emptyFallback();\n    if (empty) return empty.moveFile(src, dest, options);\n    this.assertWritable(\"moveFile\");\n    const srcAbsolute = this.resolvePath(src);\n    const destAbsolute = this.resolvePath(dest);\n    const overwrite = options?.overwrite ?? true;\n    try {\n      if (!overwrite && (await this.exists(dest))) {\n        throw new FileExistsError(dest);\n      }\n      if (\n        resolveFilesBackend(srcAbsolute) === \"dbfs\" &&\n        resolveFilesBackend(destAbsolute) === \"dbfs\"\n      ) {\n        await this.client.dbfs.move({\n          source_path: srcAbsolute,\n          destination_path: destAbsolute,\n        });\n        return;\n      }\n      await this.copyFile(src, dest, { overwrite: true });\n      await this.deleteFile(src, { force: true });\n    } catch (err) {\n      if (err instanceof FileExistsError) throw err;\n      this.rethrow(err, dest);\n    }\n  }\n\n  /** Create a directory in the workspace namespace. */\n  async mkdir(inputPath: string, options?: { recursive?: boolean }): Promise<void> {\n    await this.ensureReady();\n    const empty = await this.emptyFallback();\n    if (empty) return empty.mkdir(inputPath, options);\n    this.assertWritable(\"mkdir\");\n    const absolutePath = this.resolvePath(inputPath);\n    try {\n      await this.mkdirAbsolute(absolutePath);\n      if (!options?.recursive) {\n        return;\n      }\n    } catch (err) {\n      this.rethrow(err, inputPath);\n    }\n  }\n\n  /** Remove a directory from the workspace namespace. */\n  async rmdir(inputPath: string, options?: RemoveOptions): Promise<void> {\n    await this.ensureReady();\n    const empty = await this.emptyFallback();\n    if (empty) return empty.rmdir(inputPath, options);\n    this.assertWritable(\"rmdir\");\n    const absolutePath = this.resolvePath(inputPath);\n    try {\n      if (!(await this.exists(inputPath))) {\n        if (options?.force) return;\n        throw new DirectoryNotFoundError(inputPath);\n      }\n      const entry = await this.stat(inputPath);\n      if (entry.type !== \"directory\") {\n        throw new NotDirectoryError(inputPath);\n      }\n      await this.deleteAbsolutePath(absolutePath, options?.recursive ?? false);\n    } catch (err) {\n      if (\n        err instanceof DirectoryNotFoundError ||\n        err instanceof NotDirectoryError ||\n        err instanceof DirectoryNotEmptyError\n      ) {\n        throw err;\n      }\n      this.rethrow(err, inputPath);\n    }\n  }\n\n  /**\n   * Recursively delete a Unity Catalog directory tree.\n   *\n   * DBFS and workspace trees use native recursive delete via\n   * {@link deleteAbsolutePath} instead.\n   */\n  private async deleteUcDirectoryRecursive(absolutePath: string): Promise<void> {\n    for (const child of await this.listAbsoluteDirectory(absolutePath)) {\n      const childAbsolute = path.join(absolutePath, child.name);\n      if (child.type === \"directory\") {\n        await this.deleteUcDirectoryRecursive(childAbsolute);\n      } else {\n        await this.deleteAbsoluteFile(childAbsolute);\n      }\n    }\n    await this.client.files.deleteDirectory({ directory_path: absolutePath });\n  }\n\n  /* --- directory listing --- */\n\n  /** List entries in a workspace directory. */\n  async readdir(inputPath: string, options?: ListOptions): Promise<FileEntry[]> {\n    await this.ensureReady();\n    const empty = await this.emptyFallback();\n    if (empty) return empty.readdir(inputPath, options);\n    const absolutePath = this.resolvePath(inputPath);\n    try {\n      const entries = await this.listAbsoluteDirectory(absolutePath);\n      const filtered = this.filterEntries(entries, options);\n      if (!options?.recursive) return filtered;\n      return await this.readDirectoryRecursive(absolutePath, options, 0);\n    } catch (err) {\n      this.rethrow(err, inputPath);\n    }\n  }\n\n  private async readDirectoryRecursive(\n    absolutePath: string,\n    options: ListOptions,\n    depth: number,\n    relativePrefix = \"\",\n  ): Promise<FileEntry[]> {\n    const maxDepth = options.maxDepth ?? Number.POSITIVE_INFINITY;\n    const entries = this.filterEntries(await this.listAbsoluteDirectory(absolutePath), options);\n    const collected: FileEntry[] = [];\n    for (const entry of entries) {\n      const relativeName = relativePrefix ? path.join(relativePrefix, entry.name) : entry.name;\n      collected.push({ ...entry, name: relativeName });\n      if (entry.type !== \"directory\" || depth >= maxDepth) continue;\n      collected.push(\n        ...(await this.readDirectoryRecursive(\n          path.join(absolutePath, entry.name),\n          options,\n          depth + 1,\n          relativeName,\n        )),\n      );\n    }\n    return collected;\n  }\n\n  private async listAbsoluteDirectory(absolutePath: string): Promise<FileEntry[]> {\n    return dispatchFilesBackend(absolutePath, {\n      dbfs: async () => {\n        const entries: FileEntry[] = [];\n        for await (const info of this.client.dbfs.list({ path: absolutePath })) {\n          entries.push({\n            name: path.basename(info.path ?? \"\"),\n            type: info.is_dir ? \"directory\" : \"file\",\n            size: info.file_size,\n          });\n        }\n        return entries;\n      },\n      workspace: async () => {\n        const entries: FileEntry[] = [];\n        for await (const info of this.client.workspace.list({ path: absolutePath })) {\n          entries.push({\n            name: path.basename(info.path ?? \"\"),\n            type: info.object_type === \"DIRECTORY\" ? \"directory\" : \"file\",\n          });\n        }\n        return entries;\n      },\n      ucFiles: async () => {\n        const entries: FileEntry[] = [];\n        for await (const entry of this.client.files.listDirectoryContents({\n          directory_path: absolutePath,\n        })) {\n          entries.push({\n            name: entry.name ?? path.basename(entry.path ?? \"\"),\n            type: entry.is_directory ? \"directory\" : \"file\",\n            size: entry.file_size,\n          });\n        }\n        return entries;\n      },\n    });\n  }\n\n  /** Apply Mastra list filters (`extension`, etc.) to directory entries. */\n  private filterEntries(entries: FileEntry[], options?: ListOptions): FileEntry[] {\n    if (!options?.extension) return entries;\n    const extensions = Array.isArray(options.extension) ? options.extension : [options.extension];\n    const normalized = extensions.map((ext) =>\n      ext.startsWith(\".\") ? ext.toLowerCase() : `.${ext.toLowerCase()}`,\n    );\n    return entries.filter((entry) => {\n      if (entry.type !== \"file\") return true;\n      const lower = entry.name.toLowerCase();\n      return normalized.some((ext) => lower.endsWith(ext));\n    });\n  }\n\n  /* --- metadata --- */\n\n  /** Return whether `inputPath` exists in the workspace namespace. */\n  async exists(inputPath: string): Promise<boolean> {\n    await this.ensureReady();\n    const empty = await this.emptyFallback();\n    if (empty) return empty.exists(inputPath);\n    try {\n      await this.stat(inputPath);\n      return true;\n    } catch (err) {\n      if (err instanceof FileNotFoundError) return false;\n      throw err;\n    }\n  }\n\n  /** Return file or directory metadata for `inputPath`. */\n  async stat(inputPath: string): Promise<FileStat> {\n    await this.ensureReady();\n    const empty = await this.emptyFallback();\n    if (empty) return empty.stat(inputPath);\n    const absolutePath = this.resolvePath(inputPath);\n    const workspacePath = this.workspacePath(absolutePath);\n    try {\n      return await dispatchFilesBackend(absolutePath, {\n        dbfs: async () => {\n          const info = await this.client.dbfs.getStatus({ path: absolutePath });\n          return {\n            name: path.basename(info.path ?? absolutePath),\n            path: workspacePath,\n            type: info.is_dir ? (\"directory\" as const) : (\"file\" as const),\n            size: info.file_size ?? 0,\n            createdAt: new Date(info.modification_time ?? 0),\n            modifiedAt: new Date(info.modification_time ?? 0),\n          };\n        },\n        workspace: async () => {\n          const info = await this.client.workspace.getStatus({ path: absolutePath });\n          return {\n            name: path.basename(info.path ?? absolutePath),\n            path: workspacePath,\n            type: info.object_type === \"DIRECTORY\" ? (\"directory\" as const) : (\"file\" as const),\n            size: 0,\n            createdAt: new Date(info.created_at ?? 0),\n            modifiedAt: new Date(info.modified_at ?? 0),\n          };\n        },\n        ucFiles: () => this.statUcAbsolute(absolutePath, workspacePath, inputPath),\n      });\n    } catch (err) {\n      this.rethrow(err, inputPath);\n    }\n  }\n\n  /**\n   * Stat a Unity Catalog path by probing file metadata first, then\n   * directory metadata.\n   */\n  private async statUcAbsolute(\n    absolutePath: string,\n    workspacePath: string,\n    inputPath: string,\n  ): Promise<FileStat> {\n    try {\n      const metadata = await this.client.files.getMetadata({\n        file_path: absolutePath,\n      });\n      return {\n        name: path.basename(absolutePath),\n        path: workspacePath,\n        type: \"file\" as const,\n        size: Number(metadata[\"content-length\"] ?? 0),\n        createdAt: parseHttpDate(metadata[\"last-modified\"]),\n        modifiedAt: parseHttpDate(metadata[\"last-modified\"]),\n        mimeType: metadata[\"content-type\"],\n      };\n    } catch (fileErr) {\n      if (!error.errorContext(fileErr).notAccessible) {\n        this.rethrow(fileErr, inputPath);\n      }\n      await this.client.files.getDirectoryMetadata({\n        directory_path: absolutePath,\n      });\n      return {\n        name: path.basename(absolutePath),\n        path: workspacePath,\n        type: \"directory\" as const,\n        size: 0,\n        createdAt: new Date(0),\n        modifiedAt: new Date(0),\n      };\n    }\n  }\n}\n\n/* --------------------------- empty filesystem --------------------------- */\n\n/** Normalize paths for the in-memory empty filesystem namespace. */\nfunction normalizeEmptyFilesystemPath(inputPath: string): string {\n  const trimmed = inputPath.trim();\n  if (!trimmed || trimmed === \".\") return \"/\";\n  const normalized = trimmed.startsWith(\"/\")\n    ? path.normalize(trimmed)\n    : path.normalize(`/${trimmed}`);\n  return normalized === \".\" ? \"/\" : normalized;\n}\n\n/**\n * Read-only in-memory {@link WorkspaceFilesystem} with a single empty root.\n * Use {@link emptyFilesystem} rather than constructing directly.\n */\nclass EmptyFilesystem extends MastraFilesystem {\n  readonly id = \"empty-fs\";\n  readonly name = \"EmptyFilesystem\";\n  readonly provider = \"empty\";\n  readonly readOnly = true;\n  status: ProviderStatus = \"pending\";\n\n  constructor() {\n    super({ name: \"EmptyFilesystem\" });\n  }\n\n  override async init(): Promise<void> {\n    // No remote or on-disk resources to provision.\n  }\n\n  override async destroy(): Promise<void> {\n    // Stateless; nothing to release.\n  }\n\n  getInfo(): FilesystemInfo {\n    return {\n      id: this.id,\n      name: this.name,\n      provider: this.provider,\n      status: this.status,\n      readOnly: this.readOnly,\n    };\n  }\n\n  getInstructions(): string {\n    return \"This filesystem is empty and read-only.\";\n  }\n\n  private rootStat(): FileStat {\n    return {\n      name: \"/\",\n      path: \"/\",\n      type: \"directory\",\n      size: 0,\n      createdAt: EMPTY_FILESYSTEM_EPOCH,\n      modifiedAt: EMPTY_FILESYSTEM_EPOCH,\n    };\n  }\n\n  private assertWritable(operation: string): void {\n    throw new WorkspaceReadOnlyError(operation);\n  }\n\n  override async readFile(inputPath: string, _options?: ReadOptions): Promise<string | Buffer> {\n    await this.ensureReady();\n    const normalized = normalizeEmptyFilesystemPath(inputPath);\n    if (normalized === \"/\") {\n      throw new IsDirectoryError(normalized);\n    }\n    throw new FileNotFoundError(normalized);\n  }\n\n  override async writeFile(\n    _inputPath: string,\n    _content: FileContent,\n    _options?: WriteOptions,\n  ): Promise<void> {\n    await this.ensureReady();\n    this.assertWritable(\"writeFile\");\n  }\n\n  override async appendFile(_inputPath: string, _content: FileContent): Promise<void> {\n    await this.ensureReady();\n    this.assertWritable(\"appendFile\");\n  }\n\n  override async deleteFile(inputPath: string, options?: RemoveOptions): Promise<void> {\n    await this.ensureReady();\n    const normalized = normalizeEmptyFilesystemPath(inputPath);\n    if (normalized === \"/\") {\n      throw new IsDirectoryError(normalized);\n    }\n    if (options?.force) return;\n    throw new FileNotFoundError(normalized);\n  }\n\n  override async copyFile(src: string, _dest: string, _options?: CopyOptions): Promise<void> {\n    await this.ensureReady();\n    const normalizedSrc = normalizeEmptyFilesystemPath(src);\n    if (normalizedSrc !== \"/\") {\n      throw new FileNotFoundError(normalizedSrc);\n    }\n    throw new IsDirectoryError(normalizedSrc);\n  }\n\n  override async moveFile(src: string, dest: string, options?: CopyOptions): Promise<void> {\n    await this.copyFile(src, dest, options);\n  }\n\n  override async mkdir(_inputPath: string, _options?: { recursive?: boolean }): Promise<void> {\n    await this.ensureReady();\n    this.assertWritable(\"mkdir\");\n  }\n\n  override async rmdir(inputPath: string, options?: RemoveOptions): Promise<void> {\n    await this.ensureReady();\n    const normalized = normalizeEmptyFilesystemPath(inputPath);\n    if (normalized === \"/\") {\n      throw new DirectoryNotEmptyError(normalized);\n    }\n    if (options?.force) return;\n    throw new DirectoryNotFoundError(normalized);\n  }\n\n  override async readdir(inputPath: string, _options?: ListOptions): Promise<FileEntry[]> {\n    await this.ensureReady();\n    const normalized = normalizeEmptyFilesystemPath(inputPath);\n    if (normalized === \"/\") return [];\n    throw new DirectoryNotFoundError(normalized);\n  }\n\n  override async exists(inputPath: string): Promise<boolean> {\n    await this.ensureReady();\n    return normalizeEmptyFilesystemPath(inputPath) === \"/\";\n  }\n\n  override async stat(inputPath: string): Promise<FileStat> {\n    await this.ensureReady();\n    const normalized = normalizeEmptyFilesystemPath(inputPath);\n    if (normalized === \"/\") return this.rootStat();\n    throw new FileNotFoundError(normalized);\n  }\n}\n\n/** Memoized singleton empty read-only filesystem for no-op mounts. */\nexport const emptyFilesystem = functionModule.memoize(() => new EmptyFilesystem());\n"]}