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

package/lib/types/node/builtin_modules/mock/vm.d.ts

@@ -0,0 +1,25 @@
+/** Compiled script (unavailable). */
+export declare const Script: typeof import('node:vm').Script;
+/** Context creation (unavailable). */
+export declare const createContext: typeof import('node:vm').createContext;
+/** In-context evaluation (unavailable). */
+export declare const runInContext: typeof import('node:vm').runInContext;
+/** New-context evaluation (unavailable). */
+export declare const runInNewContext: typeof import('node:vm').runInNewContext;
+/** This-context evaluation (unavailable). */
+export declare const runInThisContext: typeof import('node:vm').runInThisContext;
+/** Context predicate (unavailable). */
+export declare const isContext: typeof import('node:vm').isContext;
+/** CommonJS interop marker: the worker loader hands `default` to default imports (see ./builtins.ts). */
+export declare const __esModule = true;
+/** CommonJS default export: the members `require()` hands a caller of this module. */
+declare const _default: {
+    Script: typeof import("vm").Script;
+    createContext: typeof import("vm").createContext;
+    runInContext: typeof import("vm").runInContext;
+    runInNewContext: typeof import("vm").runInNewContext;
+    runInThisContext: typeof import("vm").runInThisContext;
+    isContext: typeof import("vm").isContext;
+};
+export default _default;
+//# sourceMappingURL=vm.d.ts.map

package/lib/types/node/builtin_modules/mock/worker_threads.d.ts

@@ -0,0 +1,34 @@
+/** Worker-thread construction (unavailable). */
+export declare const Worker: typeof import('node:worker_threads').Worker;
+/** The host tree runs on the worker's main thread. */
+export declare const isMainThread = true;
+/** Thread id of the worker's main thread. */
+export declare const threadId = 0;
+/** No parent port exists, which Node reports as `null` outside a worker thread. */
+export declare const parentPort: null;
+/** No thread data was handed in. */
+export declare const workerData: undefined;
+/** Channel construction (unavailable). */
+export declare const MessageChannel: typeof import('node:worker_threads').MessageChannel;
+/** Port construction (unavailable). */
+export declare const MessagePort: typeof import('node:worker_threads').MessagePort;
+/** Object transfer marking (unavailable). */
+export declare const markAsUntransferable: typeof import('node:worker_threads').markAsUntransferable;
+/** Port receiving on a message channel (unavailable). */
+export declare const receiveMessageOnPort: typeof import('node:worker_threads').receiveMessageOnPort;
+/** CommonJS interop marker: the worker loader hands `default` to default imports (see ./builtins.ts). */
+export declare const __esModule = true;
+/** CommonJS default export: the members `require()` hands a caller of this module. */
+declare const _default: {
+    Worker: typeof import("worker_threads").Worker;
+    isMainThread: true;
+    threadId: number;
+    parentPort: null;
+    workerData: undefined;
+    MessageChannel: typeof import("worker_threads").MessageChannel;
+    MessagePort: typeof import("worker_threads").MessagePort;
+    markAsUntransferable: typeof import("worker_threads").markAsUntransferable;
+    receiveMessageOnPort: typeof import("worker_threads").receiveMessageOnPort;
+};
+export default _default;
+//# sourceMappingURL=worker_threads.d.ts.map

package/lib/types/node/builtins.d.ts

@@ -0,0 +1,13 @@
+import type { StaticModuleFactory } from '../module-system/module-loader.ts';
+/**
+ * Prefixes whose every subpath resolves to one replacement module. The loader
+ * matches the longest prefix after its exact table misses, so pi-ai's
+ * `/providers/*` and `/api/*.lazy` entries need no enumeration.
+ */
+export declare const REPLACED_PREFIXES: Record<string, StaticModuleFactory>;
+/**
+ * Build the specifier → factory table the worker module loader consults first.
+ * @returns every replaced specifier, including its `node:`-prefixed alias.
+ */
+export declare function createNodeBuiltins(): Record<string, StaticModuleFactory>;
+//# sourceMappingURL=builtins.d.ts.map

package/lib/types/node/external_packages/koffi.d.ts

