@dbx-tools/shared-fs 0.6.10

package/lib/src/fs.d.ts

@@ -0,0 +1,110 @@
+export type FileContent = string | Uint8Array;
+export type FileEntryType = "file" | "directory" | "symbolic-link" | "other";
+export interface FileEntry {
+    name: string;
+    type: FileEntryType;
+    size?: number;
+    /**
+     * Provider-specific information that is not part of the
+     * portable filesystem contract.
+     */
+    metadata?: Readonly<Record<string, unknown>>;
+}
+export interface FileStat extends FileEntry {
+    /** Path relative to the filesystem root. */
+    path: string;
+    createdAt?: Date;
+    modifiedAt?: Date;
+    accessedAt?: Date;
+    mimeType?: string;
+}
+export interface ReadFileOptions {
+    /**
+     * Return decoded text using this encoding.
+     * Without an encoding, readFile returns Uint8Array.
+     */
+    encoding?: string;
+}
+export interface WriteFileOptions {
+    /** Replace an existing file. Defaults to true. */
+    overwrite?: boolean;
+}
+export interface RemoveOptions {
+    /** Do not fail if the target does not exist. */
+    force?: boolean;
+    /** Recursively remove directory contents. */
+    recursive?: boolean;
+}
+export interface CopyOptions {
+    /** Replace an existing destination. Defaults to true. */
+    overwrite?: boolean;
+}
+export interface MakeDirectoryOptions {
+    /** Create missing parent directories. */
+    recursive?: boolean;
+}
+export interface ListOptions {
+    /** Recursively list descendant entries. */
+    recursive?: boolean;
+    /** Maximum recursion depth. */
+    maxDepth?: number;
+    /** Only include files with the given extension or extensions. */
+    extension?: string | string[];
+}
+/**
+ * A filesystem rooted at a local, remote, or virtual location.
+ *
+ * Possible implementations include:
+ * - Local disk
+ * - FTP or SFTP
+ * - Object storage
+ * - In-memory storage
+ * - Databricks
+ * - Database-backed storage
+ */
+export interface FileSystem<TBackend extends string = string> {
+    /** Unique identifier for this filesystem instance. */
+    readonly id: string;
+    /**
+     * Identifier for the underlying implementation.
+     *
+     * Examples: "disk", "ftp", "sftp", "memory", "s3", or "dbfs".
+     */
+    readonly backend: TBackend;
+    /**
+     * Root location exposed by this filesystem.
+     *
+     * Examples:
+     * - /var/data
+     * - ftp://example.com/files
+     * - s3://bucket/prefix
+     * - /Volumes/catalog/schema/volume
+     */
+    readonly root: string;
+    readonly readOnly: boolean;
+    /** Prepare, connect to, or validate the filesystem. */
+    init(): Promise<void>;
+    /** Release connections or other resources. */
+    close(): Promise<void>;
+    /**
+     * Resolve a filesystem-relative path into the path understood
+     * by the underlying backend.
+     */
+    resolvePath(inputPath: string): string;
+    /** Read a file as binary data. */
+    readFile(inputPath: string): Promise<Uint8Array>;
+    /** Read and decode a file as text. */
+    readFile(inputPath: string, options: ReadFileOptions & {
+        encoding: string;
+    }): Promise<string>;
+    writeFile(inputPath: string, content: FileContent, options?: WriteFileOptions): Promise<void>;
+    appendFile(inputPath: string, content: FileContent): Promise<void>;
+    deleteFile(inputPath: string, options?: RemoveOptions): Promise<void>;
+    copyFile(sourcePath: string, destinationPath: string, options?: CopyOptions): Promise<void>;
+    moveFile(sourcePath: string, destinationPath: string, options?: CopyOptions): Promise<void>;
+    mkdir(inputPath: string, options?: MakeDirectoryOptions): Promise<void>;
+    rmdir(inputPath: string, options?: RemoveOptions): Promise<void>;
+    readdir(inputPath: string, options?: ListOptions): Promise<FileEntry[]>;
+    exists(inputPath: string): Promise<boolean>;
+    stat(inputPath: string): Promise<FileStat>;
+}

package/lib/src/fs.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/memory-fs.d.ts

