@robmclarty/volley 0.7.0 → 0.9.0

package/dist/index.d.ts

@@ -1,17 +1,18 @@
-import { Engine, FinishReason, StreamChunk, Throughput, UsageTotals } from "fascicle";
+import { Engine, FinishReason, StreamChunk, Throughput, Tool, ToolApprovalHandler, TrajectoryLogger, UsageTotals } from "fascicle";
 import { z } from "zod";
 //#region src/types.d.ts
 type Verdict = 'approved' | 'changes_requested';
 type CriticPreset = 'reviewer' | 'optimizer' | 'researcher';
 /** Transport for the critic role. The critic is read-only + schema-constrained,
- * so it has always been able to run on a local model. */
-type CriticProvider = 'claude_cli' | 'ollama' | 'lmstudio';
+ * so it has always been able to run on a local model. `openrouter` reaches a
+ * hosted model over one API key and takes the local critic's tools and
+ * degradation ladder. */
+type CriticProvider = 'claude_cli' | 'ollama' | 'lmstudio' | 'openrouter';
 /** Transport for the builder role. `claude_cli` is a full agentic Claude Code
- * session; the local providers run the builder as a volley-driven tool loop
- * (write/exec tools supplied by the harness). The execution path for the local
- * providers lands with the builder tool/termination work; this type and its
- * plumbing exist so that work has somewhere to attach (spec v3). */
-type BuilderProvider = 'claude_cli' | 'ollama' | 'lmstudio';
+ * session; every other provider runs the builder as a volley-driven tool loop
+ * (write/exec tools supplied by the harness), whether its model is local
+ * (`ollama`, `lmstudio`) or hosted (`openrouter`). */
+type BuilderProvider = 'claude_cli' | 'ollama' | 'lmstudio' | 'openrouter';
 type BuilderPermissionMode = 'acceptEdits' | 'bypassPermissions';
 /** `auto`, `none`, or any shell command (the `string & {}` keeps the literal
  * hints in editor completions without collapsing the union). */
@@ -22,11 +23,22 @@ type CostSource = 'provider_reported' | 'engine_derived' | 'unknown';
  * died. Recorded alongside a critic retry so a degraded run says
  * *what* failed, not just that it retried. */
 type CauseKind = 'provider_5xx' | 'network' | 'unknown';
+/** Why a local critic's verdict came from the tool-less fallback:
+ * `stream_error`, the tool-bearing call kept dying on the provider's stream
+ * after the bounded retry; `step_exhaustion`, it spent its step budget (or
+ * stopped on a tool call) without producing a verdict. */
+type DegradeCause = 'stream_error' | 'step_exhaustion';
 type RunStatus = 'running' | 'success' | 'budget_exhausted' | 'cost_cap_reached' |
 /** The builder edited the gate that judges it, under `--fail-on-gate-edit`:
  * the run halts on the spot rather than iterating, because a check the builder
  * can rewrite is not evidence the work is done. */
