@deepseek-ai/dsh-experimental-webworker-runtime 0.1.6-alpha.1

package/lib/types/shell/fs-access.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The in-host filesystem for shell runs: {@link ShellFileSystem} straight over
+ * the mounted VFS, plus the path and diagnostic helpers every program shares.
+ *
+ * This implementation answers from memory. A command running in its own
+ * worker uses the message-backed one (`./process/child.ts`), which this one
+ * serves from the host side.
+ * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/shell/fs-access
+ */
+import type { VfsError } from '../storage/types.ts';
+import type { ShellFileSystem } from './types.ts';
+/**
+ * Resolve one shell word into an absolute VFS path.
+ * @param cwd - the shell's working directory.
+ * @param path - absolute or relative path as the command line spelled it.
+ * @returns the absolute normalized path.
+ */
+export declare function resolveIn(cwd: string, path: string): string;
+/**
+ * Restate a filesystem failure the way a shell utility reports it, so the model
+ * reads `cat: /dsh/none: No such file or directory` instead of a Node error
+ * string.
+ * @param program - the utility's name, used as the message prefix.
+ * @param path - the path the utility was working on.
+ * @param error - the failure the filesystem raised.
+ * @returns the single-line diagnostic, without a trailing newline.
+ */
+export declare function describeFailure(program: string, path: string, error: unknown): string;
+/**
+ * Build a Node-shaped filesystem error, for the conditions this layer detects
+ * itself and for the worker transport, which can carry a code but not a class.
+ * @param code - the Node error code (`ENOENT`, `EISDIR`, …).
+ * @param syscall - the operation that failed.
+ * @param path - the path it failed on.
+ * @returns the error to throw.
+ */
+export declare function filesystemError(code: string, syscall: string, path: string): VfsError;
+/**
+ * The filesystem backed by the VFS mounted in this thread.
+ * @returns the in-host {@link ShellFileSystem}.
+ */
+export declare function hostFileSystem(): ShellFileSystem;
+//# sourceMappingURL=fs-access.d.ts.map

package/lib/types/shell/interpret.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The interpreter: it walks the parsed command line and runs the command table
+ * against the VFS. Structure (`;` `&` `|` `|&` `&&` `||`, subshells, groups,
+ * redirections, prefix assignments) is honored here; what a command *does*
+ * belongs to its program in `./programs/`.
+ *
+ * Output is text, not streams: every program is a JavaScript function that
+ * returns before the next one runs, so a pipeline hands a string along instead
+ * of plumbing byte streams a browser worker has no way to schedule between.
+ * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/shell/interpret
+ */
+import type { ShellFileSystem, ShellRunOutcome } from './types.ts';
+/** Everything one `bash -c` invocation needs. */
+export interface ShellRunOptions {
+    /** Working directory the line starts in. */
+    cwd: string;
+    /** Environment the line starts with. */
+    env: Record<string, string>;
+    /** Standard input contents; absent means empty. */
+    stdin?: string | undefined;
+    /** Cancellation: an aborted line stops before its next command. */
+    signal?: AbortSignal | undefined;
+    /**
+     * The filesystem this run acts on; defaults to the VFS mounted in this
+     * thread. A run inside a process worker passes the message-backed one.
+     */
+    fs?: ShellFileSystem | undefined;
+    /**
+     * Called with each write as it happens, before the run settles. The returned
+     * outcome still carries the complete text; this only lets a caller that
+     * reports progress (a background job's incremental reads) see output while
+     * the line is still running.
+     */
+    onOutput?: ((stream: 'stdout' | 'stderr', text: string) => void) | undefined;
+}
+/**
+ * Run one shell command line to completion.
+ * @param source - the command source, exactly as `bash -c` would receive it.
+ * @param options - starting directory, environment, standard input, cancellation, filesystem, output callback.
+ * @returns the exit status and the complete standard output and standard error.
+ */
+export declare function runShellCommand(source: string, options: ShellRunOptions): Promise<ShellRunOutcome>;
+/**
+ * Run one program directly, without a command line to parse.
+ *
+ * This is the path for an argv the caller already has in pieces — a spawn that
+ * names a program instead of handing `bash` a script — so nothing re-quotes
+ * words that were never quoted in the first place.
+ * @param argv - the program name at index 0, then its arguments.
+ * @param options - starting directory, environment, standard input, cancellation, filesystem, output callback.
+ * @returns the exit status and the complete standard output and standard error.
+ */
+export declare function runShellProgram(argv: readonly string[], options: ShellRunOptions): Promise<ShellRunOutcome>;
+//# sourceMappingURL=interpret.d.ts.map

