jeopi-cli 16.2.13 → 16.2.14

package/dist/types/eval/backend.d.ts

@@ -1,60 +0,0 @@
-import type { ToolSession } from "../tools";
-import type { EvalDisplayOutput, EvalLanguage, EvalStatusEvent } from "./types";
-/** Per-cell execute() options. */
-export interface ExecutorBackendExecOptions {
-    cwd: string;
-    sessionId: string;
-    sessionFile: string | undefined;
-    kernelOwnerId: string | undefined;
-    signal?: AbortSignal;
-    session: ToolSession;
-    /**
-     * Runtime-work budget in milliseconds (the cell's `timeout`). Cancellation is
-     * driven entirely by `signal`, which the eval tool arms as a watchdog that
-     * pauses on bridge timeout-control status events and fires a `TimeoutError`
-     * reason only while the Python/JS runtime owns control. Backends use this
-     * value only for timeout-annotation text and as cold-start headroom; they MUST
-     * NOT derive a competing wall-clock timer from it.
-     */
-    idleTimeoutMs: number;
-    reset: boolean;
-    onChunk: (chunk: string) => void;
-    /**
-     * Live status events (read/write/agent/…) delivered as they are emitted,
-     * before the cell finishes. The same events are also returned in
-     * `displayOutputs`; this channel exists so callers can stream long-running
-     * progress (e.g. `agent()` subagents) into the UI mid-execution.
-     */
-    onStatus?: (event: EvalStatusEvent) => void;
-}
-/** Result returned by a backend's execute(). */
-export interface ExecutorBackendResult {
-    output: string;
-    exitCode: number | undefined;
-    cancelled: boolean;
-    truncated: boolean;
-    artifactId: string | undefined;
-    totalLines: number;
-    totalBytes: number;
-    outputLines: number;
-    outputBytes: number;
-    displayOutputs: EvalDisplayOutput[];
-}
-/** Pluggable language backend for the eval tool. */
-export interface ExecutorBackend {
-    readonly id: EvalLanguage;
-    readonly label: string;
-    /** Source language identifier passed to the syntax highlighter (e.g. "python", "javascript"). */
-    readonly highlightLang: string;
-    /** Cheap availability check. Used by fallback resolution. */
-    isAvailable(session: ToolSession): Promise<boolean>;
-    /** Execute one cell. Caller invokes once per cell and aggregates results. */
-    execute(code: string, opts: ExecutorBackendExecOptions): Promise<ExecutorBackendResult>;
-}
-/**
- * Resolve the on-disk roots that the eval helpers substitute for internal-URL
- * schemes (currently `local://`). Prefers the session's own
- * {@link LocalProtocolOptions} — the exact mapping `read local://…` uses — so an
- * eval `write("local://x")` and a later `read local://x` agree on the location.
- */
-export declare function resolveEvalUrlRoots(session: ToolSession): Record<string, string>;

package/dist/types/eval/bridge-timeout.d.ts

@@ -1,27 +0,0 @@
-/**
- * Timeout suspension for in-flight host-side eval bridge calls.
- *
- * The eval watchdog caps a cell's `timeout` as a budget on the cell runtime's
- * own work. Host-side `agent()` / `parallel()` / `completion()` bridge calls hand
- * control to the outer TypeScript process, where the Python kernel or JS VM is
- * only waiting for a result. While that delegated work is in flight, the cell
- * timeout must be ignored completely; once the bridge returns and the runtime is
- * back in control, the watchdog starts a fresh timeout window.
- *
- * Bridge helpers express that handoff with synthetic pause/resume status events
- * on the existing `emitStatus → onStatus` path. Consumers MUST treat these as
- * timeout-control events only: update the watchdog and drop them from rendered
- * or persisted cell output.
- */
-import type { JsStatusEvent } from "./js/shared/types";
-/** Synthetic status op emitted when a bridge call leaves the cell runtime. */
-export declare const EVAL_TIMEOUT_PAUSE_OP = "timeout-pause";
-/** Synthetic status op emitted when a bridge call returns control to the runtime. */
-export declare const EVAL_TIMEOUT_RESUME_OP = "timeout-resume";
-/** Whether a status event is pure eval-timeout control and should not render. */
-export declare function isEvalTimeoutControlEvent(event: JsStatusEvent): boolean;
-/**
- * Run {@link operation} while suspending the eval watchdog through
- * {@link emitStatus}. A no-op wrapper when no status sink is wired.
- */
-export declare function withBridgeTimeoutPause<T>(emitStatus: ((event: JsStatusEvent) => void) | undefined, operation: () => Promise<T>): Promise<T>;