@@ -0,0 +1,63 @@
+/** Opaque type descriptor standing in for a koffi type handle. */
+interface KoffiType {
+    readonly __dshKoffiType: string;
+    /** Byte size under the x64 ABI; struct layout guards compare against it. */
+    readonly size: number;
+    /** Byte alignment under the x64 ABI. */
+    readonly alignment: number;
+}
+/**
+ * Pointer type descriptor.
+ * @param target - pointee type name or descriptor.
+ * @returns the descriptor token.
+ */
+declare function pointer(target: unknown): KoffiType;
+/**
+ * Struct type descriptor. The size and alignment are computed with the same
+ * padding rules koffi uses on x64, because the Windows ACL layer compares them
+ * against its own header probe at module scope.
+ * @param name - struct name, or the field record when the name is omitted.
+ * @param fields - field name → type record.
+ * @returns the descriptor token.
+ */
+declare function struct(name: unknown, fields?: Record<string, unknown>): KoffiType;
+/**
+ * Array type descriptor.
+ * @param target - element type.
+ * @param length - element count.
+ * @returns the descriptor token.
+ */
+declare function array(target: unknown, length: number): KoffiType;
+/**
+ * Opaque type descriptor.
+ * @param name - type name.
+ * @returns the descriptor token.
+ */
+declare function opaque(name?: string): KoffiType;
+/** Primitive type table; members carry their x64 sizes. */
+declare const types: Record<string, KoffiType>;
+/** The koffi face its consumers read; every call refuses. */
+declare const koffi: {
+    pointer: typeof pointer;
+    struct: typeof struct;
+    array: typeof array;
+    opaque: typeof opaque;
+    types: Record<string, KoffiType>;
+    alias: (name: string, target: unknown) => KoffiType;
+    sizeof: (target: unknown) => number;
+    alignof: (target: unknown) => number;
+    load: (...args: never[]) => never;
+    alloc: (...args: never[]) => never;
+    free: (...args: never[]) => never;
+    decode: (...args: never[]) => never;
+    encode: (...args: never[]) => never;
+    address: (...args: never[]) => never;
+    register: (...args: never[]) => never;
+    unregister: (...args: never[]) => never;
+    call: (...args: never[]) => never;
+};
+export { pointer, struct, array, opaque, types };
+/** CommonJS interop marker: the worker loader hands `default` to default imports (see ./builtins.ts). */
+export declare const __esModule = true;
+export default koffi;
+//# sourceMappingURL=koffi.d.ts.map

package/lib/types/node/external_packages/node-addon-system-flock.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Single-process worker replacement for `@deepseek-ai/node-addon-system/flock`.
+ * The JSONL backend's in-process write claim already excludes every writer,
+ * so its kernel-lock request succeeds without acquiring another resource.
+ */
+/**
+ * Grant the single-process worker's exclusive-lock request immediately.
+ * @param _fd - file descriptor (unused).
+ * @returns an already-fulfilled promise.
+ */
+export declare function tryLockExclusive(_fd: number): Promise<void>;
+/** CommonJS interop marker for the worker module loader. */
+export declare const __esModule = true;
+/** The native flock API used by the JSONL backend. */
+declare const _default: {
+    tryLockExclusive: typeof tryLockExclusive;
+};
+export default _default;
+//# sourceMappingURL=node-addon-system-flock.d.ts.map

package/lib/types/node/external_packages/node-pty.d.ts

@@ -0,0 +1,13 @@
+/** Spawn a pseudo-terminal (unavailable). */
+export declare const spawn: (...args: never[]) => never;
+/** Open a pseudo-terminal pair (unavailable). */
+export declare const open: (...args: never[]) => never;
+/** CommonJS interop marker: the worker loader hands `default` to default imports (see ./builtins.ts). */
+export declare const __esModule = true;
+/** CommonJS default export: the members `require()` hands a caller of this module. */
+declare const _default: {
+    spawn: (...args: never[]) => never;
+    open: (...args: never[]) => never;
+};
+export default _default;
+//# sourceMappingURL=node-pty.d.ts.map