-'gate_edit_blocked' | 'interrupted' | 'error';
+'gate_edit_blocked' |
+/** A critique's other outcome: the critic requested changes, or the check
+ * failed, on the one change it reviewed. A run never ends this way. */
+'rejected' | 'interrupted' | 'error';
+/** What a run does: the builder/critic loop (`run`), or one check and one
+ * critique of a change already made, with no builder at all (`critique`). */
+type RunMode = 'run' | 'critique';
 /** User-facing configuration, before resolution (config file / flags). */
 type VolleyConfig = {
   prompt: string;
@@ -37,6 +49,7 @@ type VolleyConfig = {
   builder_provider?: BuilderProvider;
   builder_url?: string;
   builder_max_steps?: number;
+  builder_max_tool_calls?: number;
   allow_unsandboxed_builder?: boolean;
   critic_model?: string;
   critic_provider?: CriticProvider;
@@ -51,17 +64,25 @@ type VolleyConfig = {
   gate_paths?: string[];
   fail_on_gate_edit?: boolean;
   sandbox_image?: string;
+  state_dir?: string;
   verbose?: boolean;
   quiet?: boolean;
   json?: boolean;
   show_thinking?: boolean;
   dry_run?: boolean;
 };
-/** Fully resolved run configuration; `.volley/config.json` mirrors this. */
+/** Fully resolved run configuration; the run's `config.json` mirrors this. */
 type ResolvedConfig = {
   version: 2;
   run_id: string;
   started_at: string;
+  /** A run, or a critique (`volley critique`). A critique's builder fields
+   * hold the defaults, untouched by flags and the environment, since no
+   * builder is ever constructed, and its loop settings are one round with
+   * nothing isolated or committed. */
+  mode: RunMode;
+  /** The task. A critique needs none, since a critic judges against the
+   * criteria alone, so it's empty unless one was given to record. */
   prompt: string;
   criteria: string;
   check: CheckMode;
@@ -72,12 +93,18 @@ type ResolvedConfig = {
    * It is normalized, and crossed to the host LLM endpoint when contained, only
    * where it is used, because the crossing depends on where the run executes.
    * Null falls back to the provider's env var (`VOLLEY_OLLAMA_URL` /
-   * `VOLLEY_LMSTUDIO_URL`), then its default, never to the critic's URL. Only
-   * a provider volley reaches at a base URL (ollama, lmstudio) takes one. */
+   * `VOLLEY_LMSTUDIO_URL` / `VOLLEY_OPENROUTER_URL`), then its default, never to
+   * the critic's URL. Only a provider volley reaches at a base URL (ollama,
+   * lmstudio, openrouter) takes one. */
   builder_url: string | null;
   builder_max_steps: number;
-  /** Operator opt-out permitting a local (non-`claude_cli`) builder to run
-   * without a sandbox — it gets a real host bash. Refused by default. */
+  /** How many tool calls a tool-loop builder may make in one turn; fascicle
+   * runs the first that many, in order, and drops the rest. 1 by default,
+   * since some model and runtime pairs return parallel calls badly; raise it
+   * for a pair that handles them. Ignored by the `claude_cli` builder. */
+  builder_max_tool_calls: number;
+  /** Operator opt-out permitting a non-`claude_cli` builder to run without a
+   * sandbox — it gets a real host bash. Refused by default. */
   allow_unsandboxed_builder: boolean;
   critic_model: string;
   critic_provider: CriticProvider;
@@ -92,7 +119,7 @@ type ResolvedConfig = {
   git_checkpoints: boolean;
   /** Isolate the builder run's effects in a per-run git worktree: the
    * builder/critic file tools' containment root moves to the worktree, while
-   * `.volley/` state stays under `workspace` (the control plane). Off by
+   * the run's state stays where `state_dir` puts it (the control plane). Off by
    * default; requires the workspace to be a git repository. */
   worktree: boolean;
   /** Throw a `--worktree` run's effects away at teardown even when it converged:
@@ -119,6 +146,13 @@ type ResolvedConfig = {
    * `VOLLEY_SANDBOX_IMAGE` override it. Meaningful only for a local builder —
    * the `claude_cli` path never uses Docker. */
   sandbox_image: string;
+  /** The root that holds each run's state at `<state_dir>/<run_id>/`, as an
+   * absolute path: `--state-dir`, else the default root,
+   * `$XDG_STATE_HOME/volley` or `~/.local/state/volley`. `resolve_config`
+   * always sets one. Null is the layout older runs used, `<workspace>/.volley/`,
+   * rotated aside by the next fresh run: a run an older volley started
+   * resumes in it, and a hand-built config can still ask for it. */
+  state_dir: string | null;
   workspace: string;
   verbose: boolean;
   quiet: boolean;
@@ -209,12 +243,15 @@ type PhaseRecord = {
   retry_cause_kind?: CauseKind;
   /** This local-critic verdict was rendered by the tool-less fallback rung:
    * the tool-bearing critique kept dying on the provider's stream
-   * even after the bounded retry, so the critic judged with no read access —
-   * grounded only by the criteria, the raw check artifacts, and a workspace file
-   * inventory. Set (true) on a degraded critic record; absent on a full
-   * critique and on the builder. Additive, and a degraded verdict is *always*
-   * marked so it never passes silently as a full one. */
+   * even after the bounded retry, or ran out of steps before its verdict, so the
+   * critic judged with no read access — grounded only by the criteria, the raw
+   * check artifacts, and a workspace file inventory. Set (true) on a degraded
+   * critic record; absent on a full critique and on the builder. Additive, and a
+   * degraded verdict is *always* marked so it never passes silently as a full
+   * one. */
   critic_degraded?: boolean;
+  /** Why the verdict degraded, set with `critic_degraded`. Additive. */
+  degrade_cause?: DegradeCause;
   /** Output tokens per second over the model's own turns (tool execution and
    * retry backoff excluded), from fascicle's per-step timing. `basis` is
    * `decode` when every turn streamed, `blended` when any round trip counted
@@ -255,7 +292,7 @@ type LoopState = {
   halt: HaltReason;
   cost_warned: boolean;
 };
-/** Projection of final loop state; `.volley/summary.json` mirrors this. */
+/** Projection of final loop state; the run's `summary.json` mirrors this. */
 type RunResult = {
   run_id: string;
   status: RunStatus;
@@ -273,8 +310,15 @@ type RunResult = {
    * other copy of its effects, so teardown commits them onto `volley/<run id>`
    * and keeps the branch instead of force-deleting it. Null whenever nothing
    * survived — every non-worktree run, every integrated run, every discarded
-   * one. `--json` consumers read it here; `.volley/summary.json` mirrors it. */
+   * one. `--json` consumers read it here; the run's `summary.json` mirrors it. */
   salvaged_branch: string | null;
+  /** A run, or a critique, which runs no builder. */
+  mode: RunMode;
+  /** Where this run keeps its config, summary, trajectory, feedback, verdict,
+   * and iterations: `<state_dir>/<run_id>/` under a state root, else the
+   * workspace's `.volley/`. Inside the sandbox container it is the container's
+   * path, which a harness maps back to the directory it mounted. */
+  run_state_dir: string;
 };
 //#endregion
 //#region src/config.d.ts
@@ -287,12 +331,104 @@ type ResolveOptions = {
   run_id?: string;
   started_at?: string;
   env?: Record<string, string | undefined>;
+  /** What happens to a tool-loop builder with nothing between its commands
+   * and the host (`unguarded_builder`): the CLI `refuse`s it, the default,
+   * while under `volley acp` each of its commands `ask`s a person first, which
+   * takes the container's place. */
+  uncontained_builder?: 'refuse' | 'ask';
+  /** Where the run's state goes, in place of what the config says: `volley
+   * resume` passes the root it found the run under, or null for a run an older
+   * volley kept in the workspace's `.volley/`, which resumes there. */
+  state_dir?: string | null;
+  /** A run (the default), or a critique, which has no builder or loop. */
+  mode?: RunMode;
 };
 /** Merge, expand, and validate a raw `VolleyConfig` into a `ResolvedConfig`.
  * `check_resolved` comes from check detection against the workspace, so the
  * SDK and the CLI resolve `auto` and a command check the same way. */
 export declare function resolve_config(raw: VolleyConfig, options?: ResolveOptions): ResolvedConfig;
 //#endregion
+//#region src/builder/tools.d.ts
+/** The raw outcome of running one bash command, before the model-facing
+ * truncation + timeout marker the `bash` tool applies. `status` is the exit code
+ * (null when the process was killed by a signal — e.g. the timeout SIGKILL);
+ * `timed_out` marks the timeout path. */
+type BashOutcome = {
+  status: number | null;
+  stdout: string;
+  stderr: string;
+  timed_out: boolean;
+};
+/** How the `bash` tool runs a command: the local `host_bash_executor`
+ * (`spawnSync`) — which under whole-process containment runs *inside*
+ * volley's own hardened container, no `docker exec` hop. The executor runs one
+ * command to completion and returns its raw outcome; the `bash` tool owns the
+ * truncation + timeout marker. Kept as an injectable seam so tests can supply a
+ * fake and a future shape could re-point it (the `docker exec` executor was
+ * retired). */
+type BashExecutor = (command: string, options: {
+  timeout_ms: number;
+  max_capture_bytes: number;
+}) => BashOutcome;
+//#endregion
+//#region src/workspace_tools.d.ts
+/** Which tool set a seat holds, so its prompt names the tools it has: volley's
+ * own (`'volley'`), or fascicle's workspace tools under `volley acp`
+ * (`'acp'`). */
+type ToolSet = 'volley' | 'acp';
+//#endregion
+//#region src/builder.d.ts
+type BuilderDeps = {
+  engine: Engine;
+  config: ResolvedConfig;
+  on_chunk: (chunk: StreamChunk) => void;
+  /** The `bash` executor for a sandboxed local builder (`docker exec` against
+   * the run's container), or null to use the host `spawnSync` default (the
+   * unsandboxed escape hatch, or `claude_cli` which supplies no volley tools). */
+  bash_executor?: BashExecutor | null;
+  /** Tools to hand the builder in place of volley's own set; absent, it gets
+   * that set. A `claude_cli` builder brings its own tools and never takes
+   * these. */
+  tools?: ReadonlyArray<Tool>;
+  /** Which set `tools` is, so the prompt names the tools the builder holds;
+   * absent, volley's own. */
+  tool_set?: ToolSet;
+  /** Answers each call to a tool that asks first (`needs_approval`). Like
+   * `tools`, it reaches every builder but `claude_cli`. Absent, such a call
+   * fails closed. */
+  on_tool_approval?: ToolApprovalHandler;
+};
+//#endregion
+//#region src/critic/run.d.ts
+/** A critic that holds tools isn't constrain-decoded, so nothing stops it
+ * answering null for the feedback or the unmet list, as GLM did on approving.
+ * Both fields allow null and read it as empty, so that answer is a verdict
+ * rather than a schema failure that ends the run. fascicle sends the schema's
+ * input side, so the model sees each field as its type or null, still
+ * required; `.describe()` comes last so the description stays on the field. */
+export declare const verdict_schema: z.ZodObject<{
+  verdict: z.ZodEnum<{
+    approved: "approved";
+    changes_requested: "changes_requested";
+  }>;
+  feedback: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string, string | null>>;
+  unmet_criteria: z.ZodPipe<z.ZodNullable<z.ZodArray<z.ZodString>>, z.ZodTransform<string[], string[] | null>>;
+}, z.core.$strip>;
+type VerdictOutput = z.infer<typeof verdict_schema>;
+type CriticDeps = {
+  engine: Engine;
+  config: ResolvedConfig;
+  on_chunk: (chunk: StreamChunk) => void;
+  /** Tools to hand the critic's tool-bearing call in place of volley's reads;
+   * absent, it gets those. A `claude_cli` critic reads through the CLI's own
+   * tools and never takes these. The critic takes no approval handler, since
+   * nothing it reads with should ever ask. */
+  tools?: ReadonlyArray<Tool>;
+  /** Which set `tools` is, so the harness append names the reads the critic
+   * holds; absent, volley's own. */
+  tool_set?: ToolSet;
+};
+//#endregion
 //#region src/render/format.d.ts
 type Role = 'builder' | 'critic' | 'check';
 //#endregion
@@ -303,6 +439,9 @@ type RendererOptions = {
   show_thinking: boolean;
   color: boolean;
   max_cost_usd: number | null;
+  /** Where the run's trajectory is written, named when verbose output is cut
+   * short (default: "the run's trajectory.jsonl"). */
+  trajectory_path?: string;
   write?: (text: string) => void;
 };
 type Renderer = {
@@ -318,6 +457,30 @@ type Renderer = {
 };
 export declare function create_renderer(options: RendererOptions): Renderer;
 //#endregion
+//#region src/phases.d.ts
+/** How the check runs when the caller sets it, as `volley acp` does. Left
+ * out, the check inherits volley's environment and runs unasked, as on the
+ * CLI. */
+type CheckGate = {
+  /** The whole environment the check runs with, in place of volley's own. */
+  env?: Readonly<Record<string, string>>;
+  /** Asked on the check's card before each check, the way a model call asks
+   * before a gated tool runs. Anything short of an allow keeps the check from
+   * running, and it's recorded as failed. */
+  on_approval?: ToolApprovalHandler;
+};
+//#endregion
+//#region src/flow.d.ts
+/** The builder seat: the engine its calls go through, and, when the caller
+ * injects them, the tools that replace volley's own set, the name of that set
+ * (which its prompt names), and the handler that answers their approval
+ * requests. */
+type BuilderSeat = Pick<BuilderDeps, 'engine' | 'tools' | 'tool_set' | 'on_tool_approval'>;
+/** The critic seat: its engine and, when injected, the tools that replace its
+ * reads and the name of their set. It takes no approval handler, since its
+ * reads never ask. */
+type CriticSeat = Pick<CriticDeps, 'engine' | 'tools' | 'tool_set'>;
+//#endregion
 //#region src/orchestrator.d.ts
 type OrchestratorDeps = {
   renderer: Renderer;
@@ -325,10 +488,45 @@ type OrchestratorDeps = {
    * config. It serves both seats as-is, so the seat URLs then steer only
    * volley's own requests (prewarm and the context probe), not model calls. */
   engine?: Engine;
+  /** What to hand each seat in place of volley's own wiring: the builder's
+   * tools and the handler that answers their approval requests, and the
+   * critic's tools. A seat or a field left out keeps today's wiring, and a
+   * `claude_cli` seat, which brings its own tools, takes none of it. */
+  seats?: {
+    builder?: Omit<BuilderSeat, 'engine'>;
+    critic?: Omit<CriticSeat, 'engine'>;
+  };
+  /** A second sink for the run's trajectory, beside the run's
+   * `trajectory.jsonl`. With one, the flow runs through `run.stream`, so the
+   * sink also receives each model call's streamed chunks as `model_chunk`
+   * events, which the file never keeps. */
+  trajectory?: TrajectoryLogger;
+  /** The environment the check runs with and the approval it asks first, in
+   * place of inheriting volley's environment and running unasked. */
+  check?: CheckGate;
   abort?: AbortSignal;
   install_signal_handlers?: boolean;
 };
 export declare function run_volley(config: ResolvedConfig, deps: OrchestratorDeps, resume_from?: LoopState | null): Promise<RunResult>;
+/** What a critique runs with: what a run does, less the builder's seat, plus
+ * the revision its change is measured from. */
+type CritiqueDeps = Omit<OrchestratorDeps, 'seats'> & {
+  /** The revision the change under review is measured from (`--baseline`):
+   * everything that differs from it, committed or not, untracked files
+   * included. HEAD when absent, so the uncommitted edits are the change. */
+  baseline?: string;
+  /** The critic's tools in place of volley's reads, as for a run's critic. */
+  critic?: Omit<CriticSeat, 'engine'>;
+};
+/**
+ * `volley critique`: the check and the critic, once, over a change already
+ * made. No builder is constructed, and the engine serves the critic's seat
+ * alone, so a critic can be measured on fixed, labeled changes without paying
+ * for builder turns. It writes the state a one-round run does, with the mode
+ * recorded, and ends `success` on approval over a green check, else
+ * `rejected`.
+ */
+export declare function run_critique(config: ResolvedConfig, deps: CritiqueDeps): Promise<RunResult>;
 //#endregion
 //#region src/loop_state.d.ts
 export declare function initial_state(): LoopState;
@@ -346,18 +544,14 @@ export declare function gate(config: ResolvedConfig, state: LoopState): {
 };
 export declare function status_of(value: LoopState, converged: boolean): RunStatus;
 //#endregion
-//#region src/critic/run.d.ts
-export declare const verdict_schema: z.ZodObject<{
-  verdict: z.ZodEnum<{
-    approved: "approved";
-    changes_requested: "changes_requested";
-  }>;
-  feedback: z.ZodString;
-  unmet_criteria: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
-type VerdictOutput = z.infer<typeof verdict_schema>;
-//#endregion
 //#region src/sandbox.d.ts
+/** Where volley inside the container keeps each run's state when no
+ * `--state-dir` names a root: the default root under the pinned `HOME`, since
+ * the image sets no `XDG_STATE_HOME`. `sandbox_run_args`'s `run_state` binds one
+ * run's host directory at that run's directory under it, so the state outlives
+ * the `--rm` container. Exported so a harness can map a contained run's
+ * `run_state_dir` back to the directory it mounted. */
+export declare const SANDBOX_STATE_ROOT: string;
 /** Canonical identity of the allowlist bridge the examples create (`docker
  * network create --subnet <SANDBOX_NETWORK_SUBNET> <SANDBOX_NETWORK_NAME>`) and
  * the host `DOCKER-USER` rules scope to. Exported so the blessed examples
@@ -403,7 +597,7 @@ export declare function network_run_args(network: SandboxNetwork, network_name:
 /**
  * The hardened `docker run` argv that launches volley inside its container.
  * Pure and exported so the flag set is unit-testable without a
- * daemon and the blessed examples / `--dry-run` preflight can render it.
+ * daemon and the blessed examples and a parent harness can render it.
  *
  * A one-shot, foreground `--rm` container — the whole run *is* this
  * container (an earlier design ran a detached `-d … sleep infinity` daemon volley
@@ -415,6 +609,25 @@ export declare function network_run_args(network: SandboxNetwork, network_name:
  * the image entrypoint (the opt-in real-docker isolation test runs a raw `sh`
  * this way).
  *
+ * `run_state` binds the run's own state directory on the host,
+ * `<root>/<run_id>/`, at `<SANDBOX_STATE_ROOT>/<run_id>/`, where volley inside
+ * keeps that run's state when no `--state-dir` names a root, so it outlives the
+ * container at the path a run on the host would use. Only the one directory
+ * is mounted, never the root: the builder inside runs arbitrary commands, so
+ * it can rewrite its own run's state but can't read another run's trajectory
+ * or plant a check in another run's config. Its own run's state is still the
+ * builder's to rewrite, config.json included, so a host-side resume refuses
+ * that config, which volley signs only outside the sandbox (`./trust.ts`), and
+ * a directory holding a symlink: resume a contained run inside the container,
+ * with the same mount. Create the
+ * directory on the host first, empty (Docker on Linux makes a missing bind
+ * source owned by root, which the container's user can't write), and pass the
+ * same id to volley as `--run-id`. Keep it outside `build_root`, so the check
+ * never reads it, and pass no `XDG_STATE_HOME` in `env`, which would move the
+ * root off the mount. Omit it and no state is mounted: a contained run keeping
+ * its state under the default root then stops before spending (exit 5),
+ * since the read-only root filesystem leaves it nowhere to write.
+ *
  * `store_volume` mounts the named volume as the pnpm store; omit it and no store
  * is mounted. A store is shared by every run that mounts it, so a caller that
  * installs dependencies in a separate container first can keep the builder's
@@ -424,13 +637,17 @@ export declare function network_run_args(network: SandboxNetwork, network_name:
  * Never emits `--privileged` and refuses `--user 0`: volley must not hand
  * the sandbox root or full capabilities. Everything writable under the
  * `--read-only` rootfs is an explicit tmpfs or volume; the bind-mounted worktree
- * is the one host-visible write path.
+ * and, when one is named, the state root are the host-visible write paths.
  */
 export declare function sandbox_run_args(options: {
   image: string;
   build_root: string;
   uid: number | null;
   gid: number | null;
+  run_state?: {
+    root: string;
+    run_id: string;
+  } | null;
   store_volume?: string | null;
   network: SandboxNetwork;
   network_name: string;
@@ -441,6 +658,13 @@ export declare function sandbox_run_args(options: {
   command?: ReadonlyArray<string>;
 }): string[];
 //#endregion
+//#region src/workspace.d.ts
+/** The root each run's state sits under when `--state-dir` names none:
+ * `$XDG_STATE_HOME/volley`, else `<home>/.local/state/volley`. A relative
+ * `XDG_STATE_HOME` is ignored, as the XDG spec says. `home` is the host's by
+ * default; the sandbox passes its container's to spell the same root inside. */
+export declare function default_state_root(env: Readonly<Record<string, string | undefined>>, home?: string): string;
+//#endregion
 //#region src/exit_codes.d.ts
 export declare const EXIT_SUCCESS = 0;
 export declare const EXIT_BUDGET_EXHAUSTED = 2;
@@ -453,5 +677,5 @@ export declare const EXIT_INTERRUPTED = 130;
 export declare function exit_code_for_status(status: RunStatus): number;
 export declare function exit_code_for_error(err: unknown): number;
 //#endregion
-export type { BuilderPermissionMode, CheckArtifact, CheckMode, CheckResult, CheckRunnerKind, CostSource, CriticPreset, CriticProvider, HaltReason, LoopState, PhaseRecord, RenderMode, Renderer, RendererOptions, ResolvedConfig, RunResult, RunStatus, SandboxNetwork, Verdict, VerdictOutput, VolleyConfig };
+export type { BuilderPermissionMode, CheckArtifact, CheckMode, CheckResult, CheckRunnerKind, CostSource, CriticPreset, CriticProvider, CritiqueDeps, HaltReason, LoopState, PhaseRecord, RenderMode, Renderer, RendererOptions, ResolvedConfig, RunMode, RunResult, RunStatus, SandboxNetwork, Verdict, VerdictOutput, VolleyConfig };
 //# sourceMappingURL=index.d.ts.map