package/dist/types/eval/budget-bridge.d.ts

@@ -1,29 +0,0 @@
-/**
- * Host-side handler for the eval `budget` helper.
- *
- * Reports the active token ceiling and amount spent so kernel helpers can
- * compute remaining budget. Precedence: a `+Nk`/`+Nk!` per-turn directive (the
- * user's immediate intent) wins; otherwise an active Goal Mode budget; otherwise
- * no ceiling, with `spent` still reflecting this turn's output where available.
- */
-import type { ToolSession } from "../tools";
-import type { JsStatusEvent } from "./js/shared/types";
-/** Synthetic bridge name reserved for the `budget` helper across both runtimes. */
-export declare const EVAL_BUDGET_BRIDGE_NAME = "__budget__";
-export interface EvalBudgetBridgeOptions {
-    session: ToolSession;
-    signal?: AbortSignal;
-    emitStatus?: (event: JsStatusEvent) => void;
-}
-export interface EvalBudgetResult {
-    total: number | null;
-    spent: number;
-    /** Whether the ceiling is enforced (eval `agent()` throws past it) vs advisory. */
-    hard: boolean;
-}
-/**
- * Resolve the current token budget snapshot for an eval cell's `budget` helper.
- * The returned object is JSON-passed verbatim by the bridge transport; kernel
- * helpers read `.total`/`.spent`/`.hard` directly.
- */
-export declare function runEvalBudget(_args: unknown, options: EvalBudgetBridgeOptions): Promise<EvalBudgetResult>;

package/dist/types/eval/completion-bridge.d.ts

@@ -1,38 +0,0 @@
-/**
- * Host-side handler for the eval `completion()` helper.
- *
- * Both eval runtimes (JS worker + Python kernel) route helper→host calls
- * through {@link callSessionTool}. Reserving the synthetic tool name
- * {@link EVAL_COMPLETION_BRIDGE_NAME} lets a single host handler serve both
- * transports without registering an agent-visible tool: cell code calls
- * `completion(prompt, opts)`, the prelude forwards `{ prompt, model, system?, schema? }`
- * through the bridge, and this module performs one stateless completion.
- *
- * The call is oneshot and toolless from the model's perspective — pure text
- * in, text (or, with `schema`, a structured object) out.
- */
-import type { ToolSession } from "../tools";
-import type { JsStatusEvent } from "./js/shared/types";
-/** Synthetic bridge name reserved for the `completion()` helper across both runtimes. */
-export declare const EVAL_COMPLETION_BRIDGE_NAME = "__completion__";
-type CompletionTier = "smol" | "default" | "slow";
-export interface EvalCompletionBridgeOptions {
-    session: ToolSession;
-    signal?: AbortSignal;
-    emitStatus?: (event: JsStatusEvent) => void;
-}
-export interface EvalCompletionResult {
-    text: string;
-    details: {
-        model: string;
-        tier: CompletionTier;
-        structured: boolean;
-    };
-}
-/**
- * Run a single stateless completion on behalf of an eval cell's `completion()` call.
- * Returns a `{ text, details }` value shaped like a {@link callSessionTool}
- * result so the existing bridge transport carries it to either runtime.
- */
-export declare function runEvalCompletion(args: unknown, options: EvalCompletionBridgeOptions): Promise<EvalCompletionResult>;
-export {};