package/lib/types/node/external_packages/pi-ai.d.ts

@@ -0,0 +1,51 @@
+/** Provider factory (unavailable). */
+export declare const createProvider: (...args: never[]) => never;
+/** Model-list factory (unavailable). */
+export declare const createModels: (...args: never[]) => never;
+/** Thinking-level catalog (unavailable). */
+export declare const getSupportedThinkingLevels: (...args: never[]) => never;
+/** Context-overflow predicate (unavailable). */
+export declare const isContextOverflow: (...args: never[]) => never;
+/**
+ * Installed catalog providers, read while `llm-pi-ai` activates. Each carries the
+ * api-key auth marker the adapter filters on, and no models: the provider
+ * directory therefore matches the served deployment while every request path
+ * lands on a loud symbol above.
+ * @returns one entry per builtin provider.
+ */
+export declare function builtinProviders(): unknown[];
+/**
+ * Provider route ids of the installed catalog. `llm-pi-ai` registers the whole
+ * catalog as configurable the moment it mounts and rejects an empty
+ * registration, so these are pi-ai's real ids rather than an empty list.
+ * @returns the builtin provider ids.
+ */
+export declare function getBuiltinProviders(): string[];
+/**
+ * Models of one installed catalog provider.
+ * @returns no models.
+ */
+export declare function getBuiltinModels(): unknown[];
+/** Anthropic messages API binding (unavailable). */
+export declare const anthropicMessagesApi: (...args: never[]) => never;
+/** OpenAI completions API binding (unavailable). */
+export declare const openAICompletionsApi: (...args: never[]) => never;
+/** OpenAI responses API binding (unavailable). */
+export declare const openAIResponsesApi: (...args: never[]) => never;
+/** CommonJS interop marker: the worker loader hands `default` to default imports. */
+export declare const __esModule = true;
+/** CommonJS default export: the members `require()` hands a caller of this module. */
+declare const _default: {
+    createProvider: (...args: never[]) => never;
+    createModels: (...args: never[]) => never;
+    getSupportedThinkingLevels: (...args: never[]) => never;
+    isContextOverflow: (...args: never[]) => never;
+    builtinProviders: typeof builtinProviders;
+    getBuiltinModels: typeof getBuiltinModels;
+    getBuiltinProviders: typeof getBuiltinProviders;
+    anthropicMessagesApi: (...args: never[]) => never;
+    openAICompletionsApi: (...args: never[]) => never;
+    openAIResponsesApi: (...args: never[]) => never;
+};
+export default _default;
+//# sourceMappingURL=pi-ai.d.ts.map

package/lib/types/node/external_packages/replaced-externals.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Exact package or subpath specifiers served from the worker bundle. Kept
+ * import-free for the runtime builtin table and the VFS image collector.
+ * Whole-package entries are omitted from the image; subpath entries leave
+ * their parent package available to other consumers.
+ */
+/** Package or subpath specifiers served from the worker bundle instead of the VFS. */
+export declare const REPLACED_EXTERNAL_PACKAGES: readonly string[];
+//# sourceMappingURL=replaced-externals.d.ts.map

package/lib/types/node/external_packages/ripgrep.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `@vscode/ripgrep` stub. The package's only export is the binary path, read at
+ * module scope by search plugins; the path stays a plain string so construction
+ * succeeds, and the loud failure comes from the child_process stub when something
+ * tries to run it.
+ */
+/** Path the search plugins would spawn; nothing can execute it in a browser. */
+export declare const rgPath = "/dsh/bin/rg";
+/** CommonJS interop marker: the worker loader hands `default` to default imports (see ./builtins.ts). */
+export declare const __esModule = true;
+/** CommonJS default export: the members `require()` hands a caller of this module. */
+declare const _default: {
+    rgPath: string;
+};
+export default _default;
+//# sourceMappingURL=ripgrep.d.ts.map

package/lib/types/node/external_packages/sharp.d.ts