package/lib/types/shell/process/child.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The process worker's own half: a fresh worker that received a
+ * {@link ShellStartFrame} runs one command here and then closes.
+ *
+ * It mounts no VFS image, boots no Cordis tree, and loads no plugins — the
+ * only thing it shares with the host worker is the bundle it was started from.
+ * Its filesystem is the host's, reached by message.
+ * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/shell/process/child
+ */
+import type { FromProcessFrame, ShellStartFrame } from './protocol.ts';
+/** The messaging face this module needs from a worker scope. */
+export interface ProcessScope {
+    postMessage(frame: FromProcessFrame): void;
+    addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
+    close(): void;
+}
+/**
+ * Run one command as this worker's whole purpose, then close.
+ *
+ * Output is forwarded as it is written, so a caller reading a background job
+ * sees progress before the command settles.
+ * @param start - the frame that named the command, its directory, and its input.
+ * @param scope - the worker scope to message through (`self`).
+ */
+export declare function runShellProcess(start: ShellStartFrame, scope: ProcessScope): void;
+//# sourceMappingURL=child.d.ts.map

package/lib/types/shell/process/host.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Starting and supervising shell processes from the host worker.
+ *
+ * A process is a Web Worker started from this same bundle, told by its first
+ * frame to be a shell process rather than a host. That is what buys real
+ * process semantics in a browser: the command runs off the host's thread, and
+ * `terminate()` stops it even mid-loop — the one thing a cooperative in-thread
+ * interpreter can never do.
+ *
+ * Where no `Worker` constructor exists (a Node test host), the same command
+ * runs inline on this thread. Everything except preemption behaves the same,
+ * and the difference is named rather than hidden: {@link RunningProcess.destroy}
+ * can only ask an inline command to stop.
+ * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/shell/process/host
+ */
+import type { ShellFileSystem } from '../types.ts';
+import { runShellProcess } from './child.ts';
+import type { ProcessScope } from './child.ts';
+/** What the caller must supply to start one process. */
+export interface ProcessStartOptions {
+    /** Command source for `bash -c`, or undefined when `argv` names a program. */
+    script?: string | undefined;
+    /** The program and its arguments. */
+    argv: readonly string[];
+    /** Working directory the command starts in. */
+    cwd: string;
+    /** Environment the command starts with. */
+    env: Record<string, string>;
+    /** Everything on standard input. */
+    stdin: string;
+    /** Receives output as it is produced. */
+    onOutput: (stream: 'stdout' | 'stderr', text: string) => void;
+    /** Receives the settled status exactly once. */
+    onExit: (code: number) => void;
+    /** The filesystem the command acts on; defaults to the mounted VFS. */
+    fs?: ShellFileSystem | undefined;
+}
+/** A started command, from the host's side. */
+export interface RunningProcess {
+    /** Ask the command to stop at its next command boundary (the `SIGTERM` rung). */
+    interrupt(): void;
+    /**
+     * Stop the command now (the `SIGKILL` rung). A worker-backed process dies
+     * whatever it was doing; an inline one can only be asked, because nothing
+     * can preempt a synchronous loop on its own thread.
+     */
+    destroy(): void;
+}
+/**
+ * Start one command.
+ * @param options - the command, its environment, and the sinks for its output and status.
+ * @returns the handle the process table signals through.
+ */
+export declare function startProcess(options: ProcessStartOptions): RunningProcess;
+/** Re-exported for the worker entry, which decides its role from the first frame. */
+export { runShellProcess };
+export type { ProcessScope };
+//# sourceMappingURL=host.d.ts.map

package/lib/types/shell/process/landlock.d.ts