package/dist/types/eval/concurrency-bridge.d.ts

@@ -1,26 +0,0 @@
-/**
- * Host-side handler for the eval `parallel()` / `pipeline()` worker pool.
- *
- * The pool ceiling is not a kernel-side knob: it tracks the `task.maxConcurrency`
- * setting so an eval fan-out runs as wide as a `task` tool batch would. `0` means
- * unbounded — run every item at once, exactly like `task.maxConcurrency = 0`.
- */
-import type { ToolSession } from "../tools";
-import type { JsStatusEvent } from "./js/shared/types";
-/** Synthetic bridge name reserved for the parallel-pool ceiling across both runtimes. */
-export declare const EVAL_CONCURRENCY_BRIDGE_NAME = "__concurrency__";
-export interface EvalConcurrencyBridgeOptions {
-    session: ToolSession;
-    signal?: AbortSignal;
-    emitStatus?: (event: JsStatusEvent) => void;
-}
-export interface EvalConcurrencyResult {
-    /** Worker-pool ceiling; `0` means unbounded (run every item at once). */
-    limit: number;
-}
-/**
- * Resolve the worker-pool ceiling for an eval cell's `parallel()`/`pipeline()`
- * helpers from the live `task.maxConcurrency` setting. Negative/non-finite
- * values collapse to `0` (unbounded), matching the `task` tool's own handling.
- */
-export declare function runEvalConcurrency(_args: unknown, options: EvalConcurrencyBridgeOptions): EvalConcurrencyResult;

package/dist/types/eval/executor-base.d.ts