@@ -0,0 +1,6 @@
+/** Image processing has no worker counterpart; the call refuses. */
+declare const sharp: (...args: never[]) => never;
+/** CommonJS interop marker: the worker loader hands `default` to default imports (see ./builtins.ts). */
+export declare const __esModule = true;
+export default sharp;
+//# sourceMappingURL=sharp.d.ts.map

package/lib/types/node/external_packages/ws.d.ts

@@ -0,0 +1,38 @@
+/** Client socket (unavailable; the page side uses the tunnel, not WebSocket). */
+/** CommonJS interop marker: the worker loader hands `default` to default imports (see ./builtins.ts). */
+export declare const __esModule = true;
+/** Client socket (unavailable; the page side uses the tunnel, not WebSocket). */
+export default class WebSocket {
+    /** Node's `CONNECTING` ready state, read by consumers that never connect. */
+    static readonly CONNECTING = 0;
+    /** Node's `OPEN` ready state. */
+    static readonly OPEN = 1;
+    /** Node's `CLOSING` ready state. */
+    static readonly CLOSING = 2;
+    /** Node's `CLOSED` ready state. */
+    static readonly CLOSED = 3;
+    constructor();
+}
+/** Server whose construction must succeed and whose methods are unreachable. */
+export declare class WebSocketServer {
+    /** Connected clients: always empty, since no upgrade ever completes. */
+    readonly clients: Set<never>;
+    /** Upgrade handling (unreachable: no upgrade event is ever emitted). */
+    readonly handleUpgrade: (...args: never[]) => never;
+    /** Broadcast helper (unreachable). */
+    readonly emit: (...args: never[]) => never;
+    /**
+     * Register a listener; nothing is ever emitted.
+     * @returns this server.
+     */
+    on(): this;
+    /**
+     * Close the server.
+     * @param callback - completion callback, invoked immediately.
+     */
+    close(callback?: () => void): void;
+}
+/** Alias Node consumers sometimes import. */
+export declare const Server: typeof WebSocketServer;
+export { WebSocket };
+//# sourceMappingURL=ws.d.ts.map

package/lib/types/node/globals/crypto.d.ts

@@ -0,0 +1,3 @@
+/** Install `crypto.randomUUID` when the context withholds it. */
+export declare function installCryptoGlobals(): void;
+//# sourceMappingURL=crypto.d.ts.map

package/lib/types/node/globals/process.d.ts

@@ -0,0 +1,78 @@
+/** Construction inputs for {@link installProcessGlobal}. */
+export interface ProcessShimOptions {
+    /** Virtual root reported by `cwd()`. */
+    readonly cwd: string;
+    /** Environment the tree reads; `DSH_HOME` belongs here. */
+    readonly env: Readonly<Record<string, string>>;
+    /** Argument vector reported to the tree. */
+    readonly argv?: readonly string[];
+}
+/** The members this shim publishes. */
+export interface ProcessShim {
+    readonly env: Record<string, string>;
+    readonly argv: string[];
+    readonly execArgv: string[];
+    /** Virtual host identity; spawning this path reports ENOENT because Node execution is unavailable. */
+    readonly execPath: string;
+    /** Node process identity used by dependencies for environment detection. */
+    readonly title: string;
+    /**
+     * Node 22 `process.getBuiltinModule`: the worker's module proxy for a
+     * builtin id (`fs`, `node:fs`), or undefined for anything else — it never
+     * resolves image modules.
+     * @param id - Builtin module id, with or without the `node:` prefix.
+     * @returns the proxied builtin, or undefined.
+     */
+    getBuiltinModule(id: string): unknown;
+    readonly platform: string;
+    readonly arch: string;
+    readonly pid: number;
+    readonly version: string;
+    readonly versions: Record<string, string>;
+    cwd(): string;
+    /**
+     * Signal one command started through the `node:child_process` shim. Signal
+     * `0` is the liveness probe the subprocess service polls a process tree
+     * with; a negative pid addresses the group, which here holds exactly the one
+     * command that leads it.
+     * @param pid - the target pid, negative for its group.
+     * @param signal - signal name, or `0` to probe without delivering one.
+     * @returns true once the signal is recorded.
+     * @throws Error with `code: 'ESRCH'` when no such command is running.
+     */
+    kill(pid: number, signal?: NodeJS.Signals | 0): boolean;
+    nextTick(callback: (...args: unknown[]) => void, ...args: unknown[]): void;
+    readonly stdout: {
+        write(chunk: string): boolean;
+    };
+    readonly stderr: {
+        write(chunk: string): boolean;
+    };
+    on(): ProcessShim;
+    off(): ProcessShim;
+    once(): ProcessShim;
+    prependListener(): ProcessShim;
+    prependOnceListener(): ProcessShim;
+    removeListener(): ProcessShim;
+    removeAllListeners(): ProcessShim;
+    listeners(): unknown[];
+    listenerCount(): number;
+    setMaxListeners(): ProcessShim;
+    emit(): boolean;
+    readonly hrtime: {
+        bigint(): bigint;
+    };
+    uptime(): number;
+    exit(code?: number): void;
+}
+/**
+ * Publish `globalThis.process`.
+ *
+ * `versions.node` is `0.0.0` on purpose: it makes Cordis's
+ * `ModuleLoader.fromInternal()` return undefined instead of reaching for Node
+ * internals, which is what lets the worker install its own module seam.
+ * @param options - Root, environment, and argument vector.
+ * @returns The published object, for the module proxy table.
+ */
+export declare function installProcessGlobal(options: ProcessShimOptions): ProcessShim;
+//# sourceMappingURL=process.d.ts.map

