@deepseek-ai/dsh-ptc-runtime-node 0.1.6-alpha.1

package/lib/types/bindings.d.ts

@@ -0,0 +1,8 @@
+import type { PtcBindingNamespace, PtcRunRequest } from '@deepseek-ai/dsh-ptc-runtime';
+/**
+ * Reject unusable namespaces before starting a process.
+ * @param request - Host-owned binding declarations.
+ * @returns Namespaces keyed by their declared global.
+ */
+export declare function validateBindings(request: PtcRunRequest): Map<string, PtcBindingNamespace>;
+//# sourceMappingURL=bindings.d.ts.map

package/lib/types/bootstrap.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Program evaluation, output capture, and host binding proxies over the process channel.
+ * @module @deepseek-ai/dsh-ptc-runtime-node/src/bootstrap
+ */
+import type { DoneMessage, ReplyMessage, ProgramBootData, ProgramToHost } from './protocol.ts';
+/** Program messages and host replies transported by the private process channel. */
+export interface BootstrapPort {
+    postMessage(message: ProgramToHost): void;
+    on(event: 'message', listener: (message: ReplyMessage) => void): void;
+}
+/**
+ * A writable stream's `write` slot, as the bootstrap patches it (see
+ * {@link captureStreamWrites}). Method-typed so the real
+ * `process.stdout`/`process.stderr` (narrower chunk parameters) remain
+ * assignable.
+ */
+export interface PatchableStream {
+    write(chunk: unknown, ...rest: unknown[]): boolean;
+}
+/**
+ * Ordered text capture under the shared outer JSON-byte budget, delivered to
+ * a sink as each item lands (the real sink streams text over the port eagerly,
+ * so captured output survives a mid-run termination). It includes the log
+ * array syntax and string escaping in its accounting. Once exhausted it emits
+ * the fitting prefix and reports the limit once; the host turns that condition
+ * into an explicit `output-limit` run failure.
+ */
+export declare class LogBuffer {
+    private bytes;
+    private entries;
+    private truncated;
+    private readonly sink;
+    private readonly onLimit;
+    private readonly maxBytes;
+    constructor(maxBytes: number, sink: (text: string) => void, onLimit?: () => void);
+    /**
+     * Emit text to the sink, charging it against the budget (drops + marks once exhausted).
+     * @param text - the captured text to deliver.
+     */
+    push(text: string): void;
+    /** Remaining exact JSON-byte budget for the completion value or failure message. */
+    remainingOutputBytes(): number;
+}
+/** The five console methods the shim captures, in the seam's level vocabulary. */
+declare const CONSOLE_LEVELS: readonly ["log", "info", "warn", "error", "debug"];
+/**
+ * A `console` replacement whose five leveled methods render their arguments
+ * `util.inspect`-style (matching real console formatting closely enough for
+ * a model to recognize its own output) into the buffer. Only these five
+ * exist — the program gets a deliberately small console, not Node's full
+ * console API.
+ * @param logs - the buffer every rendered line is pushed into.
+ * @returns the five-method console object handed to the program.
+ */
+export declare function makeConsoleShim(logs: LogBuffer): Record<(typeof CONSOLE_LEVELS)[number], (...args: unknown[]) => void>;
+/**
+ * Redirect a stream's `write` into the log buffer (the program-visible
+ * `process.stdout`/`process.stderr` in the Node child), so raw writes land in emission order
+ * alongside console output instead of racing down a pipe. It preserves Node's optional callback
+ * contract: the callback runs asynchronously after admission, even when the log budget drops
+ * the write.
+ *
+ * @param logs - the buffer captured writes are pushed into.
+ * @param stream - the stream whose `write` slot is patched.
+ * @returns the restore function (the in-process tests un-patch; the real
+ *   child never needs to).
+ */
+export declare function captureStreamWrites(logs: LogBuffer, stream: PatchableStream): () => void;
+/**
+ * Prepare the program's completion value for the done message. Only lossless
+ * JSON crosses, and a value that does not fit the remaining combined outer
+ * budget reports `output-limit`; the host revalidates hostile traffic and
+ * remains authoritative for native pipe writes the program shim cannot observe.
+ *
+ * @param value - the program's completion value.
+ * @param remainingOutputBytes - exact bytes left after captured logs.
+ * @param maxOutputBytes - the configured cap named in an overflow diagnostic.
+ * @returns the done-message fragment: `{}` for `undefined`, else a flat wire `{ value }`.
+ */
+export declare function prepareCompletion(value: unknown, remainingOutputBytes: number, maxOutputBytes?: number): Omit<DoneMessage, 'type'>;
+/**
+ * Prepare a thrown program value without sending an unbounded stack or
+ * string across the process channel.
+ * @param error - the value thrown by the program.
+ * @param remainingOutputBytes - exact bytes left after captured logs.
+ * @param maxOutputBytes - the configured cap named in an overflow diagnostic.
+ * @returns a bounded exception or fixed output-limit fragment.
+ */
+export declare function prepareException(error: unknown, remainingOutputBytes: number, maxOutputBytes?: number): Omit<DoneMessage, 'type'>;
+/** One awaited binding call's settlement handles, keyed by call id in the pending map. */
+export interface PendingCall {
+    resolve(value: unknown): void;
+    reject(error: Error): void;
+}
+/** Constructor type for one program-visible binding rejection class. */
+export type BindingErrorConstructor = new (memberName: string, message: string) => Error;
+/**
+ * Build each declared error class once so calls and `instanceof` share constructor identity.
+ * @param data - binding namespace declarations from the boot payload.
+ * @returns constructors keyed by their owning namespace global.
+ */
+export declare function makeBindingErrorClasses(data: Pick<ProgramBootData, 'namespaces'>): Map<string, BindingErrorConstructor>;
+/**
+ * Route host replies into the pending-call map: each reply settles its call
+ * at most once, and a reply for an unknown id (stray, or a duplicate answer
+ * to an id already settled) is ignored. Shared wiring between
+ * {@link runProgram} and the tests that exercise {@link makeNamespaces}
+ * standalone.
+ * @param port - the port whose `message` events carry the replies.
+ * @param pending - the id-keyed map of unsettled binding calls.
+ */
+export declare function wireReplies(port: BootstrapPort, pending: Map<number, PendingCall>): void;
+/**
+ * Build the binding namespace objects the program sees: one null-prototype global per
+ * namespace, each declared name an own enumerable async function that bridges over the port
+ * (`__proto__`/`constructor`/`toString` are ordinary keys, never prototype collisions).
+ * Lossy arguments reject before posting; clone failures and host failure
+ * replies reject only the corresponding call.
+ *
+ * @param data - the boot payload's namespace declarations (globals + names).
+ * @param port - the port binding calls are posted to.
+ * @param pending - the id-keyed map each posted call parks its handles in.
+ * @param nextId - the shared mutable id counter (program-issued correlation ids).
+ * @param errorClasses - per-namespace constructors shared with program globals.
+ * @returns one namespace object per declaration, in declaration order.
+ */
+export declare function makeNamespaces(data: Pick<ProgramBootData, 'namespaces'>, port: BootstrapPort, pending: Map<number, PendingCall>, nextId: {
+    value: number;
+}, errorClasses?: Map<string, BindingErrorConstructor>): Record<string, unknown>[];
+/**
+ * Run one strict async-function body, allowing top-level `await` and `return`, and post exactly
+ * one terminal {@link DoneMessage}; a thrown program error becomes its `error` field.
+ * @param port - host message port or test double.
+ * @param data - the boot payload the host sent.
+ * @param streams - stdout/stderr objects captured as program logs.
+ * @returns after posting the done message.
+ */
+export declare function runProgram(port: BootstrapPort, data: ProgramBootData, streams: {
+    stdout: PatchableStream;
+    stderr: PatchableStream;
+}): Promise<void>;
+export {};
+//# sourceMappingURL=bootstrap.d.ts.map