@@ -1,118 +0,0 @@
-import type { ToolSession } from "../tools";
-import type { JsStatusEvent } from "./js/shared/types";
-import type { KernelDisplayOutput } from "./py/display";
-/**
- * Constructor for a language executor's cancellation error. Each backend
- * subclasses {@link Error} and carries a `timedOut` flag distinguishing a
- * deadline expiry from a plain abort.
- */
-export type CancelledErrorClass = new (timedOut: boolean) => Error & {
-    timedOut: boolean;
-};
-/** Managed-env values a kernel patch may carry (`null` clears, `undefined` skips). */
-export type KernelEnvPatch = Record<string, string | null | undefined>;
-/**
- * Options every kernel-backed language executor shares. Per-language option
- * interfaces structurally extend this; the base executor only reads these.
- */
-export interface KernelExecutorBaseOptions {
-    cwd?: string;
-    timeoutMs?: number;
-    deadlineMs?: number;
-    idleTimeoutMs?: number;
-    onChunk?: (chunk: string) => Promise<void> | void;
-    signal?: AbortSignal;
-    onStatus?: (event: JsStatusEvent) => void;
-    emitStatus?: (event: JsStatusEvent) => void;
-    toolSession?: ToolSession;
-    bridgeSessionId?: string;
-    artifactId?: string;
-    artifactPath?: string;
-}
-/** Normalised execution result produced by {@link executeWithKernelBase}. */
-export interface KernelExecutionResult {
-    output: string;
-    exitCode: number | undefined;
-    cancelled: boolean;
-    truncated: boolean;
-    artifactId: string | undefined;
-    totalLines: number;
-    totalBytes: number;
-    outputLines: number;
-    outputBytes: number;
-    displayOutputs: KernelDisplayOutput[];
-    stdinRequested: boolean;
-}
-/** Minimal kernel surface the base executor drives, satisfied by every backend kernel. */
-export interface GenericKernel<TEnv> {
-    execute(code: string, options: {
-        cwd?: string;
-        env?: TEnv;
-        id: string;
-        signal?: AbortSignal;
-        timeoutMs?: number;
-        onChunk: (text: string) => Promise<void> | void;
-        onDisplay: (output: KernelDisplayOutput) => Promise<void> | void;
-    }): Promise<{
-        status: "ok" | "error";
-        cancelled: boolean;
-        timedOut: boolean;
-        kernelKilled?: boolean;
-        stdinRequested?: boolean;
-    }>;
-}
-export declare function getExecutionDeadlineMs(options?: {
-    deadlineMs?: number;
-    timeoutMs?: number;
-}): number | undefined;
-export declare function getRemainingTimeoutMs(deadlineMs?: number): number | undefined;
-export declare function isCancellationError(error: unknown, cancelledErrorClass: CancelledErrorClass): boolean;
-export declare function isTimedOutCancellation(error: unknown, cancelledErrorClass: CancelledErrorClass, signal?: AbortSignal): boolean;
-export declare function waitForPromiseWithCancellation<T>(promise: Promise<T>, options: {
-    signal?: AbortSignal;
-    deadlineMs?: number;
-}, cancelledErrorClass: CancelledErrorClass): Promise<T>;
-export declare function createCancelledKernelResult(output: string): KernelExecutionResult;
-export declare const MANAGED_KERNEL_ENV_KEYS: readonly ["PI_SESSION_FILE", "PI_ARTIFACTS_DIR", "PI_TOOL_BRIDGE_URL", "PI_TOOL_BRIDGE_TOKEN", "PI_TOOL_BRIDGE_SESSION", "PI_EVAL_LOCAL_ROOTS"];
-interface ManagedKernelEnvOptions {
-    sessionFile?: string;
-    artifactsDir?: string;
-    bridgeSessionId?: string;
-    bridge?: {
-        url: string;
-        token: string;
-    };
-    localRoots?: Record<string, string>;
-}
-export declare function buildManagedKernelEnvPatch(options: ManagedKernelEnvOptions): Record<string, string | null>;
-export declare function buildManagedKernelEnv(options: ManagedKernelEnvOptions): Record<string, string> | undefined;
-export declare function attachSessionOwner(session: {
-    ownerIds: Set<string>;
-    hasFallbackOwner: boolean;
-}, sessionId: string, ownerId: string | undefined): void;
-export interface ExecuteWithKernelBaseParams<TOptions extends KernelExecutorBaseOptions, TEnv extends KernelEnvPatch = Record<string, string | null>> {
-    kernel: GenericKernel<TEnv>;
-    code: string;
-    options: TOptions | undefined;
-    /** Prefix for the per-execution run id (e.g. `"py"`, `"rb"`, `"jl"`). */
-    runIdPrefix: string;
-    /** Human-readable language label used in the failure log line. */
-    errorLogLabel: string;
-    /**
-     * Julia surfaces eval-timeout control events through its normal status path,
-     * so they must NOT be filtered out the way the JS-status backends do.
-     */
-    isJulia?: boolean;
-    cancelledErrorClass: CancelledErrorClass;
-    buildKernelEnvPatch: (options: TOptions) => TEnv;
-    formatKernelTimeoutAnnotation: (executionTimeoutMs: number | undefined, kernelKilled: boolean) => string;
-    formatTimeoutAnnotation: (executionTimeoutMs: number | undefined) => string | undefined;
-    /**
-     * Override how the wall-clock deadline is derived from options. Defaults to
-     * {@link getExecutionDeadlineMs}; Julia passes the pre-computed `deadlineMs`
-     * straight through instead of re-deriving from `timeoutMs`.
-     */
-    resolveDeadlineMs?: (options: TOptions | undefined) => number | undefined;
-}
-export declare function executeWithKernelBase<TOptions extends KernelExecutorBaseOptions, TEnv extends KernelEnvPatch = Record<string, string | null>>(params: ExecuteWithKernelBaseParams<TOptions, TEnv>): Promise<KernelExecutionResult>;
-export {};

package/dist/types/eval/idle-timeout.d.ts