package/lib/types/node/globals/timers.d.ts

@@ -0,0 +1,10 @@
+/** Node `Timeout`/`Immediate` face the harness relies on. */
+export interface TimerHandle {
+    ref(): TimerHandle;
+    unref(): TimerHandle;
+    hasRef(): boolean;
+    [Symbol.toPrimitive](): number;
+}
+/** Replace the worker's timer globals with the Node-shaped wrappers. */
+export declare function installTimerGlobals(): void;
+//# sourceMappingURL=timers.d.ts.map

package/lib/types/node/notImplementedFail.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Structural not-implemented stubs: a replaced module must expose every symbol
+ * its importers name (a missing CommonJS symbol degrades to `undefined` at call
+ * time instead of failing at link time), and every one of those symbols must
+ * report exactly what is unavailable when it is finally called.
+ */
+/**
+ * Build a function that throws naming its module and symbol. The refusal is
+ * also written to the console before it propagates: callers routinely swallow
+ * these errors far from their cause, and the console line is what places the
+ * failure while debugging a worker session.
+ *
+ * `Face` is the Node declaration this stub stands in for, so the replaced module
+ * publishes the type its importers compile against. The value is one throwing
+ * function whatever that declaration says: a caller reaches the throw before any
+ * declared parameter, return value, or `new` result exists, so the assertion
+ * below cannot be observed as a lie. It is a function expression rather than an
+ * arrow because a stub standing in for a class must refuse under `new` too, and
+ * an arrow has no construct behavior to reach.
+ * @param module - module specifier being stubbed.
+ * @param symbol - exported symbol name.
+ * @returns the throwing stand-in, typed as the member it replaces.
+ */
+export declare function notImplementedFail<Face = (...args: never[]) => never>(module: string, symbol: string): Face;
+/**
+ * Build the refusal error and write it to the console first, for stubs that
+ * cannot be a plain throwing function (constructors, methods on structural
+ * fakes).
+ * @param module - module specifier being stubbed.
+ * @param symbol - unavailable member, named as the importer sees it.
+ * @returns the error to throw.
+ */
+export declare function notAvailableError(module: string, symbol: string): Error;
+//# sourceMappingURL=notImplementedFail.d.ts.map