@@ -0,0 +1,46 @@
+/**
+ * In-memory {@link FileSystem} backed by Maps.
+ *
+ * Implements only the `*At` primitives; {@link BaseFileSystem} supplies parents,
+ * recursion, encoding, and append/copy/move fallbacks. Useful for tests and as
+ * a reference for new adapters.
+ *
+ * @module
+ */
+import { BaseFileSystem, type FileSystemRootInput } from "./base-fs.ts";
+import type { FileEntry, FileStat, WriteFileOptions } from "./fs.ts";
+/** Options for {@link MemoryFileSystem}. */
+export interface MemoryFileSystemOptions {
+    /** Unique identifier. Defaults to a stable hash of the root. */
+    id?: string;
+    /**
+     * Virtual root. Defaults to `/memory`. See {@link FileSystemRootInput}.
+     */
+    root?: FileSystemRootInput;
+    /** Block all write operations. Defaults to false. */
+    readOnly?: boolean;
+}
+/**
+ * {@link FileSystem} that stores files and directories in process memory.
+ *
+ * @example
+ * ```ts
+ * const fs = new MemoryFileSystem();
+ * await fs.writeFile("note.txt", "hi");
+ * const text = await fs.readFile("note.txt", { encoding: "utf8" });
+ * ```
+ */
+export declare class MemoryFileSystem extends BaseFileSystem<"memory"> {
+    private readonly files;
+    private readonly dirs;
+    constructor(options?: MemoryFileSystemOptions);
+    /** Drop every file and directory except the root. */
+    clear(): void;
+    protected readBytesAt(resolvedPath: string): Promise<Uint8Array>;
+    protected writeBytesAt(resolvedPath: string, content: Uint8Array, options: Required<WriteFileOptions>): Promise<void>;
+    protected deleteFileAt(resolvedPath: string): Promise<void>;
+    protected createDirectoryAt(resolvedPath: string): Promise<void>;
+    protected removeDirectoryAt(resolvedPath: string): Promise<void>;
+    protected listDirectoryAt(resolvedPath: string): Promise<FileEntry[]>;
+    protected statAt(resolvedPath: string): Promise<Omit<FileStat, "path">>;
+}

package/lib/src/memory-fs.js