@@ -1,26 +0,0 @@
-/**
- * Watchdog for eval cell work.
- *
- * A cell's `timeout` bounds time while the Python kernel or JS VM is in control.
- * Host-side bridge calls can {@link pause} the watchdog so delegated
- * `agent()`/`parallel()`/`completion()` work is ignored completely, then {@link resume}
- * starts a fresh timeout window once the runtime gets control back.
- *
- * Pause is reference-counted because `parallel()` can have multiple bridge calls
- * in flight at once.
- */
-export declare class IdleTimeout {
-    #private;
-    constructor(idleMs: number);
-    /** Aborts with a `TimeoutError` reason once the active timeout window is exhausted. */
-    get signal(): AbortSignal;
-    /** Configured active timeout window in milliseconds. */
-    get idleMs(): number;
-    /** Suspend timeout accounting while control is delegated to host-side work. */
-    pause(): void;
-    /** Resume timeout accounting with a fresh timeout window. */
-    resume(): void;
-    /** Stop the watchdog. Safe to call multiple times. */
-    dispose(): void;
-    [Symbol.dispose](): void;
-}

package/dist/types/eval/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./backend";
-export { default as juliaBackend } from "./jl";
-export { default as jsBackend } from "./js";
-export { default as pythonBackend } from "./py";
-export { default as rubyBackend } from "./rb";
-export * from "./types";

package/dist/types/eval/jl/executor.d.ts

@@ -1,44 +0,0 @@
-import type { ToolSession } from "../../tools";
-import { type PyToolBridgeInfo } from "../py/tool-bridge";
-import type { EvalDisplayOutput, EvalStatusEvent } from "../types";
-import { JuliaKernel, type KernelExecuteOptions, type KernelExecuteResult } from "./kernel";
-export interface JuliaExecutorOptions {
-    cwd?: string;
-    sessionId?: string;
-    sessionFile?: string;
-    artifactsDir?: string;
-    localRoots?: Record<string, string>;
-    interpreter?: string;
-    onChunk?: (text: string) => void | Promise<void>;
-    onStatus?: (event: EvalStatusEvent) => void;
-    signal?: AbortSignal;
-    timeoutMs?: number;
-    deadlineMs?: number;
-    idleTimeoutMs?: number;
-    kernelOwnerId?: string;
-    reset?: boolean;
-    toolSession?: ToolSession;
-    bridge?: PyToolBridgeInfo;
-    bridgeSessionId?: string;
-    artifactId?: string;
-}
-export interface JuliaKernelExecutor {
-    execute: (code: string, options?: KernelExecuteOptions) => Promise<KernelExecuteResult>;
-}
-export interface JuliaResult {
-    output: string;
-    exitCode: number | undefined;
-    cancelled: boolean;
-    truncated: boolean;
-    artifactId: string | undefined;
-    totalLines: number;
-    totalBytes: number;
-    outputLines: number;
-    outputBytes: number;
-    displayOutputs: EvalDisplayOutput[];
-    stdinRequested: boolean;
-}
-export declare function disposeAllJuliaKernelSessions(): Promise<void>;
-export declare function disposeJuliaKernelSessionsByOwner(ownerId: string): Promise<void>;
-export declare function executeJuliaWithKernel(kernel: JuliaKernel, code: string, options?: JuliaExecutorOptions): Promise<JuliaResult>;
-export declare function executeJulia(code: string, options?: JuliaExecutorOptions): Promise<JuliaResult>;

package/dist/types/eval/jl/index.d.ts

@@ -1,11 +0,0 @@
-import type { ToolSession } from "../../tools";
-import { type ExecutorBackendExecOptions, type ExecutorBackendResult } from "../backend";
-export declare function namespaceSessionId(sessionId: string): string;
-declare const _default: {
-    id: "julia";
-    label: string;
-    highlightLang: string;
-    isAvailable(session: ToolSession): Promise<boolean>;
-    execute(code: string, opts: ExecutorBackendExecOptions): Promise<ExecutorBackendResult>;
-};
-export default _default;