package/lib/types/channel.d.ts

@@ -0,0 +1,32 @@
+import type { Duplex } from 'node:stream';
+/** One co-shipped process channel; the consumer owns frame validation and terminal outcomes. */
+export declare class JsonChannel {
+    private readonly stream;
+    private readonly maxBytes;
+    private readonly receive;
+    private readonly failure;
+    private readonly header;
+    private headerBytes;
+    private payload;
+    private payloadBytes;
+    private queuedBytes;
+    private closed;
+    private readonly writes;
+    constructor(stream: Duplex, maxBytes: number, receive: (message: unknown, bytes: number) => void, failure: (error: Error, kind: 'io' | 'protocol') => void);
+    private readonly onError;
+    private readonly onClose;
+    private readonly onEnd;
+    private readonly onData;
+    /**
+     * Submit a bounded frame immediately and await the stream's write receipt.
+     * @param message - JSON-only co-shipped protocol value.
+     * @returns Resolves when this frame has been written, or rejects after transport failure.
+     */
+    send(message: unknown): Promise<void>;
+    private finishWrites;
+    /** Stop reads and close the owned endpoint; pending writes reject on closure. */
+    close(): void;
+    /** Wait for accepted writes to finish or fail. */
+    drain(): Promise<void>;
+}
+//# sourceMappingURL=channel.d.ts.map