@@ -0,0 +1,131 @@
+/**
+ * In-memory {@link FileSystem} backed by Maps.
+ *
+ * Implements only the `*At` primitives; {@link BaseFileSystem} supplies parents,
+ * recursion, encoding, and append/copy/move fallbacks. Useful for tests and as
+ * a reference for new adapters.
+ *
+ * @module
+ */
+import { hash } from "@dbx-tools/shared-core";
+import { BaseFileSystem, FileSystemError, normalizeFileSystemRoot, } from "./base-fs.js";
+import * as posixPath from "./posix-path.js";
+/**
+ * {@link FileSystem} that stores files and directories in process memory.
+ *
+ * @example
+ * ```ts
+ * const fs = new MemoryFileSystem();
+ * await fs.writeFile("note.txt", "hi");
+ * const text = await fs.readFile("note.txt", { encoding: "utf8" });
+ * ```
+ */
+export class MemoryFileSystem extends BaseFileSystem {
+    files = new Map();
+    dirs = new Set();
+    constructor(options = {}) {
+        const root = options.root ?? "/memory";
+        super({
+            id: options.id ?? `memory-${hash.fnvHash(normalizeFileSystemRoot(root))}`,
+            backend: "memory",
+            root,
+            readOnly: options.readOnly,
+        });
+        this.dirs.add(this.root);
+    }
+    /** Drop every file and directory except the root. */
+    clear() {
+        this.files.clear();
+        this.dirs.clear();
+        this.dirs.add(this.root);
+    }
+    async readBytesAt(resolvedPath) {
+        const bytes = this.files.get(resolvedPath);
+        if (!bytes) {
+            throw new FileSystemError("NOT_FOUND", `Not found: ${resolvedPath}`, resolvedPath);
+        }
+        return new Uint8Array(bytes);
+    }
+    async writeBytesAt(resolvedPath, content, options) {
+        if (!options.overwrite && this.files.has(resolvedPath)) {
+            throw new FileSystemError("ALREADY_EXISTS", `Exists: ${resolvedPath}`, resolvedPath);
+        }
+        if (this.dirs.has(resolvedPath)) {
+            throw new FileSystemError("IS_DIRECTORY", `Is directory: ${resolvedPath}`, resolvedPath);
+        }
+        this.files.set(resolvedPath, new Uint8Array(content));
+    }
+    async deleteFileAt(resolvedPath) {
+        if (!this.files.delete(resolvedPath)) {
+            throw new FileSystemError("NOT_FOUND", `Not found: ${resolvedPath}`, resolvedPath);
+        }
+    }
+    async createDirectoryAt(resolvedPath) {
+        if (this.files.has(resolvedPath) || this.dirs.has(resolvedPath)) {
+            throw new FileSystemError("ALREADY_EXISTS", `Exists: ${resolvedPath}`, resolvedPath);
+        }
+        this.dirs.add(resolvedPath);
+    }
+    async removeDirectoryAt(resolvedPath) {
+        if (!this.dirs.has(resolvedPath)) {
+            throw new FileSystemError("NOT_FOUND", `Not found: ${resolvedPath}`, resolvedPath);
+        }
+        if (resolvedPath === this.root) {
+            throw new FileSystemError("PERMISSION_DENIED", `Cannot remove filesystem root: ${resolvedPath}`, resolvedPath);
+        }
+        const prefix = `${resolvedPath}/`;
+        for (const file of this.files.keys()) {
+            if (file.startsWith(prefix)) {
+                throw new FileSystemError("DIRECTORY_NOT_EMPTY", `Not empty: ${resolvedPath}`, resolvedPath);
+            }
+        }
+        for (const dir of this.dirs) {
+            if (dir !== resolvedPath && dir.startsWith(prefix)) {
+                throw new FileSystemError("DIRECTORY_NOT_EMPTY", `Not empty: ${resolvedPath}`, resolvedPath);
+            }
+        }
+        this.dirs.delete(resolvedPath);
+    }
+    async listDirectoryAt(resolvedPath) {
+        if (!this.dirs.has(resolvedPath)) {
+            throw new FileSystemError("NOT_FOUND", `Not found: ${resolvedPath}`, resolvedPath);
+        }
+        const prefix = `${resolvedPath}/`;
+        const names = new Map();
+        for (const dir of this.dirs) {
+            if (!dir.startsWith(prefix))
+                continue;
+            const rest = dir.slice(prefix.length);
+            if (!rest || rest.includes("/"))
+                continue;
+            names.set(rest, { name: rest, type: "directory" });
+        }
+        for (const [file, bytes] of this.files) {
+            if (!file.startsWith(prefix))
+                continue;
+            const rest = file.slice(prefix.length);
+            if (!rest || rest.includes("/"))
+                continue;
+            names.set(rest, { name: rest, type: "file", size: bytes.byteLength });
+        }
+        return [...names.values()].sort((a, b) => a.name.localeCompare(b.name));
+    }
+    async statAt(resolvedPath) {
+        if (this.dirs.has(resolvedPath)) {
+            return {
+                name: posixPath.basename(resolvedPath) || posixPath.basename(this.root),
+                type: "directory",
+            };
+        }
+        const bytes = this.files.get(resolvedPath);
+        if (!bytes) {
+            throw new FileSystemError("NOT_FOUND", `Not found: ${resolvedPath}`, resolvedPath);
+        }
+        return {
+            name: posixPath.basename(resolvedPath),
+            type: "file",
+            size: bytes.byteLength,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"memory-fs.js","sourceRoot":"","sources":["../../src/memory-fs.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * In-memory {@link FileSystem} backed by Maps.\n *\n * Implements only the `*At` primitives; {@link BaseFileSystem} supplies parents,\n * recursion, encoding, and append/copy/move fallbacks. Useful for tests and as\n * a reference for new adapters.\n *\n * @module\n */\n\nimport { hash } from \"@dbx-tools/shared-core\";\nimport {\n  BaseFileSystem,\n  FileSystemError,\n  normalizeFileSystemRoot,\n  type FileSystemRootInput,\n} from \"./base-fs.ts\";\nimport type { FileEntry, FileStat, WriteFileOptions } from \"./fs.ts\";\nimport * as posixPath from \"./posix-path.ts\";\n\n/** Options for {@link MemoryFileSystem}. */\nexport interface MemoryFileSystemOptions {\n  /** Unique identifier. Defaults to a stable hash of the root. */\n  id?: string;\n\n  /**\n   * Virtual root. Defaults to `/memory`. See {@link FileSystemRootInput}.\n   */\n  root?: FileSystemRootInput;\n\n  /** Block all write operations. Defaults to false. */\n  readOnly?: boolean;\n}\n\n/**\n * {@link FileSystem} that stores files and directories in process memory.\n *\n * @example\n * ```ts\n * const fs = new MemoryFileSystem();\n * await fs.writeFile(\"note.txt\", \"hi\");\n * const text = await fs.readFile(\"note.txt\", { encoding: \"utf8\" });\n * ```\n */\nexport class MemoryFileSystem extends BaseFileSystem<\"memory\"> {\n  private readonly files = new Map<string, Uint8Array>();\n  private readonly dirs = new Set<string>();\n\n  constructor(options: MemoryFileSystemOptions = {}) {\n    const root = options.root ?? \"/memory\";\n    super({\n      id: options.id ?? `memory-${hash.fnvHash(normalizeFileSystemRoot(root))}`,\n      backend: \"memory\",\n      root,\n      readOnly: options.readOnly,\n    });\n    this.dirs.add(this.root);\n  }\n\n  /** Drop every file and directory except the root. */\n  clear(): void {\n    this.files.clear();\n    this.dirs.clear();\n    this.dirs.add(this.root);\n  }\n\n  protected override async readBytesAt(resolvedPath: string): Promise<Uint8Array> {\n    const bytes = this.files.get(resolvedPath);\n    if (!bytes) {\n      throw new FileSystemError(\"NOT_FOUND\", `Not found: ${resolvedPath}`, resolvedPath);\n    }\n    return new Uint8Array(bytes);\n  }\n\n  protected override async writeBytesAt(\n    resolvedPath: string,\n    content: Uint8Array,\n    options: Required<WriteFileOptions>,\n  ): Promise<void> {\n    if (!options.overwrite && this.files.has(resolvedPath)) {\n      throw new FileSystemError(\"ALREADY_EXISTS\", `Exists: ${resolvedPath}`, resolvedPath);\n    }\n    if (this.dirs.has(resolvedPath)) {\n      throw new FileSystemError(\"IS_DIRECTORY\", `Is directory: ${resolvedPath}`, resolvedPath);\n    }\n    this.files.set(resolvedPath, new Uint8Array(content));\n  }\n\n  protected override async deleteFileAt(resolvedPath: string): Promise<void> {\n    if (!this.files.delete(resolvedPath)) {\n      throw new FileSystemError(\"NOT_FOUND\", `Not found: ${resolvedPath}`, resolvedPath);\n    }\n  }\n\n  protected override async createDirectoryAt(resolvedPath: string): Promise<void> {\n    if (this.files.has(resolvedPath) || this.dirs.has(resolvedPath)) {\n      throw new FileSystemError(\"ALREADY_EXISTS\", `Exists: ${resolvedPath}`, resolvedPath);\n    }\n    this.dirs.add(resolvedPath);\n  }\n\n  protected override async removeDirectoryAt(resolvedPath: string): Promise<void> {\n    if (!this.dirs.has(resolvedPath)) {\n      throw new FileSystemError(\"NOT_FOUND\", `Not found: ${resolvedPath}`, resolvedPath);\n    }\n    if (resolvedPath === this.root) {\n      throw new FileSystemError(\n        \"PERMISSION_DENIED\",\n        `Cannot remove filesystem root: ${resolvedPath}`,\n        resolvedPath,\n      );\n    }\n    const prefix = `${resolvedPath}/`;\n    for (const file of this.files.keys()) {\n      if (file.startsWith(prefix)) {\n        throw new FileSystemError(\n          \"DIRECTORY_NOT_EMPTY\",\n          `Not empty: ${resolvedPath}`,\n          resolvedPath,\n        );\n      }\n    }\n    for (const dir of this.dirs) {\n      if (dir !== resolvedPath && dir.startsWith(prefix)) {\n        throw new FileSystemError(\n          \"DIRECTORY_NOT_EMPTY\",\n          `Not empty: ${resolvedPath}`,\n          resolvedPath,\n        );\n      }\n    }\n    this.dirs.delete(resolvedPath);\n  }\n\n  protected override async listDirectoryAt(resolvedPath: string): Promise<FileEntry[]> {\n    if (!this.dirs.has(resolvedPath)) {\n      throw new FileSystemError(\"NOT_FOUND\", `Not found: ${resolvedPath}`, resolvedPath);\n    }\n    const prefix = `${resolvedPath}/`;\n    const names = new Map<string, FileEntry>();\n\n    for (const dir of this.dirs) {\n      if (!dir.startsWith(prefix)) continue;\n      const rest = dir.slice(prefix.length);\n      if (!rest || rest.includes(\"/\")) continue;\n      names.set(rest, { name: rest, type: \"directory\" });\n    }\n    for (const [file, bytes] of this.files) {\n      if (!file.startsWith(prefix)) continue;\n      const rest = file.slice(prefix.length);\n      if (!rest || rest.includes(\"/\")) continue;\n      names.set(rest, { name: rest, type: \"file\", size: bytes.byteLength });\n    }\n    return [...names.values()].sort((a, b) => a.name.localeCompare(b.name));\n  }\n\n  protected override async statAt(resolvedPath: string): Promise<Omit<FileStat, \"path\">> {\n    if (this.dirs.has(resolvedPath)) {\n      return {\n        name: posixPath.basename(resolvedPath) || posixPath.basename(this.root),\n        type: \"directory\",\n      };\n    }\n    const bytes = this.files.get(resolvedPath);\n    if (!bytes) {\n      throw new FileSystemError(\"NOT_FOUND\", `Not found: ${resolvedPath}`, resolvedPath);\n    }\n    return {\n      name: posixPath.basename(resolvedPath),\n      type: \"file\",\n      size: bytes.byteLength,\n    };\n  }\n}\n"]}

package/lib/src/posix-path.d.ts

@@ -0,0 +1,80 @@
+/**
+ * POSIX-only path helpers for {@link BaseFileSystem} and adapters.
+ *
+ * The portable filesystem namespace always uses `/` separators. Host adapters
+ * convert with {@link toPosix} / {@link toHost} at the boundary; they must not
+ * leak `\` into namespace paths.
+ *
+ * @module
+ */
+/** Replace every `\` with `/`. */
+export declare function toPosix(input: string): string;
+/**
+ * Convert a POSIX path to a host separator style.
+ *
+ * @param separator - Host separator (`path.sep` in Node). Defaults to `/`
+ *   (no-op), which keeps shared code free of `process`.
+ */
+export declare function toHost(posixPath: string, separator?: string): string;
+/** True when {@link input} is an absolute POSIX or Windows-drive path. */
+export declare function isAbsolute(input: string): boolean;
+/**
+ * Normalize a filesystem root for storage on {@link BaseFileSystem.root}.
+ *
+ * Converts to POSIX, trims, and strips trailing slashes while preserving
+ * `/`, Windows drive roots (`C:/`), and URL-like scheme roots.
+ */
+export declare function normalizeRoot(root: string): string;
+/**
+ * Join path segments using `/`.
+ *
+ * Absolute segments (see {@link isAbsolute}) reset the result. Empty segments
+ * and `.` are skipped. Does not resolve `..`; use {@link normalize} for that.
+ */
+export declare function join(...parts: string[]): string;
+export type NormalizeResult = {
+    readonly ok: true;
+    readonly path: string;
+} | {
+    readonly ok: false;
+    readonly escape: true;
+};
+/**
+ * Normalize a filesystem-relative path into a rooted POSIX namespace path
+ * (`/a/b`). Resolves `.` and `..`. Returns `{ escape: true }` when `..`
+ * would leave the root.
+ *
+ * Backslashes are converted via {@link toPosix}. Null bytes are rejected by
+ * callers that wrap this in a {@link FileSystemError}.
+ */
+export declare function normalize(inputPath: string): NormalizeResult;
+/** Parent directory of a POSIX path (`/` for the root). */
+export declare function dirname(inputPath: string): string;
+/** Final segment of a POSIX path. */
+export declare function basename(inputPath: string): string;
+/**
+ * Relative POSIX path from {@link from} to {@link to}, both absolute.
+ * Returns undefined when {@link to} is outside {@link from}.
+ */
+export declare function relative(from: string, to: string): string | undefined;
+/** Whether {@link candidate} is {@link root} or a descendant (POSIX lexical). */
+export declare function isWithinRoot(root: string, candidate: string): boolean;
+/** True when {@link input} is `~` or a path under `~/` (or `~\`). */
+export declare function isHomeRelativePath(input: string): boolean;
+/**
+ * Expand a `~` / `~/...` input against {@link home}.
+ *
+ * Shared by every adapter that has a notion of "home", since each one differs
+ * only in what `home` is and how segments join: local disk passes
+ * `path.join`, Databricks passes a POSIX join under
+ * `/Workspace/Users/<user>`. Non-home inputs come back trimmed and unchanged.
+ *
+ * @param joinWith - Join the expanded remainder onto {@link home}. Defaults to
+ *   POSIX {@link join}.
+ */
+export declare function expandHome(input: string, home: string, joinWith?: (home: string, rest: string) => string): string;
+/**
+ * Drop a leading `~` and any leading separators, so an absolute-looking or
+ * home-relative input can be joined UNDER a base rather than replacing it.
+ */
+export declare function toRelativeSegment(input: string): string;

package/lib/src/posix-path.js

@@ -0,0 +1,208 @@
+/**
+ * POSIX-only path helpers for {@link BaseFileSystem} and adapters.
+ *
+ * The portable filesystem namespace always uses `/` separators. Host adapters
+ * convert with {@link toPosix} / {@link toHost} at the boundary; they must not
+ * leak `\` into namespace paths.
+ *
+ * @module
+ */
+/** Replace every `\` with `/`. */
+export function toPosix(input) {
+    return input.replace(/\\/g, "/");
+}
+/**
+ * Convert a POSIX path to a host separator style.
+ *
+ * @param separator - Host separator (`path.sep` in Node). Defaults to `/`
+ *   (no-op), which keeps shared code free of `process`.
+ */
+export function toHost(posixPath, separator = "/") {
+    if (separator === "/" || separator.length === 0)
+        return posixPath;
+    // Preserve scheme roots such as `s3://bucket/key`.
+    const scheme = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.exec(posixPath);
+    if (scheme) {
+        const prefix = scheme[0];
+        return prefix + posixPath.slice(prefix.length).replace(/\//g, separator);
+    }
+    return posixPath.replace(/\//g, separator);
+}
+/** True when {@link input} is an absolute POSIX or Windows-drive path. */
+export function isAbsolute(input) {
+    const p = toPosix(input);
+    if (p.startsWith("/"))
+        return true;
+    // `C:/...` drive path
+    if (/^[A-Za-z]:\//.test(p))
+        return true;
+    // `scheme://...`
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(p))
+        return true;
+    return false;
+}
+/**
+ * Normalize a filesystem root for storage on {@link BaseFileSystem.root}.
+ *
+ * Converts to POSIX, trims, and strips trailing slashes while preserving
+ * `/`, Windows drive roots (`C:/`), and URL-like scheme roots.
+ */
+export function normalizeRoot(root) {
+    const trimmed = toPosix(root.trim());
+    if (!trimmed) {
+        throw new TypeError("Filesystem root cannot be empty");
+    }
+    const scheme = /^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)(.*)$/.exec(trimmed);
+    if (scheme) {
+        const [, prefix, rest] = scheme;
+        if (!rest)
+            return trimmed; // bare `s3://`
+        return prefix + rest.replace(/\/+$/, "");
+    }
+    if (trimmed === "/")
+        return "/";
+    if (/^[A-Za-z]:\/$/.test(trimmed))
+        return trimmed;
+    if (/^[A-Za-z]:\//.test(trimmed))
+        return trimmed.replace(/\/+$/, "");
+    return trimmed.replace(/\/+$/, "");
+}
+/**
+ * Join path segments using `/`.
+ *
+ * Absolute segments (see {@link isAbsolute}) reset the result. Empty segments
+ * and `.` are skipped. Does not resolve `..`; use {@link normalize} for that.
+ */
+export function join(...parts) {
+    if (parts.length === 0)
+        return ".";
+    let result = "";
+    for (const part of parts) {
+        const segment = toPosix(part);
+        if (!segment || segment === ".")
+            continue;
+        if (isAbsolute(segment)) {
+            result = segment;
+            continue;
+        }
+        if (!result || result.endsWith("/")) {
+            result += segment.replace(/^\/+/, "");
+        }
+        else {
+            result += `/${segment.replace(/^\/+/, "")}`;
+        }
+    }
+    return result || ".";
+}
+/**
+ * Normalize a filesystem-relative path into a rooted POSIX namespace path
+ * (`/a/b`). Resolves `.` and `..`. Returns `{ escape: true }` when `..`
+ * would leave the root.
+ *
+ * Backslashes are converted via {@link toPosix}. Null bytes are rejected by
+ * callers that wrap this in a {@link FileSystemError}.
+ */
+export function normalize(inputPath) {
+    const p = toPosix(inputPath);
+    const segments = [];
+    for (const segment of p.split("/")) {
+        if (!segment || segment === ".")
+            continue;
+        if (segment === "..") {
+            if (segments.length === 0)
+                return { ok: false, escape: true };
+            segments.pop();
+            continue;
+        }
+        segments.push(segment);
+    }
+    return { ok: true, path: `/${segments.join("/")}` };
+}
+/** Parent directory of a POSIX path (`/` for the root). */
+export function dirname(inputPath) {
+    const p = toPosix(inputPath);
+    if (p === "/" || /^[A-Za-z]:\/$/.test(p))
+        return p;
+    const trimmed = p.replace(/\/+$/, "") || "/";
+    const slash = trimmed.lastIndexOf("/");
+    if (slash <= 0) {
+        if (/^[A-Za-z]:\//.test(trimmed))
+            return `${trimmed.slice(0, 2)}/`;
+        return "/";
+    }
+    if (slash === 2 && /^[A-Za-z]:\//.test(trimmed)) {
+        return trimmed.slice(0, 3); // `C:/`
+    }
+    return trimmed.slice(0, slash) || "/";
+}
+/** Final segment of a POSIX path. */
+export function basename(inputPath) {
+    const p = toPosix(inputPath).replace(/\/+$/, "");
+    if (!p || p === "/")
+        return "";
+    const slash = p.lastIndexOf("/");
+    return slash < 0 ? p : p.slice(slash + 1);
+}
+/**
+ * Relative POSIX path from {@link from} to {@link to}, both absolute.
+ * Returns undefined when {@link to} is outside {@link from}.
+ */
+export function relative(from, to) {
+    const fromNorm = normalizeRoot(from);
+    const toNorm = toPosix(to).replace(/\/+$/, "") || toPosix(to);
+    if (toNorm === fromNorm)
+        return "";
+    const prefix = fromNorm.endsWith("/") ? fromNorm : `${fromNorm}/`;
+    if (!toNorm.startsWith(prefix) && toNorm !== fromNorm) {
+        // Case-folding not applied; adapters that need it should normalize first.
+        if (fromNorm === "/") {
+            return toNorm.startsWith("/") ? toNorm.slice(1) : undefined;
+        }
+        return undefined;
+    }
+    return toNorm.slice(prefix.length);
+}
+/** Whether {@link candidate} is {@link root} or a descendant (POSIX lexical). */
+export function isWithinRoot(root, candidate) {
+    return relative(root, candidate) !== undefined;
+}
+/** True when {@link input} is `~` or a path under `~/` (or `~\`). */
+export function isHomeRelativePath(input) {
+    const trimmed = input.trim();
+    return trimmed === "~" || trimmed.startsWith("~/") || trimmed.startsWith("~\\");
+}
+/**
+ * Expand a `~` / `~/...` input against {@link home}.
+ *
+ * Shared by every adapter that has a notion of "home", since each one differs
+ * only in what `home` is and how segments join: local disk passes
+ * `path.join`, Databricks passes a POSIX join under
+ * `/Workspace/Users/<user>`. Non-home inputs come back trimmed and unchanged.
+ *
+ * @param joinWith - Join the expanded remainder onto {@link home}. Defaults to
+ *   POSIX {@link join}.
+ */
+export function expandHome(input, home, joinWith = join) {
+    const trimmed = input.trim();
+    if (!isHomeRelativePath(trimmed))
+        return trimmed;
+    if (!home.trim()) {
+        throw new TypeError("Home expansion requires a non-empty home directory");
+    }
+    const rest = stripLeadingSeparators(trimmed.slice(1));
+    return rest ? joinWith(home, rest) : home;
+}
+/**
+ * Drop a leading `~` and any leading separators, so an absolute-looking or
+ * home-relative input can be joined UNDER a base rather than replacing it.
+ */
+export function toRelativeSegment(input) {
+    const trimmed = input.trim();
+    if (!trimmed || trimmed === "." || trimmed === "./")
+        return "";
+    return stripLeadingSeparators(trimmed.replace(/^~(?=[/\\]|$)/, ""));
+}
+function stripLeadingSeparators(input) {
+    return input.replace(/^[\\/]+/, "");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"posix-path.js","sourceRoot":"","sources":["../../src/posix-path.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * POSIX-only path helpers for {@link BaseFileSystem} and adapters.\n *\n * The portable filesystem namespace always uses `/` separators. Host adapters\n * convert with {@link toPosix} / {@link toHost} at the boundary; they must not\n * leak `\\` into namespace paths.\n *\n * @module\n */\n\n/** Replace every `\\` with `/`. */\nexport function toPosix(input: string): string {\n  return input.replace(/\\\\/g, \"/\");\n}\n\n/**\n * Convert a POSIX path to a host separator style.\n *\n * @param separator - Host separator (`path.sep` in Node). Defaults to `/`\n *   (no-op), which keeps shared code free of `process`.\n */\nexport function toHost(posixPath: string, separator = \"/\"): string {\n  if (separator === \"/\" || separator.length === 0) return posixPath;\n  // Preserve scheme roots such as `s3://bucket/key`.\n  const scheme = /^[a-zA-Z][a-zA-Z0-9+.-]*:\\/\\//.exec(posixPath);\n  if (scheme) {\n    const prefix = scheme[0];\n    return prefix + posixPath.slice(prefix.length).replace(/\\//g, separator);\n  }\n  return posixPath.replace(/\\//g, separator);\n}\n\n/** True when {@link input} is an absolute POSIX or Windows-drive path. */\nexport function isAbsolute(input: string): boolean {\n  const p = toPosix(input);\n  if (p.startsWith(\"/\")) return true;\n  // `C:/...` drive path\n  if (/^[A-Za-z]:\\//.test(p)) return true;\n  // `scheme://...`\n  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:\\/\\//.test(p)) return true;\n  return false;\n}\n\n/**\n * Normalize a filesystem root for storage on {@link BaseFileSystem.root}.\n *\n * Converts to POSIX, trims, and strips trailing slashes while preserving\n * `/`, Windows drive roots (`C:/`), and URL-like scheme roots.\n */\nexport function normalizeRoot(root: string): string {\n  const trimmed = toPosix(root.trim());\n  if (!trimmed) {\n    throw new TypeError(\"Filesystem root cannot be empty\");\n  }\n\n  const scheme = /^([a-zA-Z][a-zA-Z0-9+.-]*:\\/\\/)(.*)$/.exec(trimmed);\n  if (scheme) {\n    const [, prefix, rest] = scheme;\n    if (!rest) return trimmed; // bare `s3://`\n    return prefix + rest.replace(/\\/+$/, \"\");\n  }\n\n  if (trimmed === \"/\") return \"/\";\n  if (/^[A-Za-z]:\\/$/.test(trimmed)) return trimmed;\n  if (/^[A-Za-z]:\\//.test(trimmed)) return trimmed.replace(/\\/+$/, \"\");\n  return trimmed.replace(/\\/+$/, \"\");\n}\n\n/**\n * Join path segments using `/`.\n *\n * Absolute segments (see {@link isAbsolute}) reset the result. Empty segments\n * and `.` are skipped. Does not resolve `..`; use {@link normalize} for that.\n */\nexport function join(...parts: string[]): string {\n  if (parts.length === 0) return \".\";\n\n  let result = \"\";\n  for (const part of parts) {\n    const segment = toPosix(part);\n    if (!segment || segment === \".\") continue;\n\n    if (isAbsolute(segment)) {\n      result = segment;\n      continue;\n    }\n\n    if (!result || result.endsWith(\"/\")) {\n      result += segment.replace(/^\\/+/, \"\");\n    } else {\n      result += `/${segment.replace(/^\\/+/, \"\")}`;\n    }\n  }\n\n  return result || \".\";\n}\n\nexport type NormalizeResult =\n  { readonly ok: true; readonly path: string } | { readonly ok: false; readonly escape: true };\n\n/**\n * Normalize a filesystem-relative path into a rooted POSIX namespace path\n * (`/a/b`). Resolves `.` and `..`. Returns `{ escape: true }` when `..`\n * would leave the root.\n *\n * Backslashes are converted via {@link toPosix}. Null bytes are rejected by\n * callers that wrap this in a {@link FileSystemError}.\n */\nexport function normalize(inputPath: string): NormalizeResult {\n  const p = toPosix(inputPath);\n  const segments: string[] = [];\n\n  for (const segment of p.split(\"/\")) {\n    if (!segment || segment === \".\") continue;\n    if (segment === \"..\") {\n      if (segments.length === 0) return { ok: false, escape: true };\n      segments.pop();\n      continue;\n    }\n    segments.push(segment);\n  }\n\n  return { ok: true, path: `/${segments.join(\"/\")}` };\n}\n\n/** Parent directory of a POSIX path (`/` for the root). */\nexport function dirname(inputPath: string): string {\n  const p = toPosix(inputPath);\n  if (p === \"/\" || /^[A-Za-z]:\\/$/.test(p)) return p;\n\n  const trimmed = p.replace(/\\/+$/, \"\") || \"/\";\n  const slash = trimmed.lastIndexOf(\"/\");\n  if (slash <= 0) {\n    if (/^[A-Za-z]:\\//.test(trimmed)) return `${trimmed.slice(0, 2)}/`;\n    return \"/\";\n  }\n  if (slash === 2 && /^[A-Za-z]:\\//.test(trimmed)) {\n    return trimmed.slice(0, 3); // `C:/`\n  }\n  return trimmed.slice(0, slash) || \"/\";\n}\n\n/** Final segment of a POSIX path. */\nexport function basename(inputPath: string): string {\n  const p = toPosix(inputPath).replace(/\\/+$/, \"\");\n  if (!p || p === \"/\") return \"\";\n  const slash = p.lastIndexOf(\"/\");\n  return slash < 0 ? p : p.slice(slash + 1);\n}\n\n/**\n * Relative POSIX path from {@link from} to {@link to}, both absolute.\n * Returns undefined when {@link to} is outside {@link from}.\n */\nexport function relative(from: string, to: string): string | undefined {\n  const fromNorm = normalizeRoot(from);\n  const toNorm = toPosix(to).replace(/\\/+$/, \"\") || toPosix(to);\n\n  if (toNorm === fromNorm) return \"\";\n  const prefix = fromNorm.endsWith(\"/\") ? fromNorm : `${fromNorm}/`;\n  if (!toNorm.startsWith(prefix) && toNorm !== fromNorm) {\n    // Case-folding not applied; adapters that need it should normalize first.\n    if (fromNorm === \"/\") {\n      return toNorm.startsWith(\"/\") ? toNorm.slice(1) : undefined;\n    }\n    return undefined;\n  }\n  return toNorm.slice(prefix.length);\n}\n\n/** Whether {@link candidate} is {@link root} or a descendant (POSIX lexical). */\nexport function isWithinRoot(root: string, candidate: string): boolean {\n  return relative(root, candidate) !== undefined;\n}\n\n/** True when {@link input} is `~` or a path under `~/` (or `~\\`). */\nexport function isHomeRelativePath(input: string): boolean {\n  const trimmed = input.trim();\n  return trimmed === \"~\" || trimmed.startsWith(\"~/\") || trimmed.startsWith(\"~\\\\\");\n}\n\n/**\n * Expand a `~` / `~/...` input against {@link home}.\n *\n * Shared by every adapter that has a notion of \"home\", since each one differs\n * only in what `home` is and how segments join: local disk passes\n * `path.join`, Databricks passes a POSIX join under\n * `/Workspace/Users/<user>`. Non-home inputs come back trimmed and unchanged.\n *\n * @param joinWith - Join the expanded remainder onto {@link home}. Defaults to\n *   POSIX {@link join}.\n */\nexport function expandHome(\n  input: string,\n  home: string,\n  joinWith: (home: string, rest: string) => string = join,\n): string {\n  const trimmed = input.trim();\n  if (!isHomeRelativePath(trimmed)) return trimmed;\n  if (!home.trim()) {\n    throw new TypeError(\"Home expansion requires a non-empty home directory\");\n  }\n  const rest = stripLeadingSeparators(trimmed.slice(1));\n  return rest ? joinWith(home, rest) : home;\n}\n\n/**\n * Drop a leading `~` and any leading separators, so an absolute-looking or\n * home-relative input can be joined UNDER a base rather than replacing it.\n */\nexport function toRelativeSegment(input: string): string {\n  const trimmed = input.trim();\n  if (!trimmed || trimmed === \".\" || trimmed === \"./\") return \"\";\n  return stripLeadingSeparators(trimmed.replace(/^~(?=[/\\\\]|$)/, \"\"));\n}\n\nfunction stripLeadingSeparators(input: string): string {\n  return input.replace(/^[\\\\/]+/, \"\");\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/base-fs.ts","../src/fs.ts","../src/memory-fs.ts","../src/posix-path.ts","../index.ts"],"version":"5.9.3"}