package/dist/types/eval/jl/kernel.d.ts

@@ -1,28 +0,0 @@
-import { BaseKernel, type KernelStartOptions } from "../kernel-base";
-import type { KernelDisplayOutput } from "../py/display";
-import { type JuliaRuntime } from "./runtime";
-export type { KernelExecuteResult, KernelRuntimeEnv } from "../kernel-base";
-export { renderKernelDisplay } from "../py/display";
-export type { KernelDisplayOutput };
-export interface KernelExecuteOptions {
-    id?: string;
-    cwd?: string;
-    env?: Record<string, string | undefined>;
-    silent?: boolean;
-    storeHistory?: boolean;
-    timeoutMs?: number;
-    signal?: AbortSignal;
-    onChunk?: (text: string) => void | Promise<void>;
-    onDisplay?: (output: KernelDisplayOutput) => void | Promise<void>;
-}
-export interface JuliaKernelAvailability {
-    ok: boolean;
-    juliaPath?: string;
-    runtime?: JuliaRuntime;
-    reason?: string;
-}
-export declare function checkJuliaKernelAvailability(cwd: string, interpreter?: string): Promise<JuliaKernelAvailability>;
-export declare class JuliaKernel extends BaseKernel<KernelExecuteOptions> {
-    private constructor();
-    static start(options: KernelStartOptions): Promise<JuliaKernel>;
-}

package/dist/types/eval/jl/prelude.d.ts

@@ -1 +0,0 @@
-export declare const JULIA_PRELUDE: string;

package/dist/types/eval/jl/runtime.d.ts

@@ -1,22 +0,0 @@
-export interface JuliaRuntime {
-    /** Path to the julia executable. */
-    juliaPath: string;
-    /** Filtered environment variables. */
-    env: Record<string, string | undefined>;
-}
-export declare const filterEnv: (env: Record<string, string | undefined>) => Record<string, string | undefined>;
-/**
- * Resolve an explicitly configured interpreter (`julia.interpreter`) into a
- * runtime, bypassing discovery. Does not probe the executable.
- * `~` expands to the home directory and relative paths resolve against `cwd`.
- */
-export declare function resolveExplicitJuliaRuntime(interpreter: string, cwd: string, baseEnv: Record<string, string | undefined>): JuliaRuntime;
-/**
- * Enumerate candidate Julia runtimes in priority order. With an explicit
- * interpreter that is the only candidate; otherwise the first `julia` on PATH.
- */
-export declare function enumerateJuliaRuntimes(cwd: string, baseEnv: Record<string, string | undefined>, interpreter?: string): JuliaRuntime[];
-/**
- * Resolve the highest-priority Julia runtime. Throws when none exists.
- */
-export declare function resolveJuliaRuntime(cwd: string, baseEnv: Record<string, string | undefined>, interpreter?: string): JuliaRuntime;

package/dist/types/eval/js/context-manager.d.ts

@@ -1,40 +0,0 @@
-import type { ToolSession } from "../../tools";
-import type { JsDisplayOutput } from "./worker-protocol";
-export { rewriteImports, wrapCode } from "./shared/rewrite-imports";
-export type { JsDisplayOutput } from "./worker-protocol";
-export interface VmRunState {
-    signal?: AbortSignal;
-    onText?: (chunk: string) => void;
-    onDisplay?: (output: JsDisplayOutput) => void;
-}
-/**
- * Test-only seam: override the graceful-close grace period (ms). Returns the
- * previous value so callers can restore it. Production always uses
- * {@link WORKER_CLOSE_TIMEOUT_MS}; never call this outside tests.
- */
-export declare function setWorkerCloseTimeoutMsForTests(ms: number): number;
-export declare function executeInVmContext(options: {
-    sessionKey: string;
-    sessionId: string;
-    cwd: string;
-    session: ToolSession;
-    localRoots?: Record<string, string>;
-    reset?: boolean;
-    code: string;
-    filename: string;
-    timeoutMs?: number;
-    runState: VmRunState;
-}): Promise<{
-    value: unknown;
-}>;
-export declare function resetVmContext(sessionKey: string): Promise<void>;
-export declare function disposeAllVmContexts(): Promise<void>;
-/**
- * Smoke probe: spawn the JS eval worker through the worker-host entry and prove
- * it answers the `init` handshake on a real worker thread (not the inline
- * fallback). Catches the silent worker-load and init-message-drop regressions
- * that otherwise strand every cell on the init timeout in a distribution build —
- * the failure mode that motivated `installWorkerInbox`. Wired into
- * `jeopi --smoke-test` so binary / source / tarball installs all exercise it.
- */
-export declare function smokeTestJsEvalWorker(): Promise<void>;