package/lib/types/environment.d.ts

@@ -0,0 +1,4 @@
+/** Startup variables required by native executables before model evaluation. */
+/** Native executable search, Windows system paths, and sandbox temporary paths retained in the OS environment. */
+export declare const STARTUP_ENVIRONMENT_NAMES: ReadonlySet<string>;
+//# sourceMappingURL=environment.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,55 @@
+import { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { PtcRuntime } from '@deepseek-ai/dsh-ptc-runtime';
+import type { PtcRunRequest, PtcRunResult, PtcRunSpec } from '@deepseek-ai/dsh-ptc-runtime';
+import type { SandboxMode } from '@deepseek-ai/dsh-sandbox';
+import type { LaunchConfig } from './launch.ts';
+/** Deployment-varying runtime bounds and launch choices. */
+export interface Config extends LaunchConfig {
+    /** Default elapsed deadline, including nested tool and approval waits. */
+    timeoutMs?: number;
+    /** Maximum numeric elapsed budget accepted by resolve. */
+    maxTimeoutMs?: number;
+    /** Combined serialized logs, completion and diagnostic byte cap. */
+    maxOutputBytes?: number;
+    /** V8 old-generation heap limit in MiB; native allocations are excluded. */
+    maxOldGenerationSizeMb?: number;
+    /** Maximum control frame, outstanding argument and queued control-output bytes. */
+    maxMessageBytes?: number;
+    /** Maximum simultaneous host binding calls accepted from a program. */
+    maxPendingCalls?: number;
+    /** Managed process termination and output-drain grace in milliseconds. */
+    graceMs?: number;
+}
+/** Node provider; direct file effects use the same sandbox service as Bash. */
+export declare class NodePtcRuntime extends PtcRuntime {
+    static inject: string[];
+    static Config: z<Config>;
+    readonly language = "typescript";
+    readonly isolation = "process";
+    get executionInstructions(): string;
+    private readonly config;
+    private readonly live;
+    private disposed;
+    constructor(ctx: Context, config: Config);
+    get sandboxMode(): SandboxMode;
+    get timeout(): {
+        defaultMs: number;
+        maxMs: number;
+    };
+    /**
+     * Resolve an execution under explicit or deployment policy.
+     * @param request - Program, bindings, optional cwd/deadline, and resolved authority.
+     * @returns Complete execution inputs with a capped numeric budget or an explicit null deadline.
+     */
+    resolve(request: PtcRunRequest): PtcRunSpec;
+    /**
+     * Run a resolved program in a fresh managed and confined Node process.
+     * @param spec - Inputs returned by resolve; missing authority is caller misuse.
+     * @returns Output and file-confinement facts after managed cleanup.
+     */
+    run(spec: PtcRunSpec): Promise<PtcRunResult>;
+    private execute;
+}
+export default NodePtcRuntime;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/json-wire.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Lossless-JSON snapshots for the dependency-free source bootstrap closure.
+ * @module @deepseek-ai/dsh-ptc-runtime-node/json-wire
+ */
+import type { PtcJsonValue } from '@deepseek-ai/dsh-ptc-runtime';
+/**
+ * Validate and detach one process-boundary value without loading another
+ * workspace package at runtime. This mirrors the session-owned canonical
+ * JSON boundary while remaining safe to import from the unbuilt bootstrap.
+ * Its iterative traversal adds no JavaScript call-stack depth limit.
+ *
+ * @param value - the candidate completion value.
+ * @returns a detached lossless-JSON snapshot, or `undefined` when invalid.
+ */
+export declare function snapshotPtcJsonValue(value: unknown): PtcJsonValue | undefined;
+interface ArrayWireToken {
+    kind: 'array';
+    length: number;
+}
+interface ObjectWireToken {
+    kind: 'object';
+    keys: string[];
+}
+type PtcJsonToken = null | boolean | number | string | ArrayWireToken | ObjectWireToken;
+/**
+ * A pre-order, bounded-depth transport for one lossless JSON value. Container
+ * markers and scalar leaves share one flat token array, so JSON serialization
+ * does not recurse through the value's application nesting.
+ */
+export type PtcJsonWire = PtcJsonToken[];
+/**
+ * Flatten one validated JSON value for the process control channel.
+ * @param value - the lossless JSON value to transport.
+ * @returns a pre-order token stream whose own nesting is bounded.
+ */
+export declare function encodePtcJsonWire(value: PtcJsonValue): PtcJsonWire;
+/**
+ * Rebuild one lossless JSON value from the flat process wire format.
+ * Malformed or incomplete traffic returns `undefined`; traversal is iterative
+ * and therefore independent of the transported value's application depth.
+ * @param input - untrusted message-port payload.
+ * @returns the detached JSON value, or `undefined` when the wire is invalid.
+ */
+export declare function decodePtcJsonWire(input: unknown): PtcJsonValue | undefined;
+export {};
+//# sourceMappingURL=json-wire.d.ts.map

package/lib/types/launch.d.ts

@@ -0,0 +1,17 @@
+import type { FileSystem } from '@deepseek-ai/dsh-fs';
+/** Deployment-owned Node executable and optional preinstalled built bootstrap. */
+export interface LaunchConfig {
+    /** Executable in the subprocess world; defaults to the current Node executable. */
+    nodeExecutable?: string;
+    /** Absolute preinstalled built bootstrap in the execution world. */
+    bootstrapPath?: string;
+}
+/**
+ * Select explicit arguments without inheriting host loader or inspector flags.
+ * @param fs - Filesystem mapping host bootstrap assets into the process world.
+ * @param config - Optional preinstalled built bootstrap.
+ * @param maxMessageBytes - Validated frame and queued-write limit.
+ * @returns Arguments following the resolved Node executable.
+ */
+export declare function bootstrapArgs(fs: FileSystem, config: LaunchConfig, maxMessageBytes: number): string[];
+//# sourceMappingURL=launch.d.ts.map

package/lib/types/output-json.d.ts

@@ -0,0 +1,26 @@
+/** JSON string-prefix accounting for the outer-output ledger. @module @deepseek-ai/dsh-ptc-runtime-node/output-json */
+import type { PtcJsonValue } from '@deepseek-ai/dsh-ptc-runtime';
+/**
+ * Measure one JSON string without materializing its complete escaped form.
+ * @param text - the candidate string.
+ * @param maxBytes - largest serialized size the caller can admit.
+ * @returns Exact serialized bytes, or `undefined` as soon as the cap is crossed.
+ */
+export declare function jsonStringBytesUpTo(text: string, maxBytes: number): number | undefined;
+/**
+ * Measure one lossless JSON value without allocating its serialized form.
+ * @param value - already validated lossless JSON.
+ * @param maxBytes - largest serialized size the caller can admit.
+ * @returns Exact serialized bytes, or `undefined` as soon as the cap is crossed.
+ */
+export declare function jsonValueBytesUpTo(value: PtcJsonValue, maxBytes: number): number | undefined;
+/**
+ * Return the longest code-point-aligned prefix whose JSON string encoding,
+ * including its surrounding quotes, fits `maxBytes`.
+ *
+ * @param text - the candidate string.
+ * @param maxBytes - serialized JSON-string bytes available.
+ * @returns the fitting prefix, or an empty string when even useful content cannot fit.
+ */
+export declare function truncateJsonStringBytes(text: string, maxBytes: number): string;
+//# sourceMappingURL=output-json.d.ts.map

package/lib/types/output-ledger.d.ts

@@ -0,0 +1,18 @@
+/** Combined byte accounting for retained program output. */
+import type { PtcJsonValue, PtcRunFailure, PtcRunResult } from '@deepseek-ai/dsh-ptc-runtime';
+/** One run's combined outer-output ledger; binding values never enter it. */
+export declare class OutputLedger {
+    private readonly maxBytes;
+    private bytes;
+    private entries;
+    constructor(maxBytes: number);
+    /** Admit one exact log entry, or report that the hard cap was crossed. */
+    admit(text: string, sink: string[]): boolean;
+    /** Finalize a successful absent-or-JSON completion against the combined cap. */
+    success(logs: string[], value?: PtcJsonValue): PtcRunResult;
+    /** Finalize a failure diagnostic, with output-limit taking precedence when combined bytes exceed the cap. */
+    failure(logs: string[], error: PtcRunFailure): PtcRunResult;
+    /** Build the explicit output-limit failure while retaining a fitting prefix of the final log. */
+    limit(logs: string[]): PtcRunResult;
+}
+//# sourceMappingURL=output-ledger.d.ts.map

package/lib/types/output-stream.d.ts

@@ -0,0 +1,10 @@
+/** Bounded drainage for raw process output after managed execution ends. */
+import type { Readable } from 'node:stream';
+/**
+ * Wait for queued bytes without letting an inherited descriptor retain a run forever.
+ * @param stream - Caller-owned raw process output, when provided.
+ * @param graceMs - Maximum wait after managed process termination.
+ * @returns Whether the complete stream ended without a transport error.
+ */
+export declare function drainOutput(stream: Readable | undefined, graceMs: number): Promise<boolean>;
+//# sourceMappingURL=output-stream.d.ts.map

package/lib/types/process-entry.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=process-entry.d.ts.map

package/lib/types/process.d.ts

@@ -0,0 +1,19 @@
+/** Node child execution over an inherited control channel; no Harness services run here. */
+import type { Duplex } from 'node:stream';
+import type { PatchableStream } from './bootstrap.ts';
+/** Process-owned environment and output streams consumed by the child bootstrap. */
+export interface ProgramProcess {
+    env: NodeJS.ProcessEnv;
+    stdout: PatchableStream;
+    stderr: PatchableStream;
+    exitCode: string | number | null | undefined;
+}
+/**
+ * Run one host-supplied program after the control handshake.
+ * @param stream - Inherited, already-adopted control endpoint.
+ * @param maxMessageBytes - Host-validated maximum frame and queued-write bytes.
+ * @param processState - Environment, output streams and exit status of this Node child.
+ * @returns After control output flushes and host shutdown is observed, or transport failure closes the channel.
+ */
+export declare function runNodeMain(stream: Duplex, maxMessageBytes: number, processState: ProgramProcess): Promise<void>;
+//# sourceMappingURL=process.d.ts.map

package/lib/types/protocol.d.ts

@@ -0,0 +1,75 @@
+/**
+ * JSON message vocabulary carried by the bounded process channel. The host validates every
+ * message because model code can write directly to the inherited descriptor.
+ * @module @deepseek-ai/dsh-ptc-runtime-node/src/protocol
+ */
+import type { PtcJsonWire } from './json-wire.ts';
+/** What the host hands the program at spawn, after the readiness handshake. */
+export interface ProgramBootData {
+    /** The type-stripped (plain JS) program body. */
+    code: string;
+    /** Binding namespaces to materialize; functions themselves stay host-side. */
+    namespaces: {
+        global: string;
+        names: string[];
+        errorClass?: {
+            name: string;
+            memberNameProperty: string;
+        };
+    }[];
+    /** Hard cap for the combined serialized outer logs plus completion value or failure diagnostic. */
+    maxOutputBytes: number;
+}
+/** Program → host: one bridged binding call. */
+interface CallMessage {
+    type: 'call';
+    /** Program-issued correlation id; the host answers each id at most once and ignores duplicates. */
+    id: number;
+    /** The namespace global the call targets. */
+    global: string;
+    /** The function name within the namespace. */
+    name: string;
+    /** The single argument as a flat lossless-JSON wire value. */
+    args: PtcJsonWire;
+}
+/** Program → host: captured text, streamed eagerly so output survives a mid-run termination (timeout, abort, OOM). */
+interface LogMessage {
+    type: 'log';
+    text: string;
+}
+/** Program → host: program-side capture or completion measurement exceeded the outer cap. */
+interface OutputLimitMessage {
+    type: 'output-limit';
+}
+/**
+ * Program → host: the program settled. `error` carries a program exception,
+ * invalid completion, or output overflow (budgets, aborts, and substrate death
+ * are observed host-side). `value` is present only on a clean completion that
+ * produced one, as a flat wire value already lossless and admitted against
+ * the remaining combined output cap. Logs are NOT carried here — they streamed
+ * eagerly as {@link LogMessage}s.
+ */
+export interface DoneMessage {
+    type: 'done';
+    value?: PtcJsonWire;
+    error?: {
+        kind: 'exception' | 'invalid-output' | 'output-limit';
+        message: string;
+    };
+}
+/** Every message the program sends. */
+export type ProgramToHost = CallMessage | LogMessage | OutputLimitMessage | DoneMessage;
+/** Host → program: the answer to one {@link CallMessage}. */
+export type ReplyMessage = {
+    type: 'reply';
+    id: number;
+    ok: true;
+    value: PtcJsonWire;
+} | {
+    type: 'reply';
+    id: number;
+    ok: false;
+    message: string;
+};
+export {};
+//# sourceMappingURL=protocol.d.ts.map

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@deepseek-ai/dsh-ptc-runtime-node",
+  "description": "Sandboxed Node process implementation of the DeepSeek Harness PTC execution capability",
+  "version": "0.1.6-alpha.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/ptc-runtime/ptc-runtime-node"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json",
+    "./process": {
+      "types": "./lib/types/process-entry.d.ts",
+      "default": "./lib/process.js"
+    }
+  },
+  "files": [
+    "lib/index.js",
+    "lib/process.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-ptc-runtime": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-session": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-timeout": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-fs": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-subprocess": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-sandbox-policy": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-sandbox": "^0.1.6-alpha.1"
+  },
+  "dependencies": {
+    "@deepseek-ai/dsh-util-values": "^0.1.6-alpha.1",
+    "@deepseek-ai/schemastery": "^3.18.2"
+  },
+  "devDependencies": {
+    "@deepseek-ai/dsh-ptc-runtime": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-session": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-timeout": "^0.1.6-alpha.1",
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-fs": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-subprocess": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-sandbox": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-sandbox-policy": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-fs-local": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-subprocess-local": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-session-projection": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-sandbox-local": "^0.1.6-alpha.1"
+  }
+}