package/lib/types/node/process-table.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The worker's process table. A browser worker cannot fork, so the
+ * `node:child_process` shim keeps its own table: one entry per running
+ * command, with the pid `process.kill` and the subprocess service's tree
+ * bookkeeping address it by.
+ *
+ * Kept apart from both consumers because they need it from opposite sides —
+ * the shim registers entries, the `process` global signals them.
+ * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/node/process-table
+ */
+import type { RunningProcess } from '../shell/process/host.ts';
+/** One running command, as the table tracks it. */
+export interface WorkerProcessEntry {
+    /** Identifier handed out to the host tree; unique for the worker's lifetime. */
+    readonly pid: number;
+    /** The first signal delivered, which decides how the process reports its death. */
+    signal: NodeJS.Signals | undefined;
+    /** The started command, attached once it exists; signals reach it through this. */
+    process: RunningProcess | undefined;
+}
+/**
+ * Reserve one pid before its command starts, so a handle can report it
+ * synchronously.
+ * @returns the new table entry, still without its process.
+ */
+export declare function registerProcess(): WorkerProcessEntry;
+/**
+ * Drop one entry once its command has settled.
+ * @param pid - the entry's pid.
+ */
+export declare function releaseProcess(pid: number): void;
+/**
+ * Whether a command with this pid is still running.
+ * @param pid - pid to look up; a negative value addresses the group, which here
+ * holds exactly the one process that leads it.
+ * @returns true while the entry is in the table.
+ */
+export declare function processAlive(pid: number): boolean;
+/**
+ * Deliver a signal to one running command.
+ *
+ * `SIGKILL` stops the command whatever it is doing; every other signal asks it
+ * to stop at its next command boundary. That distinction is real only for a
+ * worker-backed process — see {@link RunningProcess.destroy}.
+ * @param pid - pid or negative process-group id.
+ * @param signal - the signal name to record and deliver.
+ * @returns true when an entry received it, false when no such process exists.
+ */
+export declare function signalProcess(pid: number, signal: NodeJS.Signals): boolean;
+//# sourceMappingURL=process-table.d.ts.map

package/lib/types/polyfill/async-context/als-runtime.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Runtime the transformed modules call at every suspension point.
+ *
+ * `pause` snapshots every ambient store and hands back a token that **always
+ * fulfills** (a rejection travels inside it); `resume` restores that snapshot as
+ * the first thing the resumed frame does, then returns the value or rethrows the
+ * error, so both completion paths are causally exact. The state itself belongs to
+ * the `node:async_hooks` proxy — this module only moves it.
+ *
+ * The transform that inserts these calls lives in `transform.ts`.
+ * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/polyfill/async-context/als-runtime
+ */
+/** Snapshot of every ambient store, opaque to this module. */
+export type AlsSnapshot = unknown;
+/** Result of a suspension: a rejection travels inside it, so the token always fulfills. */
+export interface AlsToken {
+    readonly ok: boolean;
+    readonly value?: unknown;
+    readonly error?: unknown;
+    readonly snapshot: AlsSnapshot;
+}
+/** The state face the rewrite moves snapshots through; the shim owns the state itself. */
+export interface AlsCausality {
+    /** Capture every instance's current store. */
+    snapshot(): AlsSnapshot;
+    /** Restore a captured snapshot. */
+    restore(snapshot: AlsSnapshot): void;
+}
+/** Runtime the rewritten modules call; built by {@link createAlsRuntime}. */
+export interface AlsRuntime {
+    pause(value: unknown): Promise<AlsToken>;
+    resume(token: AlsToken): unknown;
+    snapshot(): AlsSnapshot;
+    afterYield(snapshot: AlsSnapshot, sent: unknown): unknown;
+    iterator(value: unknown): AsyncIterator<unknown>;
+    close(iterator: AsyncIterator<unknown>): Promise<unknown>;
+}
+/**
+ * Build the runtime the rewritten code calls.
+ * @param causality - Snapshot face from the `node:async_hooks` proxy; omitted
+ *   leaves the rewrite inert (it still hops a microtask, but moves no state).
+ * @returns Runtime object passed to every module wrapper.
+ */
+export declare function createAlsRuntime(causality?: AlsCausality): AlsRuntime;
+//# sourceMappingURL=als-runtime.d.ts.map

package/lib/types/polyfill/async-context/async-context-hooks.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Patch the platform registration points. Idempotent; call once from the worker
+ * entry before the host tree boots.
+ */
+export declare function installAsyncContextHooks(): void;
+//# sourceMappingURL=async-context-hooks.d.ts.map

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