@@ -0,0 +1,33 @@
+import type { ShellFileSystem } from '../types.ts';
+import type { VirtualExecutable } from './virtual-executables.ts';
+/** Parsed invocation of the native launcher's unchanged argv grammar. */
+export type LandlockInvocation = {
+    readonly kind: 'probe';
+} | {
+    readonly kind: 'run';
+    readonly readOnly: readonly string[];
+    readonly readWrite: readonly string[];
+    readonly argv: readonly string[];
+};
+/** Launcher-owned failure; callers print its message with the `landlock-run:` prefix. */
+export declare class LandlockLauncherError extends Error {
+}
+/**
+ * Parse the native launcher's argv grammar.
+ * @param args - Arguments after the launcher executable.
+ * @returns A probe or confined-run request.
+ */
+export declare function parseLandlockArguments(args: readonly string[]): LandlockInvocation;
+/**
+ * Validate grant roots and create one process-local filesystem guard.
+ * @param base - Host-side VFS adapter all permitted calls delegate to.
+ * @param invocation - Parsed confined-run request.
+ * @param cwd - Launcher's working directory for relative grant paths.
+ * @returns A filesystem enforcing only this invocation's grants.
+ */
+export declare function landlockFileSystem(base: ShellFileSystem, invocation: Extract<LandlockInvocation, {
+    kind: 'run';
+}>, cwd: string): Promise<ShellFileSystem>;
+/** Virtual executable implementing the native launcher's CLI over VFS grants. */
+export declare const LANDLOCK_EXECUTABLE: VirtualExecutable;
+//# sourceMappingURL=landlock.d.ts.map

package/lib/types/shell/process/protocol.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The frames a shell process and its host exchange.
+ *
+ * A command runs in its own Web Worker, which owns no filesystem: the VFS
+ * stays in the host worker and every read or write is a request on this
+ * channel. Blocking the child on a reply is impossible here (that would need
+ * `SharedArrayBuffer`, which requires a cross-origin isolation this deployment
+ * cannot have), so the filesystem face is asynchronous end to end.
+ * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/shell/process/protocol
+ */
+/** The first frame a process worker receives; it also selects its role. */
+export interface ShellStartFrame {
+    t: 'shell-start';
+    /** Command source for `bash -c`, or undefined when `argv` names a program directly. */
+    script?: string | undefined;
+    /** The program and arguments, used when `script` is absent. */
+    argv: readonly string[];
+    /** Working directory the command starts in. */
+    cwd: string;
+    /** Environment the command starts with. */
+    env: Record<string, string>;
+    /** Everything on standard input. */
+    stdin: string;
+}
+/** Output produced by the command, forwarded as it is written. */
+export interface ShellOutputFrame {
+    t: 'shell-out';
+    stream: 'stdout' | 'stderr';
+    text: string;
+}
+/** The command settled; the process worker closes itself right after. */
+export interface ShellExitFrame {
+    t: 'shell-exit';
+    code: number;
+}
+/** A signal the command is asked to honor (the terminate ladder's first rung). */
+export interface ShellSignalFrame {
+    t: 'shell-signal';
+}
+/** Filesystem operations a process worker can ask its host to perform. */
+export type FilesystemOperation = 'stat' | 'list' | 'readText' | 'writeText' | 'mkdir' | 'remove' | 'rename';
+/** One filesystem call, awaiting its reply by `id`. */
+export interface FilesystemCallFrame {
+    t: 'fs-call';
+    id: number;
+    op: FilesystemOperation;
+    args: readonly unknown[];
+}
+/**
+ * One filesystem reply. A failure carries the Node error `code` because the
+ * utilities branch on it (`ENOENT` prints "No such file or directory"), and an
+ * Error instance does not survive structured cloning with its class.
+ */
+export interface FilesystemReplyFrame {
+    t: 'fs-reply';
+    id: number;
+    value?: unknown;
+    failure?: {
+        code?: string | undefined;
+        message: string;
+    };
+}
+/** Everything the host sends to a process worker. */
+export type ToProcessFrame = ShellStartFrame | ShellSignalFrame | FilesystemReplyFrame;
+/** Everything a process worker sends to its host. */
+export type FromProcessFrame = ShellOutputFrame | ShellExitFrame | FilesystemCallFrame;
+/**
+ * Whether a message is the frame that turns a fresh worker into a shell
+ * process. The host worker's entry reads this to pick its role.
+ * @param data - the raw message payload.
+ * @returns true when the payload starts a shell process.
+ */
+export declare function isShellStartFrame(data: unknown): data is ShellStartFrame;
+//# sourceMappingURL=protocol.d.ts.map

package/lib/types/shell/process/virtual-executables.d.ts

