@jerryan/just-bash 3.5.0

package/dist/fs/overlay-fs/overlay-fs.d.ts

@@ -0,0 +1,360 @@
+/**
+ * OverlayFs - Copy-on-write filesystem backed by a real directory
+ *
+ * Reads come from the real filesystem, writes go to an in-memory layer.
+ * Changes don't persist to disk and can't escape the root directory.
+ *
+ * Security: Symlinks are blocked by default (allowSymlinks: false).
+ * All real-FS access goes through resolveRealPath_() / resolveRealPathParent_()
+ * gates which detect symlink traversal via path comparison and return the
+ * canonical path for I/O (closing the TOCTOU gap). New methods must use these
+ * gates — never access the real FS directly.
+ *
+ * Concurrent modification of the underlying directory is not supported.
+ * OverlayFs does not detect changes made to the underlying directory outside
+ * the overlay while an instance is live. If such changes occur, behavior is
+ * undefined and data loss is a possible outcome — including deletion of
+ * files the overlay never saw, when applying a diff() computed against a
+ * stale view. After intentional external changes (e.g. a native run
+ * between sandbox sessions), call sync() or reset() to re-baseline before
+ * continuing.
+ */
+import { type ByteString } from "../../encoding.js";
+import { type FileContent } from "../encoding.js";
+import type { CpOptions, DirentEntry, FsStat, IFileSystem, MkdirOptions, ReadFileOptions, RmOptions, WriteFileOptions } from "../interface.js";
+/** Kind of entry recorded in an {@link OverlayWrite}. */
+export type OverlayNodeType = "file" | "directory" | "symlink";
+/**
+ * A single write captured in the overlay's upper layer.
+ */
+export interface OverlayWrite {
+    /**
+     * Path relative to the overlay root, with a leading slash
+     * (e.g. `"/src/app.ts"`). Join it with the host-side root directory to
+     * materialize the change.
+     */
+    path: string;
+    /** Kind of entry written. */
+    nodeType: OverlayNodeType;
+    /**
+     * File content; the symlink target (as UTF-8 bytes) for symlinks; empty
+     * for directories and for metadata-only writes.
+     */
+    content: Uint8Array;
+    /**
+     * Unix-style permission mode to apply when materializing on the host.
+     * Advisory on Windows (maps at most to the read-only attribute).
+     */
+    mode: number;
+    /** Modification time; hosts may apply it (utimes) for fidelity. */
+    mtime: Date;
+    /**
+     * When true, only metadata changed (chmod/utimes via a metacopy shadow):
+     * apply `mode` and `mtime` and never touch file content.
+     */
+    metadataOnly?: boolean;
+}
+/**
+ * All changes recorded in an overlay relative to its lower directory:
+ * the upper-layer write set plus the deletions (whiteouts) of lower paths.
+ *
+ * Hosts embedding just-bash use this to apply sandboxed writes to the real
+ * project directory after execution (or prompt about them) — the overlay
+ * itself never modifies disk.
+ */
+export interface OverlayDiff {
+    /** Every entry created or modified under the mount point, sorted by path. */
+    writes: OverlayWrite[];
+    /**
+     * Root-relative paths deleted during execution, sorted. Whiteout nodes
+     * never nest, so each entry is a top-most deletion covering its subtree.
+     */
+    deletions: string[];
+}
+export interface OverlayFsOptions {
+    /**
+     * The root directory on the real filesystem.
+     * All paths are relative to this root and cannot escape it.
+     */
+    root: string;
+    /**
+     * The virtual mount point where the root directory appears.
+     * Defaults to "/home/user/project".
+     */
+    mountPoint?: string;
+    /**
+     * If true, all write operations will throw an error.
+     * Useful for truly read-only access to the filesystem.
+     * Defaults to false.
+     */
+    readOnly?: boolean;
+    /**
+     * Maximum file size in bytes that can be read from the real filesystem.
+     * Files larger than this will throw an EFBIG error.
+     * Defaults to 10MB (10485760).
+     */
+    maxFileReadSize?: number;
+    /**
+     * Maximum bytes retained by copy-on-write files in the memory layer.
+     * Defaults to 1 GiB. Real backing files are not counted until copied.
+     */
+    maxMemoryBytes?: number;
+    /**
+     * Whether to allow following and creating symlinks on the real filesystem.
+     * When false (default), any real-FS path traversing a symlink is rejected
+     * and symlink() throws EPERM.
+     */
+    allowSymlinks?: boolean;
+}
+export declare class OverlayFs implements IFileSystem {
+    private readonly root;
+    private readonly canonicalRoot;
+    private readonly mountPoint;
+    private readonly readOnly;
+    private readonly maxFileReadSize;
+    private readonly maxMemoryBytes;
+    private readonly allowSymlinks;
+    private readonly tree;
+    private nextMemoryIdentity;
+    private identityFor;
+    constructor(options: OverlayFsOptions);
+    /**
+     * Throws an error if the filesystem is in read-only mode.
+     */
+    private assertWritable;
+    /**
+     * Create directory entries for the mount point path
+     */
+    private createMountPointDirs;
+    /**
+     * Get the mount point for this overlay
+     */
+    getMountPoint(): string;
+    /**
+     * Return all changes recorded in this overlay since construction (or the
+     * last {@link reset}): every write captured in the upper layer and every
+     * deletion of a lower-layer path.
+     *
+     * Paths are reported relative to the overlay root with a leading slash
+     * (e.g. `"/README.md"`), ready to join with the host-side root directory.
+     * The mount root itself is never reported, and writes outside the mount
+     * point (e.g. `/tmp` scratch files) are excluded: they have no disk
+     * counterpart to apply against.
+     *
+     * Semantics worth relying on:
+     * - **Modify** — an internal copy-up shadows the disk file; the diff
+     *   shows one write with the new content.
+     * - **Metadata-only change (chmod/utimes)** — one write with
+     *   `metadataOnly: true` and empty content; apply mode/mtime only.
+     * - **Create** — one write, including parent directories created on
+     *   demand.
+     * - **Delete then recreate** — reported as a write, not a deletion.
+     * - **`rm -rf dir`** — one deletion for `dir`, not one per child
+     *   (whiteouts never nest, so every reported deletion is top-most).
+     * - **Create then delete (never on disk)** — appears in neither list.
+     *
+     * Pure tree walk plus a synchronous existence check per whiteout and
+     * metacopy node. See the class-level policy on concurrent modification
+     * of the underlying directory.
+     */
+    diff(): OverlayDiff;
+    /**
+     * Reconcile the overlay with current disk state: drop every upper-layer
+     * shadow that now matches the lower directory, and clear whiteouts whose
+     * disk paths no longer exist. Entries that still differ remain pending
+     * and keep appearing in {@link diff}.
+     *
+     * After the host applies writes (or a native run rewrites files),
+     * `sync()` leaves the overlay holding "exactly the differences from disk
+     * right now": applied writes and deletions disappear, failed or
+     * conflicting ones stay visible — no per-path bookkeeping needed.
+     * Matching rules: content nodes compare bytes; metacopy nodes compare
+     * mtime everywhere and mode on POSIX (mode is advisory on Windows);
+     * directories match on existence and drop only once every child was
+     * dropped (post-order guarantees children reconcile first).
+     */
+    sync(): Promise<void>;
+    /**
+     * Discard all pending state: clear the upper layer so the overlay
+     * re-baselines on current disk state (trust-disk switch after native
+     * runs). Unlike {@link sync}, which keeps entries that genuinely differ
+     * from disk, `reset()` deliberately forgets them.
+     */
+    reset(): void;
+    /**
+     * Drop pending upper-layer state at the given paths (root-relative with
+     * a leading slash, exactly as {@link diff} emits them). Pure tree
+     * operation — no disk I/O, no match verification: the caller asserts
+     * these entries are done with, for whatever reason (applied to disk,
+     * rejected, superseded); the overlay does not care which.
+     *
+     * Per path: file/symlink nodes detach; whiteouts detach (dropping a
+     * pending deletion resurrects the lower-layer view of the path);
+     * directory nodes detach only when childless of pending children (same
+     * structural rule as {@link sync}), so a listed directory with
+     * still-pending children is kept until they drain. Unknown paths are a
+     * no-op. Nested paths in one call are handled deepest-first, so
+     * children drain before their parents are evaluated.
+     *
+     * {@link reset} is drop-everything; {@link sync} is drop-what-matches-
+     * disk. `drop()` is for callers that already know which entries are
+     * done — e.g. a host that just applied a change set.
+     */
+    drop(paths: string[]): void;
+    /**
+     * True when the disk entry at `path` matches the upper-layer shadow:
+     * byte-identical content for full file nodes, metadata for metacopy
+     * nodes (mtime everywhere, mode on POSIX), existence for directories,
+     * same target for symlinks.
+     */
+    /**
+     * lstat the lower-layer counterpart of a virtual path via parent-based
+     * canonical resolution (the path itself may not exist as a real file,
+     * e.g. an upper symlink shadow). Returns null when the path has no
+     * real-FS counterpart or the lstat fails.
+     */
+    private lstatLower;
+    private nodeMatchesDisk;
+    /**
+     * Create a virtual directory in memory (sync, for initialization)
+     */
+    mkdirSync(path: string, _options?: MkdirOptions): void;
+    /**
+     * Create a virtual file in memory (sync, for initialization)
+     */
+    writeFileSync(path: string, content: string | Uint8Array): void;
+    /**
+     * Check if a normalized virtual path is under the mount point.
+     * Returns the relative path within the mount point, or null if not under it.
+     */
+    private getRelativeToMount;
+    /**
+     * Convert a virtual path to a real filesystem path.
+     * Returns null if the path is not under the mount point or would escape the root.
+     */
+    private toRealPath;
+    /**
+     * Resolve a real-FS path to its canonical form and validate it stays
+     * within the sandbox.  Returns the canonical path for I/O, or null if
+     * the path escapes the root or traverses a symlink (when !allowSymlinks).
+     *
+     * Callers MUST use the returned canonical path for subsequent I/O to
+     * close the TOCTOU gap between validation and use.
+     */
+    private resolveRealPath_;
+    /**
+     * Resolve only the parent directory of a real-FS path, then join with
+     * the original basename.  Used by lstat/readlink/existsInOverlay where
+     * the final component may itself be a symlink we want to inspect (not
+     * follow).  Returns the canonical parent + basename for I/O, or null.
+     */
+    private resolveRealPathParent_;
+    private sanitizeError;
+    private ensureParentDirs;
+    /**
+     * List the lower-layer (real-FS) child names of a directory, for
+     * whiteout population during resurrection. Returns null when the path
+     * has no readable lower directory — lookups then degrade to individual
+     * lower-layer errors rather than leaking.
+     */
+    private lowerChildren;
+    /**
+     * Check if a path exists in the overlay (tree + real fs - whiteouts)
+     */
+    private existsInOverlay;
+    readFile(path: string, options?: ReadFileOptions | BufferEncoding): Promise<string>;
+    readFileBytes(path: string): Promise<ByteString>;
+    readFileBuffer(path: string, seen?: Set<string>): Promise<Uint8Array>;
+    /**
+     * Read a path from the lower layer (real filesystem), following lower
+     * symlinks through the virtual layer. Shared by clean-miss reads and
+     * metacopy fall-through.
+     */
+    private readLowerFileBytes;
+    writeFile(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void>;
+    /**
+     * Mode for a newly attached file shadow: the current entry's mode when
+     * overwriting an upper-layer file, the lower file's mode when shadowing
+     * a lower-layer file (POSIX O_TRUNC preserves mode), DEFAULT_FILE_MODE
+     * for genuinely new files (including recreate-after-delete).
+     *
+     * The lower-layer stat is POSIX-only: Windows modes are synthesized
+     * (0o666/0o444 from the read-only attribute, exec bits from the file
+     * extension) and nothing in the overlay enforces them, so the syscall
+     * would buy fiction.
+     */
+    private inheritedMode;
+    appendFile(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string, seen?: Set<string>): Promise<FsStat>;
+    lstat(path: string): Promise<FsStat>;
+    /**
+     * Build an FsStat for an upper-layer entry node (lstat semantics:
+     * symlinks are reported, not followed).
+     */
+    private memoryEntryStat;
+    private resolveSymlink;
+    /**
+     * Convert a real-fs symlink target to a virtual target suitable for resolveSymlink.
+     * Handles absolute real-fs paths that point within the root by converting them
+     * to virtual paths relative to the mount point.
+     */
+    private realTargetToVirtual;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    /**
+     * Core readdir implementation that returns entries with file types.
+     * Both readdir and readdirWithFileTypes use this shared implementation.
+     */
+    private readdirCore;
+    /**
+     * Follow symlinks to resolve the final directory path.
+     * Returns outsideOverlay: true if the symlink points outside the overlay or
+     * the resolved target doesn't exist (security - broken symlinks return []).
+     */
+    private resolveForReaddir;
+    readdir(path: string): Promise<string[]>;
+    readdirWithFileTypes(path: string): Promise<DirentEntry[]>;
+    rm(path: string, options?: RmOptions): Promise<void>;
+    /**
+     * Check (synchronously) whether a path exists on the real filesystem.
+     * Used to decide whether a whiteout is needed after deletion.
+     */
+    private existsOnRealFs;
+    cp(src: string, dest: string, options?: CpOptions): Promise<void>;
+    mv(src: string, dest: string): Promise<void>;
+    resolvePath(base: string, rel: string): string;
+    getAllPaths(): string[];
+    private scanRealFs;
+    /**
+     * True when the lower layer at `virtualPath` is invisible: a whiteout at
+     * or above the path, or a non-directory shadow in the way. Missing paths
+     * (clean fall-through) return false.
+     */
+    private lowerHidden;
+    /** The upper-layer entry at `virtualPath`, or undefined. */
+    private entryAt;
+    chmod(path: string, mode: number): Promise<void>;
+    /**
+     * Attach a metadata-only shadow for a lower-layer path: metadata moves
+     * to the upper layer, data stays lower (copied lazily on first content
+     * write for files). Callers pass the mode/mtime the shadow should carry
+     * (the operation's argument or the lower stat, depending on which
+     * metadata the operation changes).
+     */
+    private attachMetacopyShadow;
+    symlink(target: string, linkPath: string): Promise<void>;
+    link(existingPath: string, newPath: string): Promise<void>;
+    readlink(path: string): Promise<string>;
+    /**
+     * Resolve all symlinks in a path to get the canonical physical path.
+     * This is equivalent to POSIX realpath().
+     */
+    realpath(path: string): Promise<string>;
+    /**
+     * Set access and modification times of a file
+     * @param path - The file path
+     * @param _atime - Access time (ignored, kept for API compatibility)
+     * @param mtime - Modification time
+     */
+    utimes(path: string, _atime: Date, mtime: Date): Promise<void>;
+}

package/dist/fs/overlay-fs/overlay-tree.d.ts

@@ -0,0 +1,188 @@
+/**
+ * Overlay upper-layer tree.
+ *
+ * Pure data structure backing OverlayFs's copy-on-write layer: entry nodes
+ * (file/directory/symlink) shadow lower-layer paths, whiteout nodes mark
+ * deleted lower-layer paths. The tree root is the VFS root ("/").
+ *
+ * Design notes:
+ * - No parent pointers. Every operation starts with descend(), whose
+ *   ancestry stack gives mutations all the context they need — the tree
+ *   cannot disagree with itself about where a node lives.
+ * - Whiteouts are tree nodes, so "is this path hidden?" is answered by the
+ *   descent itself ("blocked"), not by a parallel tombstone set.
+ * - Type-safe mutation: attach() refuses to replace a directory with a
+ *   file/symlink (EISDIR) or an entry with a directory (EEXIST), mirroring
+ *   what real bash reports at the syscall boundary. detach()/putWhiteout()
+ *   may remove anything (rm semantics).
+ * - Byte accounting is centralized here so retainedBytes always equals the
+ *   sum of file bytes over the tree (directories, symlinks, whiteouts: 0).
+ *
+ * All traversals are iterative — no recursion depth limits on deep trees.
+ */
+export interface OverlayFileNode {
+    type: "file";
+    content: Uint8Array;
+    /**
+     * Metacopy marker (Linux overlayfs metacopy semantics): metadata
+     * (mode/mtime) is upper-layer, data is still lower-layer. Created by
+     * chmod/utimes copy-up so metadata-only changes cost O(1) instead of a
+     * full content copy. Reads fall through to the lower file (or promote
+     * to a full node on Windows, where metadata is advisory); the first
+     * content write completes the copy-up, preserving the upper mode.
+     */
+    metacopy?: boolean;
+    /** Lower-layer file size recorded at metacopy creation (for stat). */
+    lowerSize?: number;
+    /** Append segments retained without copying the complete file per append. */
+    appendChunks?: Uint8Array[];
+    mode: number;
+    mtime: Date;
+    identity?: string;
+}
+export interface OverlayDirNode {
+    type: "directory";
+    /** Child nodes keyed by name segment, in insertion order. */
+    children: Map<string, OverlayNode>;
+    mode: number;
+    mtime: Date;
+    identity?: string;
+}
+export interface OverlaySymlinkNode {
+    type: "symlink";
+    target: string;
+    mode: number;
+    mtime: Date;
+}
+/** Leaf marker hiding a lower-layer (real-FS) path and everything under it. */
+export interface OverlayWhiteoutNode {
+    type: "whiteout";
+}
+export type OverlayEntryNode = OverlayFileNode | OverlayDirNode | OverlaySymlinkNode;
+export type OverlayNode = OverlayEntryNode | OverlayWhiteoutNode;
+/**
+ * Result of walking a path through the tree.
+ *
+ * - `found`: an entry or whiteout exists at the exact path. `stack` holds
+ *   the ancestry of directory nodes, root first, parent last (empty for "/").
+ * - `missing`: nothing shadows the path — the caller may fall through to the
+ *   lower layer. `missingAt` is the index of the first absent segment.
+ * - `blocked`: a whiteout sits at or above the path — ENOENT, with no
+ *   lower-layer fallthrough. `blockedAt` is the whiteout's segment index.
+ * - `notdir`: a file/symlink entry blocks descent below it — ENOTDIR.
+ *   `notdirAt` is the entry's segment index.
+ */
+export type DescentResult = {
+    kind: "found";
+    stack: OverlayDirNode[];
+    node: OverlayNode;
+} | {
+    kind: "missing";
+    stack: OverlayDirNode[];
+    missingAt: number;
+} | {
+    kind: "blocked";
+    stack: OverlayDirNode[];
+    blockedAt: number;
+} | {
+    kind: "notdir";
+    stack: OverlayDirNode[];
+    notdirAt: number;
+};
+/** Byte size of a file node (base content + append chunks). */
+export declare function fileNodeBytes(node: OverlayFileNode): number;
+/**
+ * Merge a file node's base content and append chunks into one buffer,
+ * compacting the node in place. Total byte accounting is unchanged (the
+ * chunk bytes move into content), so the retainedBytes invariant holds.
+ */
+export declare function coalesceFileContent(node: OverlayFileNode, virtualPath: string): Uint8Array;
+export declare class OverlayTree {
+    private readonly maxMemoryBytes;
+    private rootNode;
+    private bytes;
+    constructor(maxMemoryBytes: number);
+    /** The root directory node — the VFS root ("/"). */
+    get root(): OverlayDirNode;
+    /** Sum of file bytes retained in the tree (whiteouts and metadata: 0). */
+    get retainedBytes(): number;
+    /**
+     * Walk `path` segment by segment from the root. See DescentResult for the
+     * four outcomes and their meanings.
+     */
+    descend(path: string): DescentResult;
+    /**
+     * Ensure every segment of `path` exists as a directory, creating missing
+     * ones and resurrecting whiteouts into fresh directories
+     * (write-under-deleted-dir semantics). Returns the directory at `path`.
+     * Throws ENOTDIR when a file/symlink entry blocks the path.
+     *
+     * Resurrection preserves deletions explicitly: for each resurrected
+     * directory the `lowerChildren` callback is invoked with its VFS path,
+     * and every returned lower-layer name gets a whiteout child — the old
+     * contents stay deleted exactly where they live, at any depth, with no
+     * ancestry state in lookups. A null return (lower layer unreadable or
+     * gone) populates nothing: lookups then degrade to individual lower-layer
+     * errors rather than leaking.
+     */
+    ensureDirs(path: string, lowerChildren?: (vfsPath: string) => Iterable<string> | null): OverlayDirNode;
+    /**
+     * Replace the whiteout at `parent/name` with a fresh directory, marking
+     * each lower-layer child with a whiteout so recreating the directory does
+     * not bring its deleted contents back.
+     */
+    private resurrectDir;
+    /**
+     * Insert or replace the entry at `path`. The parent must already exist as
+     * a directory (callers use ensureDirs first). Type rules mirror real bash
+     * at the syscall boundary:
+     * - file/symlink replacing a directory → EISDIR
+     * - directory replacing any existing node → EEXIST (directory
+     *   resurrection after deletion must go through ensureDirs, which
+     *   populates lower-layer whiteouts)
+     * - file/symlink replacing a whiteout, file, or symlink → legal
+     *   (write-over / recreate-after-delete)
+     */
+    attach(path: string, node: OverlayEntryNode): void;
+    /**
+     * Remove the entry or whiteout at `path`, releasing the byte cost of the
+     * whole dropped subtree. Returns the removed node, or undefined when the
+     * path is missing, blocked, or the root.
+     */
+    detach(path: string): OverlayNode | undefined;
+    /**
+     * Mark `path` as deleted in the lower layer: ensure the parent chain
+     * exists, then replace whatever child is there with a whiteout, releasing
+     * the dropped subtree's bytes. Idempotent. This is the rm primitive.
+     */
+    putWhiteout(path: string): void;
+    /**
+     * Append a chunk to a file node, accounting its bytes against capacity.
+     */
+    appendChunk(node: OverlayFileNode, chunk: Uint8Array): void;
+    /**
+     * Yield every node, parents before children (pre-order), starting with the
+     * root at path "/". Whiteouts are included; callers filter as needed.
+     */
+    preOrder(): Generator<{
+        path: string;
+        node: OverlayNode;
+    }>;
+    /**
+     * Yield every node, children before parents (post-order) — the order in
+     * which bottom-up drops are safe. Whiteouts are included.
+     */
+    postOrder(): Generator<{
+        path: string;
+        node: OverlayNode;
+    }>;
+    /** Discard the whole tree, resetting byte accounting. */
+    clear(): void;
+    /** Sum of file bytes over the node's subtree (0 for non-directories). */
+    private static subtreeBytes;
+    /** Descend to the parent of `segments`, which must exist as directories. */
+    private parentDirOf;
+    /** Descend one level for putWhiteout, creating/resurrecting as needed. */
+    private ensureChildDir;
+    private assertCapacity;
+}

package/dist/fs/path-utils.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Pure path utilities for virtual filesystems.
+ *
+ * No node:fs or node:path dependencies — safe for browser bundles.
+ * Real-FS-backed implementations should import from real-fs-utils.ts
+ * (which re-exports these) to keep a single import source.
+ */
+/** Maximum depth for symlink resolution loops. */
+export declare const MAX_SYMLINK_DEPTH = 40;
+/** Default directory permissions. */
+export declare const DEFAULT_DIR_MODE = 493;
+/** Default file permissions. */
+export declare const DEFAULT_FILE_MODE = 420;
+/** Default symlink permissions. */
+export declare const SYMLINK_MODE = 511;
+/**
+ * Normalize a virtual path: resolve `.` and `..`, ensure it starts with `/`,
+ * strip trailing slashes.  Pure function, no I/O.
+ */
+export declare function normalizePath(path: string): string;
+/** True when candidate is the same virtual path as parent or below it. */
+export declare function isSameOrDescendantPath(parent: string, candidate: string): boolean;
+/**
+ * Validate that a path does not contain null bytes.
+ * Null bytes in paths can be used to truncate filenames or bypass security
+ * filters.
+ */
+export declare function validatePath(path: string, operation: string): void;
+/**
+ * Get the directory name of a normalized virtual path.
+ */
+export declare function dirname(path: string): string;
+/**
+ * Resolve a relative path against a base directory.
+ * If `path` is absolute, it is normalized and returned directly.
+ */
+export declare function resolvePath(base: string, path: string): string;
+/**
+ * Join a parent path with a child name.
+ * Handles the root-path edge case (`"/" + "child"` → `"/child"`).
+ */
+export declare function joinPath(parent: string, child: string): string;
+/**
+ * Resolve a symlink target relative to the symlink's location.
+ * Absolute targets are normalized directly; relative targets are
+ * resolved from the symlink's parent directory.
+ */
+export declare function resolveSymlinkTarget(symlinkPath: string, target: string): string;

package/dist/fs/read-write-fs/index.d.ts

@@ -0,0 +1 @@
+export { ReadWriteFs, type ReadWriteFsOptions } from "./read-write-fs.js";