@@ -0,0 +1,23 @@
+/**
+ * The parsed command line, as this shell names it.
+ *
+ * `@yarnpkg/parsers` re-exports only part of its grammar's type map from the
+ * package root, and its `exports` field forbids reaching the grammar module
+ * directly, so the three missing members are derived from the ones it does
+ * publish. `CommandChain` is `Command` plus an optional pipeline link, which
+ * makes it usable wherever a command node is expected.
+ * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/shell/ast
+ */
+import type { Argument, CommandChain } from '@yarnpkg/parsers';
+export type { ArgumentSegment, ArithmeticExpression, CommandChain, CommandLine, ShellLine } from '@yarnpkg/parsers';
+/** One command node: a program call, a subshell, a group, or bare assignments. */
+export type Command = CommandChain;
+/** An argument that becomes argv fields. */
+export type ValueArgument = Extract<Argument, {
+    type: 'argument';
+}>;
+/** An argument that rewires a descriptor instead of becoming argv. */
+export type RedirectArgument = Extract<Argument, {
+    type: 'redirection';
+}>;
+//# sourceMappingURL=ast.d.ts.map

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

@@ -0,0 +1,65 @@
+/**
+ * Word expansion: one parsed argument becomes the zero or more fields a
+ * program receives in its argv. Covers the segment kinds the grammar produces
+ * — literal text, variables (with `:-` / `:+` forms), command substitution,
+ * arithmetic, and globs matched against the VFS.
+ * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/shell/expand
+ */
+import type { ShellLine, ValueArgument } from './ast.ts';
+import type { ShellFileSystem, ShellState } from './types.ts';
+/**
+ * Whether one word is a glob the shell should match against the filesystem.
+ * Handed to `parseShell`, which decides between a `text` and a `glob` segment.
+ * @param word - the word exactly as it was written.
+ * @returns true when the word contains a wildcard.
+ */
+export declare function isGlobPattern(word: string): boolean;
+/**
+ * Read one variable the way `$name` does.
+ *
+ * Shell variables shadow the environment (an assignment without `export` is
+ * only visible to this shell), and the specials report what a shell without
+ * job control or positional parameters can honestly report.
+ * @param state - the shell state to read.
+ * @param name - variable name, or one of `?`, `$`, `#`, `@`, `*`, `0`.
+ * @returns the value, or undefined when the variable is unset.
+ */
+export declare function readVariable(state: ShellState, name: string): string | undefined;
+/**
+ * Expand one glob against the filesystem, one path segment at a time.
+ *
+ * Matches keep the pattern's own spelling: a relative pattern yields relative
+ * paths, so `ls *.ts` prints what the model typed.
+ * @param pattern - the glob as written.
+ * @param cwd - directory a relative pattern starts from.
+ * @param fs - the filesystem to match against.
+ * @returns sorted matches, or an empty array when nothing matches.
+ */
+export declare function expandGlob(pattern: string, cwd: string, fs: ShellFileSystem): Promise<string[]>;
+/**
+ * Everything expansion needs that the argument itself cannot supply: how to
+ * run a command substitution, and the state variables resolve against.
+ */
+export interface ExpansionContext {
+    state: ShellState;
+    /** The filesystem globs match against. */
+    fs: ShellFileSystem;
+    /**
+     * Run one nested command line and return its standard output.
+     * @param shell - the parsed line inside `$( … )`.
+     * @returns the captured output, with trailing newlines already stripped.
+     */
+    substitute(shell: ShellLine): Promise<string>;
+}
+/**
+ * Expand one argument into fields.
+ *
+ * Unquoted expansions split on whitespace the way a shell does, so
+ * `cat $FILES` with two names runs `cat` with two arguments while
+ * `cat "$FILES"` runs it with one.
+ * @param argument - the parsed argument.
+ * @param context - substitution hook and shell state.
+ * @returns the fields this argument contributes to argv.
+ */
+export declare function expandArgument(argument: ValueArgument, context: ExpansionContext): Promise<string[]>;
+//# sourceMappingURL=expand.d.ts.map