@@ -0,0 +1,49 @@
+import type { ShellFileSystem } from '../types.ts';
+/** Completed virtual executable invocation. */
+export interface VirtualExecutableExit {
+    readonly kind: 'exit';
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+/** Invocation delegated to the normal Worker command runner after preparation. */
+export interface VirtualExecutableDelegate {
+    readonly kind: 'delegate';
+    readonly argv: readonly string[];
+    readonly filesystem: ShellFileSystem;
+    readonly missingExecutable: VirtualExecutableExit;
+}
+/** Result of preparing an asynchronous virtual executable invocation. */
+export type VirtualExecutablePreparation = VirtualExecutableExit | VirtualExecutableDelegate;
+/** Result available to the synchronous child-process face. */
+export type VirtualExecutableSyncResult = VirtualExecutableExit | {
+    readonly kind: 'asynchronous';
+};
+/** One executable implemented by the Worker instead of an operating-system binary. */
+export interface VirtualExecutable {
+    /** Platform executable name, independent of package-manager installation path. */
+    readonly name: string;
+    /**
+     * Prepare an invocation or complete it without entering the command runner.
+     * @param args - Arguments after the executable path.
+     * @param context - Working directory and ambient Worker filesystem.
+     * @returns The completed result or delegated command and filesystem.
+     */
+    prepare(args: readonly string[], context: {
+        readonly cwd: string;
+        readonly filesystem: ShellFileSystem;
+    }): Promise<VirtualExecutablePreparation>;
+    /**
+     * Handle the subset that can complete synchronously.
+     * @param args - Arguments after the executable path.
+     * @returns A completed result or the asynchronous marker.
+     */
+    runSync(args: readonly string[]): VirtualExecutableSyncResult;
+}
+/**
+ * Resolve a Worker platform executable by logical name.
+ * @param path - Bare name or executable path passed to `spawn`.
+ * @returns Its implementation, or undefined for the normal command table.
+ */
+export declare function virtualExecutable(path: string): VirtualExecutable | undefined;
+//# sourceMappingURL=virtual-executables.d.ts.map

package/lib/types/shell/programs/builtins.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shell builtins: the programs that read or change the shell's own state
+ * (directory, environment, exit status) rather than the filesystem.
+ * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/shell/programs/builtins
+ */
+import type { ShellProgram } from '../types.ts';
+/** The state builtins, keyed by the name a command line uses. */
+export declare const BUILTIN_PROGRAMS: Readonly<Record<string, ShellProgram>>;
+//# sourceMappingURL=builtins.d.ts.map

package/lib/types/shell/programs/files.d.ts

@@ -0,0 +1,11 @@
+/**
+ * File and directory utilities of the command table, all of them over the
+ * shell's filesystem. Listings print one entry per line: nothing here is ever
+ * a terminal, so the column layout a real `ls` picks for a tty would only be
+ * noise in a tool result.
+ * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/shell/programs/files
+ */
+import type { ShellProgram } from '../types.ts';
+/** The file utilities, keyed by the name a command line uses. */
+export declare const FILE_PROGRAMS: Readonly<Record<string, ShellProgram>>;
+//# sourceMappingURL=files.d.ts.map

package/lib/types/shell/programs/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The command table: every program name this shell can run. A browser worker
+ * spawns no processes, so this table IS the machine's `/bin` — a name that is
+ * not here reports `command not found`, exactly as a real shell would for a
+ * binary that is not installed.
+ * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/shell/programs
+ */
+import type { ShellProgram } from '../types.ts';
+/**
+ * The standard command table, built once and shared by every command line.
+ * @returns the program table, keyed by command name.
+ */
+export declare function standardPrograms(): ReadonlyMap<string, ShellProgram>;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/shell/programs/options.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Argument splitting shared by the command table: short flags (bundled or
+ * separate), long flags, `--`, and the operands that follow.
+ * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/shell/programs/options
+ */
+/** One parsed argv: which flags were given, and what is left to act on. */
+export interface ParsedOptions {
+    /** Every short letter and long name seen, without their dashes. */
+    readonly flags: ReadonlySet<string>;
+    /** Values of flags that take one (`-n 5` and `--name=x` both land here). */
+    readonly values: ReadonlyMap<string, string>;
+    /** Everything that is not a flag, in order. */
+    readonly operands: readonly string[];
+}
+/**
+ * Split one program's arguments.
+ *
+ * A short letter listed in `valued` consumes the rest of its token (`-n5`) or
+ * the next argument (`-n 5`); every other letter is a plain flag, so `-rn`
+ * sets both `r` and `n`.
+ * @param argv - the program's argv, including its name at index 0.
+ * @param valued - short letters that take a value.
+ * @returns the flags, their values, and the operands.
+ */
+export declare function parseOptions(argv: readonly string[], valued?: ReadonlySet<string>): ParsedOptions;
+/**
+ * Read a numeric flag value.
+ * @param options - the parsed options.
+ * @param flag - the short letter to read.
+ * @param fallback - value to use when the flag is absent or unparsable.
+ * @returns the number the caller should use.
+ */
+export declare function numberOption(options: ParsedOptions, flag: string, fallback: number): number;
+/**
+ * Split text into lines for the line-oriented utilities.
+ * @param text - the text to split.
+ * @returns its lines, without the trailing empty line a final newline creates.
+ */
+export declare function toLines(text: string): string[];
+//# sourceMappingURL=options.d.ts.map

package/lib/types/shell/programs/text.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Text utilities of the command table. Each one reads its operands as files
+ * and falls back to standard input, the way its POSIX counterpart does.
+ * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/shell/programs/text
+ */
+import type { ShellProgram } from '../types.ts';
+/** The text utilities, keyed by the name a command line uses. */
+export declare const TEXT_PROGRAMS: Readonly<Record<string, ShellProgram>>;
+//# sourceMappingURL=text.d.ts.map

package/lib/types/shell/types.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Types of the in-worker shell: the state one command line mutates, the byte
+ * face a program reads and writes, and the program signature the command table
+ * stores. A browser worker has no processes, so a "program" is a JavaScript
+ * function over the VFS and the state below is the whole machine.
+ * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/shell/types
+ */
+/**
+ * Mutable state of one shell instance. A subshell copies it; a group and the
+ * top level share it, which is what makes `cd` visible to later commands of
+ * the same line and invisible outside `( … )`.
+ */
+export interface ShellState {
+    /** Absolute working directory every relative path resolves against. */
+    cwd: string;
+    /** Exported variables — the environment a program reads. */
+    environment: Record<string, string>;
+    /** Shell variables that were assigned but never exported. */
+    variables: Record<string, string>;
+    /** Exit status of the last completed command, read back as `$?`. */
+    lastStatus: number;
+    /** Set by `exit`; the interpreter stops the line and reports this status. */
+    exitRequested: number | undefined;
+    /**
+     * The caller's cancellation, for programs that would otherwise keep the
+     * whole line waiting after a kill. The interpreter checks it between
+     * commands; a program that waits on anything must check it too.
+     */
+    readonly signal: AbortSignal | undefined;
+}
+/**
+ * The byte face of one running program. Output is collected as text rather
+ * than streamed: every program is a JavaScript function that returns before
+ * the next one starts, so a pipeline is a string handed along, and nothing in
+ * this shell can observe a partially written stream.
+ */
+export interface ShellIo {
+    /** Everything on standard input, already complete. */
+    readonly stdin: string;
+    /** Append to standard output. Declared as a value: redirections hand it around. */
+    readonly out: (text: string) => void;
+    /** Append to standard error. Declared as a value: redirections hand it around. */
+    readonly err: (text: string) => void;
+}
+/** One directory entry, as the listing, glob, and walk programs read it. */
+export interface ShellDirent {
+    readonly name: string;
+    readonly directory: boolean;
+}
+/** What a program can learn about one path. */
+export interface ShellStats {
+    readonly directory: boolean;
+    readonly size: number;
+    readonly mtimeMs: number;
+}
+/**
+ * The filesystem a shell run acts on.
+ *
+ * Asynchronous by construction: a command that runs in its own worker reaches
+ * the VFS by message, and the browser offers no way to block on that (a
+ * synchronous face would need `SharedArrayBuffer`, which requires
+ * cross-origin isolation this deployment cannot have). The in-host
+ * implementation answers immediately from the mounted VFS.
+ */
+export interface ShellFileSystem {
+    /**
+     * Stat one path.
+     * @param path - absolute VFS path.
+     * @returns the entry's facts, or undefined when nothing is there.
+     */
+    stat(path: string): Promise<ShellStats | undefined>;
+    /**
+     * List one directory.
+     * @param path - absolute VFS path of the directory.
+     * @returns its entries, sorted by name.
+     * @throws a Node-shaped error when the path is absent or is not a directory.
+     */
+    list(path: string): Promise<ShellDirent[]>;
+    /**
+     * Read one file as UTF-8 text.
+     * @param path - absolute VFS path.
+     * @returns the file's contents.
+     * @throws a Node-shaped error when the path is absent or is a directory.
+     */
+    readText(path: string): Promise<string>;
+    /**
+     * Write text to one file.
+     * @param path - absolute VFS path; its parent must exist.
+     * @param text - the text to store.
+     * @param append - true to keep the existing contents and add after them.
+     */
+    writeText(path: string, text: string, append?: boolean): Promise<void>;
+    /**
+     * Create one directory.
+     * @param path - absolute VFS path.
+     * @param recursive - true to create missing parents and tolerate an existing directory.
+     */
+    mkdir(path: string, recursive: boolean): Promise<void>;
+    /**
+     * Remove one path.
+     * @param path - absolute VFS path.
+     * @param options - `recursive` to take a whole subtree, `force` to tolerate absence.
+     */
+    remove(path: string, options: {
+        recursive: boolean;
+        force: boolean;
+    }): Promise<void>;
+    /**
+     * Move one file or subtree.
+     * @param from - absolute source path.
+     * @param to - absolute destination path.
+     */
+    rename(from: string, to: string): Promise<void>;
+}
+/**
+ * One executable of the command table.
+ *
+ * A program reports its exit status like a POSIX process: 0 for success, and a
+ * nonzero status it also explains on {@link ShellIo.err}. Throwing is reserved
+ * for a defect in the program itself — the interpreter turns a throw into
+ * status 1 plus a diagnostic naming the program.
+ * @param argv - the program name at index 0, then its arguments, fully expanded.
+ * @param io - standard input contents and the output sinks.
+ * @param state - shell state; a program that changes it (`cd`, `export`) mutates in place.
+ * @param fs - the filesystem this run acts on.
+ * @returns the exit status.
+ */
+export type ShellProgram = (argv: readonly string[], io: ShellIo, state: ShellState, fs: ShellFileSystem) => number | Promise<number>;
+/** Outcome of one interpreted command line. */
+export interface ShellRunOutcome {
+    /** Exit status of the last command the line ran. */
+    exitCode: number;
+    /** Everything written to standard output. */
+    stdout: string;
+    /** Everything written to standard error. */
+    stderr: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/storage/active.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Process-wide slot holding the mounted filesystem. Kept apart from any
+ * backend implementation: the `node:fs` proxy depends on the slot, not on
+ * which backend the worker entry mounted.
+ * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/storage/active
+ */
+import type { Vfs } from './types.ts';
+/**
+ * Publish the filesystem the `node:fs` proxy reads.
+ * @param vfs - Filesystem mounted by the worker entry.
+ */
+export declare function setActiveVfs(vfs: Vfs): void;
+/**
+ * Read the mounted filesystem.
+ * @returns The active filesystem.
+ */
+export declare function requireActiveVfs(): Vfs;
+//# sourceMappingURL=active.d.ts.map

package/lib/types/storage/image-gzip.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The image byte envelope. The packer writes one gzip member holding the ustar
+ * archive, and the worker inflates it with the platform's own decompressor before
+ * the tar reader sees a byte — `storage/tar.ts` stays a pure ustar reader with no
+ * codec in it.
+ *
+ * Inflation runs on the fetch stream rather than on downloaded bytes: the
+ * decompressor consumes each chunk as it lands, so unpacking overlaps the
+ * download instead of following it, and the compressed copy never has to be held
+ * whole in memory beside the archive it produces.
+ *
+ * One format, no negotiation: a body that does not start a gzip member is refused
+ * by name, in the stream, before the decompressor sees it. Without that check a
+ * plain tar, a truncated download, or a proxy's HTML error page would reach
+ * `parseTar` and fail as a corrupt header field, which says nothing about what
+ * the deployment actually served.
+ * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/storage/image-gzip
+ */
+/**
+ * Inflate a packed VFS image as it arrives.
+ * @param body - the image body, straight from `fetch` or wrapped around bytes.
+ * @param source - the image URL, or how the bytes arrived; named in a refusal.
+ * @returns the ustar archive the image carries.
+ * @throws When the body does not start a gzip member, or the member is corrupt.
+ */
+export declare function inflateImageStream(body: ReadableStream<Uint8Array>, source: string): Promise<Uint8Array>;
+/**
+ * Inflate a packed VFS image held in memory.
+ *
+ * The bytes become a body so both entries run the same stream: one decompression
+ * path, one refusal, whether the image came off the network or out of a caller's
+ * buffer.
+ * @param bytes - the image bytes.
+ * @param source - how the bytes arrived; named in a refusal.
+ * @returns the ustar archive the image carries.
+ * @throws When the bytes do not start a gzip member, or the member is corrupt.
+ */
+export declare function inflateImage(bytes: Uint8Array, source: string): Promise<Uint8Array>;
+//# sourceMappingURL=image-gzip.d.ts.map