package/dist/types/eval/js/executor.d.ts

@@ -1,38 +0,0 @@
-import type { ToolSession } from "../../tools";
-import { type JsDisplayOutput } from "./context-manager";
-import type { JsStatusEvent } from "./shared/types";
-export interface JsExecutorOptions {
-    cwd?: string;
-    timeoutMs?: number;
-    deadlineMs?: number;
-    /**
-     * Runtime-work budget (ms). Used for worker cold-start headroom and
-     * timeout-annotation text when the caller drives cancellation via the eval
-     * watchdog `signal` instead of `deadlineMs`/`timeoutMs`. Never arms a timer.
-     */
-    idleTimeoutMs?: number;
-    onChunk?: (chunk: string) => Promise<void> | void;
-    onStatus?: (event: JsStatusEvent) => void;
-    signal?: AbortSignal;
-    sessionId: string;
-    reset?: boolean;
-    sessionFile?: string;
-    artifactPath?: string;
-    artifactId?: string;
-    session: ToolSession;
-    /** On-disk roots the helpers substitute for internal-URL schemes (e.g. `local://`). */
-    localRoots?: Record<string, string>;
-}
-export interface JsResult {
-    output: string;
-    exitCode: number | undefined;
-    cancelled: boolean;
-    truncated: boolean;
-    artifactId?: string;
-    totalLines: number;
-    totalBytes: number;
-    outputLines: number;
-    outputBytes: number;
-    displayOutputs: JsDisplayOutput[];
-}
-export declare function executeJs(code: string, options: JsExecutorOptions): Promise<JsResult>;

package/dist/types/eval/js/index.d.ts

@@ -1,11 +0,0 @@
-import type { ToolSession } from "../../tools";
-import { type ExecutorBackendExecOptions, type ExecutorBackendResult } from "../backend";
-export declare function namespaceSessionId(sessionId: string): string;
-declare const _default: {
-    id: "js";
-    label: string;
-    highlightLang: string;
-    isAvailable(_session: ToolSession): Promise<boolean>;
-    execute(code: string, opts: ExecutorBackendExecOptions): Promise<ExecutorBackendResult>;
-};
-export default _default;

package/dist/types/eval/js/shared/helpers.d.ts

@@ -1,32 +0,0 @@
-import type { JsStatusEvent } from "./types";
-export interface HelperOptions {
-    limit?: number;
-    offset?: number;
-}
-/**
- * Inputs the helper factory needs from its host runtime. `cwd` is a getter so the runtime
- * can update it between cells (e.g. when the agent's session cwd changes) without
- * recreating helpers.
- */
-export interface HelperContext {
-    cwd(): string;
-    env: Map<string, string>;
-    /**
-     * On-disk roots for internal-URL schemes the helpers accept (e.g.
-     * `{ local: "/…/artifacts/local" }`). A path like `local://x.md` is rewritten
-     * to `<root>/x.md` before any filesystem op; unknown schemes are rejected.
-     */
-    localRoots(): Record<string, string>;
-    emitStatus(event: JsStatusEvent): void;
-}
-/**
- * The set of functions exposed to user code via `globalThis.__omp_helpers__`. The JS
- * prelude reads from this bag and attaches short aliases (`read`, `write`, `env`, ...)
- * onto the global scope.
- */
-export interface HelperBundle {
-    read(rawPath: string, options?: HelperOptions): Promise<string>;
-    writeFile(rawPath: string, data: unknown): Promise<string>;
-    env(key?: string, value?: string): string | Record<string, string> | undefined;
-}
-export declare function createHelpers(ctx: HelperContext): HelperBundle;

package/dist/types/eval/js/shared/indirect-eval.d.ts

@@ -1,14 +0,0 @@
-/**
- * Indirect eval — runs in the host's global scope, isolating bindings declared with
- * `const`/`let` from this module's closure. Used by both the JS eval worker and the
- * browser tab worker to execute user-supplied source without `node:vm`.
- *
- * Why not vm.runInContext: Bun crashes the parent process with SIGTRAP when
- * `Worker.terminate()` fires while a worker is mid-`vm.runInContext` synchronous loop.
- * Indirect eval does not trip that bug.
- *
- * The optional `filename` is appended as a `//# sourceURL=...` pragma so V8 attributes
- * stack frames to the user cell instead of `<anonymous>`.
- */
-export declare function indirectEval(source: string, filename?: string): unknown;
-export declare function awaitMaybePromise<T>(value: T | Promise<T>): Promise<T>;

package/dist/types/eval/js/shared/local-module-loader.d.ts

@@ -1,16 +0,0 @@
-export type LocalImportResolution = {
-    mode: "local";
-    value: unknown;
-} | {
-    mode: "external";
-    target: string;
-};
-export declare class LocalModuleLoader {
-    #private;
-    constructor(sessionId: string);
-    resolveForRun(cwd: string, source: string): Promise<LocalImportResolution>;
-    resolveForModule(moduleUrl: string, source: string, cwd: string): Promise<LocalImportResolution>;
-    requireForFile(moduleUrlOrPath: string | undefined, cwd: string): NodeJS.Require;
-    filenameForUrl(moduleUrlOrPath: string | undefined): string | null;
-    dirnameForUrl(moduleUrlOrPath: string | undefined, cwd: string): string;
-}

package/dist/types/eval/js/shared/prelude.d.ts

@@ -1 +0,0 @@
-export declare const JAVASCRIPT_PRELUDE_SOURCE: string;

package/dist/types/eval/js/shared/rewrite-imports.d.ts

@@ -1,25 +0,0 @@
-export declare function rewriteImports(code: string): Promise<string>;
-export declare function collectModuleSourceSpecifiers(code: string): Promise<string[]>;
-export declare function rewriteModuleSourceSpecifiers(code: string, replacer: (source: string) => string): Promise<string>;
-export declare function rewriteDynamicImports(code: string, callee?: string): Promise<string>;
-/**
- * Strip TypeScript syntax (type annotations, type-only imports/exports, `interface`, `as`,
- * `satisfies`, generics in call expressions, etc.) before the import/lexical rewriters parse
- * the code. Bun's native transpiler preserves `import`/`export` declarations, so downstream
- * Babel rewrites still control module resolution.
- *
- * Eval cells use a cheap "looks like TS" heuristic to avoid transpiling ordinary JS. Known
- * TypeScript modules pass `force` because a file can contain TS-only module syntax such as
- * `import type` without any value-level type annotations.
- */
-type TypeScriptStripLoader = "ts" | "tsx";
-export declare function stripTypeScriptSyntax(code: string, options?: {
-    force?: boolean;
-    loader?: TypeScriptStripLoader;
-}): string;
-export declare function wrapCode(code: string): Promise<{
-    source: string;
-    asyncWrapped: boolean;
-    finalExpressionReturned: boolean;
-}>;
-export {};