@alchemy.run/modal 0.0.0 → 2.0.0-beta.86

package/lib/SandboxClient.d.ts

@@ -0,0 +1,748 @@
+import * as persistent from "@distilled.cloud/modal/persistent";
+import * as sandbox from "@distilled.cloud/modal/sandbox";
+import * as router from "@distilled.cloud/modal/task_command_router";
+import type { RuntimeContext } from "alchemy/RuntimeContext";
+import * as Sandbox from "alchemy/Sandbox";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as HttpClient from "effect/http/HttpClient";
+import type * as HttpClientError from "effect/http/HttpClientError";
+import * as HttpClientRequest from "effect/http/HttpClientRequest";
+import type * as HttpClientResponse from "effect/http/HttpClientResponse";
+import type * as HttpServerRequest from "effect/http/HttpServerRequest";
+import type * as HttpServerResponse from "effect/http/HttpServerResponse";
+import type * as Scope from "effect/Scope";
+import type * as Socket from "effect/socket/Socket";
+import * as Stream from "effect/Stream";
+import { type ErrorOf } from "./internal.ts";
+import { type ModalMounts, type SandboxMount } from "./Mounts.ts";
+declare const SandboxNotRunning_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Modal.SandboxNotRunning";
+} & Readonly<A>;
+/** A sandbox ended (or never became ready) before the call could finish. */
+export declare class SandboxNotRunning extends SandboxNotRunning_base<{
+    readonly sandboxId: string;
+    readonly message: string;
+}> {
+}
+declare const SandboxUnexpectedResponse_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Modal.SandboxUnexpectedResponse";
+} & Readonly<A>;
+/** A Modal call returned without the field the client needs. */
+export declare class SandboxUnexpectedResponse extends SandboxUnexpectedResponse_base<{
+    readonly message: string;
+}> {
+}
+declare const SandboxFilesystemError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Modal.SandboxFilesystemError";
+} & Readonly<A>;
+/** A filesystem operation inside the sandbox failed (missing path, permissions). */
+export declare class SandboxFilesystemError extends SandboxFilesystemError_base<{
+    readonly path: string;
+    readonly message: string;
+}> {
+}
+/** A Modal duration: seconds, or a string like `"10 minutes"`. */
+export type DurationInput = number | string;
+/** An image a sandbox boots from: a registry ref, or a `Modal.Image` (resolved). */
+export type SandboxImage = string | {
+    readonly imageId: string;
+};
+/** Where a route sends matching traffic: blocked, through a `Modal.Proxy`, or to a sidecar. */
+export type OutboundRedirect = "block" | {
+    readonly proxy: {
+        readonly proxyId: string;
+    };
+} | {
+    readonly sidecar: string;
+};
+/** An inclusive port range, or one port. */
+export type OutboundPorts = ReadonlyArray<number | {
+    readonly start: number;
+    readonly end: number;
+}>;
+/** Set headers on decrypted HTTPS requests, with values from a secret. */
+export interface HeaderReplacement {
+    /** The secret whose keys the header values reference. Omit for static values. */
+    readonly secret?: {
+        readonly secretId: string;
+    };
+    /** Header name to value; `$KEY` is replaced with the secret's `KEY`, `$$` is a literal `$`. */
+    readonly headers: Record<string, string>;
+}
+/**
+ * One route of an {@link OutboundPolicy}. Routes match in order; traffic a
+ * route matches without a `redirect` goes to its destination.
+ */
+export type OutboundRoute = {
+    /** Traffic to these CIDR ranges. */
+    readonly ip: {
+        readonly cidrs: ReadonlyArray<string>;
+        /** @default every port */
+        readonly ports?: OutboundPorts;
+        readonly transport?: "tcp" | "udp" | "any";
+        readonly redirect?: OutboundRedirect;
+    };
+} | {
+    /** TLS connections to these domains (`*.` wildcards allowed), never decrypted. */
+    readonly tls: {
+        readonly domains: ReadonlyArray<string>;
+        /** @default 443 */
+        readonly ports?: OutboundPorts;
+        readonly redirect?: OutboundRedirect;
+    };
+} | {
+    /** HTTPS requests to these domains, decrypted so headers can be replaced. */
+    readonly https: {
+        readonly domains: ReadonlyArray<string>;
+        /** @default 443 */
+        readonly ports?: OutboundPorts;
+        readonly headerReplacements?: ReadonlyArray<HeaderReplacement>;
+        readonly redirect?: OutboundRedirect;
+    };
+} | {
+    /** Everything no earlier route matched. Must be the last route. */
+    readonly any: {
+        readonly redirect?: OutboundRedirect;
+    };
+};
+/**
+ * A sandbox's outbound traffic rules, enforced by Modal outside the
+ * sandbox. HTTPS routes decrypt traffic with a certificate authority the
+ * sandbox trusts, so Modal can add credentials the sandbox never sees.
+ */
+export interface OutboundPolicy {
+    readonly routes: ReadonlyArray<OutboundRoute>;
+    /**
+     * Let HTTPS routes decrypt traffic. Fixed at creation.
+     * @default true when a route is `https`
+     */
+    readonly tlsDecryption?: boolean;
+}
+/** Options for creating a sandbox: Modal's own sandbox parameters. */
+export interface SandboxCreateOptions {
+    /** Image to boot. Defaults to the binding's image, else `debian:bookworm-slim`. */
+    readonly image?: SandboxImage;
+    /**
+     * The sandbox's main process. Without one the sandbox idles (`sleep`) and
+     * you drive it with {@link SandboxHandle.exec}.
+     */
+    readonly command?: ReadonlyArray<string>;
+    /** Working directory of the main process and of exec'd commands. */
+    readonly workdir?: string;
+    /** Environment variables for the main process. */
+    readonly env?: Record<string, string>;
+    /** Secrets whose variables the sandbox sees as environment variables. */
+    readonly secrets?: ReadonlyArray<{
+        readonly secretId: string;
+    }>;
+    /**
+     * Volumes and cloud buckets to mount: volume handles, bucket names, or
+     * the references `Modal.MountVolume` / `Modal.MountBucket` return.
+     */
+    readonly mounts?: ReadonlyArray<SandboxMount>;
+    /** CPU cores (fractional allowed). */
+    readonly cpu?: number;
+    /** Memory in MiB. */
+    readonly memory?: number;
+    /** GPU: `"T4"`, `"A10G"`, `"A100-80GB"`, `"H100"`, with an optional `":<count>"`. */
+    readonly gpu?: string;
+    /** Ephemeral disk in MiB. */
+    readonly ephemeralDisk?: number;
+    /** Most time the sandbox lives. @default 5 minutes (Modal's default); at most 24 hours */
+    readonly timeout?: DurationInput;
+    /** Terminate after this long without exec'd commands or connections. */
+    readonly idleTimeout?: DurationInput;
+    /** Name, unique among the app's running sandboxes; find it again with `fromName`. */
+    readonly name?: string;
+    /** Tags, for `list({ tags })`. */
+    readonly tags?: Record<string, string>;
+    /** Regions to run in (`"us-east"`, `"eu"`, ...). */
+    readonly regions?: ReadonlyArray<string>;
+    /** Block all network access. */
+    readonly blockNetwork?: boolean;
+    /** Allow outbound traffic only to these CIDR ranges (and {@link allowedDomains}). */
+    readonly cidrAllowlist?: ReadonlyArray<string>;
+    /** Allow outbound traffic only to these domains (and {@link cidrAllowlist}). */
+    readonly allowedDomains?: ReadonlyArray<string>;
+    /** Allow inbound connections (tunnels) only from these CIDR ranges. */
+    readonly inboundCidrAllowlist?: ReadonlyArray<string>;
+    /** Outbound header injection: secrets the sandbox never sees. */
+    readonly outboundPolicy?: OutboundPolicy;
+    /** Route outbound traffic through a `Modal.Proxy`'s static IPs. */
+    readonly proxy?: {
+        readonly proxyId: string;
+    };
+    /**
+     * Give the sandbox a `MODAL_IDENTITY_TOKEN` environment variable: an OIDC
+     * token Modal signs, naming the workspace, environment, app and sandbox.
+     * A cloud that trusts Modal's issuer (`https://oidc.modal.com`) exchanges
+     * it for short-lived credentials, so no long-lived key enters the sandbox.
+     */
+    readonly includeOidcIdentityToken?: boolean;
+    /**
+     * Serve the sandbox an X.509 certificate that names it (an X.509-SVID),
+     * over the SPIFFE Workload API socket at `SPIFFE_ENDPOINT_SOCKET`. A
+     * cloud that trusts Modal's certificate authority (AWS IAM Roles
+     * Anywhere) exchanges it for short-lived credentials.
+     */
+    readonly includeX509Svid?: boolean;
+    /** Ports reachable through TLS tunnels (`sandbox.getTcpPort(port)`). */
+    readonly encryptedPorts?: ReadonlyArray<number>;
+    /** Ports reachable through plain TCP tunnels. */
+    readonly unencryptedPorts?: ReadonlyArray<number>;
+    /** Ports reachable through HTTP/2 tunnels. */
+    readonly h2Ports?: ReadonlyArray<number>;
+    /** Allow memory snapshots of this sandbox (`snapshotMemory`). */
+    readonly enableSnapshot?: boolean;
+    /** Serve tunnels on a custom domain registered with Modal. */
+    readonly customDomain?: string;
+}
+/** What a finished command printed, and its exit code. */
+export interface ExecResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+/** A command: a shell string (run with `sh -c`), or an argument vector (no shell). */
+export type Command = Sandbox.Command;
+/** Options for {@link SandboxHandleOf.exec}. */
+export interface ExecOptions {
+    /** Working directory. @default the sandbox's `workdir` */
+    readonly cwd?: string;
+    /** Extra environment variables for this command. */
+    readonly env?: Record<string, string>;
+    /** Secrets whose variables this command sees. */
+    readonly secrets?: ReadonlyArray<{
+        readonly secretId: string;
+    }>;
+    /** Kill the command after this long. */
+    readonly timeout?: DurationInput;
+    /** Bytes (or text) written to the command's stdin, then closed. */
+    readonly stdin?: string | Uint8Array;
+}
+/** A filesystem entry inside a sandbox. */
+export interface SandboxFileEntry {
+    readonly path: string;
+    readonly type: "file" | "directory" | "symlink" | "other";
+}
+/** What `files.stat` reports about a path. */
+export interface SandboxFileStat extends SandboxFileEntry {
+    /** Size in bytes. */
+    readonly size: number;
+    /** Last modification time. */
+    readonly modifiedAt: DateTime.Utc;
+}
+/** A tunnel to a port inside the sandbox. */
+export interface SandboxTunnel {
+    /** `https://…` (or `tcp://…` for unencrypted tunnels). */
+    readonly url: string;
+    readonly host: string;
+    readonly port: number;
+}
+/** The error of one of {@link SandboxOps}. */
+export type SandboxOpError<K extends keyof SandboxOps> = ErrorOf<SandboxOps[K]>;
+type RouterOpError<K extends keyof typeof routerOps> = Effect.Success<ReturnType<(typeof routerOps)[K]>> extends (...args: any[]) => infer Out ? Out extends Effect.Effect<any, infer E, any> ? E : Out extends Stream.Stream<any, infer E, any> ? E : never : never;
+/** Reaching a sandbox's task: it ended, or Modal's task lookup failed. */
+export type SandboxTaskError = SandboxNotRunning | SandboxUnexpectedResponse | SandboxOpError<"getTaskId"> | SandboxOpError<"getCommandRouterAccess">;
+/** Running a command in a sandbox. */
+export type SandboxExecError = SandboxTaskError | RouterOpError<"execStart" | "execStdinWrite" | "execStdioRead" | "execWait">;
+/** A started process: running it, following its output, writing its stdin, signalling it. */
+export type SandboxProcessError = SandboxExecError | RouterOpError<"execStdioFollow">;
+declare const SandboxPtyResizeUnsupported_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Modal.SandboxPtyResizeUnsupported";
+} & Readonly<A>;
+/** Modal's task command router has no call to resize a running PTY. */
+export declare class SandboxPtyResizeUnsupported extends SandboxPtyResizeUnsupported_base<{
+    readonly message: string;
+}> {
+}
+/** A terminal session's errors. */
+export type SandboxPtyError = SandboxProcessError | SandboxPtyResizeUnsupported;
+/** Options for `pty.open`: the terminal size, and what runs in it. */
+export interface SandboxPtyOptions extends Sandbox.PtyOptions {
+    /** Secrets whose variables the session sees. */
+    readonly secrets?: ReadonlyArray<{
+        readonly secretId: string;
+    }>;
+}
+/** A file operation inside a sandbox (it runs as a command). */
+export type SandboxFilesError = SandboxExecError | SandboxFilesystemError;
+/** Taking a snapshot or changing a running sandbox through its command router. */
+export type SandboxRouterError<K extends keyof typeof routerOps> = SandboxTaskError | RouterOpError<K>;
+/** The files inside a sandbox, read and written with commands its image has (`sh`, `base64`, `stat`). */
+export interface SandboxFilesOf<R> {
+    /** Read a file. */
+    read(path: string): Effect.Effect<Uint8Array, SandboxFilesError, R>;
+    /** Read a UTF-8 file. */
+    readText(path: string): Effect.Effect<string, SandboxFilesError, R>;
+    /** Write (create or truncate) a file, creating its directory. */
+    write(path: string, data: string | Uint8Array): Effect.Effect<void, SandboxFilesError, R>;
+    /** List a directory. */
+    list(path: string): Effect.Effect<ReadonlyArray<SandboxFileEntry>, SandboxFilesError, R>;
+    /** A path's type, size and modification time. */
+    stat(path: string): Effect.Effect<SandboxFileStat, SandboxFilesError, R>;
+    /** Remove a file, or a directory with `recursive`. */
+    remove(path: string, options?: {
+        readonly recursive?: boolean;
+    }): Effect.Effect<void, SandboxFilesError, R>;
+    /** Create a directory and its parents. */
+    makeDir(path: string): Effect.Effect<void, SandboxFilesError, R>;
+}
+/** A running (or finished) Modal sandbox. Every method calls Modal's API. */
+export interface SandboxHandleOf<R> {
+    readonly sandboxId: string;
+    /**
+     * Run a command and wait for it. A string runs with `sh -c`; an argument
+     * vector runs without a shell. A non-zero exit code is returned, not failed.
+     */
+    exec(command: Command, options?: ExecOptions): Effect.Effect<ExecResult, SandboxExecError, R>;
+    /**
+     * Start a command and follow it: its output streams as it runs, `write`
+     * feeds its stdin, `kill` signals it. Closing the scope detaches; the
+     * command keeps running.
+     */
+    start(command: Command, options?: ExecOptions): Effect.Effect<Sandbox.Process<SandboxProcessError>, SandboxProcessError, R | Scope.Scope>;
+    /**
+     * Terminals: `open` starts a login shell (or `command`) on a PTY of the
+     * given size. Modal can't resize a running PTY, so `resize` fails with
+     * {@link SandboxPtyResizeUnsupported}.
+     */
+    readonly pty: Sandbox.Pty<SandboxPtyError, SandboxPtyOptions>;
+    /** The sandbox's files. */
+    readonly files: SandboxFilesOf<R>;
+    /** Tunnels to the sandbox's open ports, by container port. */
+    tunnels(timeout?: DurationInput): Effect.Effect<Record<number, SandboxTunnel>, SandboxOpError<"getTunnels">, R>;
+    /**
+     * A token-authenticated URL for one port, for a browser or client that
+     * shouldn't hold Modal credentials.
+     */
+    connectToken(options?: {
+        readonly port?: number;
+        readonly userMetadata?: string;
+    }): Effect.Effect<{
+        readonly url: string;
+        readonly token: string;
+    }, SandboxOpError<"createConnectToken"> | SandboxUnexpectedResponse, R>;
+    /** Capture the filesystem as a new image (usable as `image` later). */
+    snapshotFilesystem(timeout?: DurationInput): Effect.Effect<{
+        readonly imageId: string;
+    }, SandboxRouterError<"snapshotFilesystem">, R>;
+    /** Capture memory and filesystem (needs `enableSnapshot`); restore with `restore`. */
+    snapshotMemory(): Effect.Effect<{
+        readonly snapshotId: string;
+    }, SandboxRouterError<"snapshotMemory">, R>;
+    /** Capture one directory as an image (mount it into another sandbox with `mountDirectory`). */
+    snapshotDirectory(path: string): Effect.Effect<{
+        readonly imageId: string;
+    }, SandboxRouterError<"snapshotDirectory">, R>;
+    /** Mount a directory snapshot at `path`. */
+    mountDirectory(path: string, snapshot: {
+        readonly imageId: string;
+    }): Effect.Effect<void, SandboxRouterError<"mountDirectory">, R>;
+    /**
+     * Replace the sandbox's outbound network policy while it runs. Connections
+     * the new policy no longer allows are closed. `{}` opens the network.
+     */
+    setNetworkAccess(access: {
+        readonly blockNetwork?: boolean;
+        readonly cidrAllowlist?: ReadonlyArray<string>;
+        readonly allowedDomains?: ReadonlyArray<string>;
+    }): Effect.Effect<void, SandboxRouterError<"setNetworkAccess">, R>;
+    /** Replace the outbound header injection rules while it runs. */
+    setOutboundPolicy(policy: OutboundPolicy): Effect.Effect<void, SandboxOpError<"setOutboundPolicy">, R>;
+    /** Replace the sandbox's tags. */
+    setTags(tags: Record<string, string>): Effect.Effect<void, SandboxOpError<"setTags">, R>;
+    /** The sandbox's tags. */
+    getTags(): Effect.Effect<Record<string, string>, SandboxOpError<"getTags">, R>;
+    /** Name the sandbox (unique among its app's running sandboxes) so `fromName` finds it. */
+    setName(name: string): Effect.Effect<void, SandboxOpError<"setName">, R>;
+    /** CPU, memory and GPU used so far (core-seconds, GiB-seconds, GPU-seconds). */
+    resourceUsage(): Effect.Effect<{
+        readonly cpuSeconds: number;
+        readonly memoryGibSeconds: number;
+        readonly gpuSeconds: number;
+    }, SandboxOpError<"getResourceUsage">, R>;
+    /**
+     * The main process's stdout so far: what the sandbox's command router sends
+     * within `timeout` (default 5 seconds), or all of it once the program has
+     * exited.
+     */
+    logs(options?: {
+        readonly timeout?: DurationInput;
+    }): Effect.Effect<string, SandboxRouterError<"mainStdio">, R>;
+    /** Wait for the sandbox to finish; `undefined` exit code while still running. */
+    wait(timeout?: DurationInput): Effect.Effect<{
+        readonly exitCode?: number;
+        readonly status: string;
+    }, SandboxOpError<"wait">, R>;
+    /** Terminate the sandbox (no-op when it already finished). */
+    terminate(): Effect.Effect<void, Exclude<SandboxOpError<"terminate">, {
+        readonly _tag: "SandboxNotFound";
+    }>, R>;
+    /**
+     * A port inside the sandbox, reached through its tunnel: `fetch` sends a
+     * client request there, or proxies a server request a handler received;
+     * `connect` opens a TCP socket to it. The port needs a tunnel
+     * (`encryptedPorts`, `unencryptedPorts` or `h2Ports`); without a port
+     * number, the `Modal.Sandbox` program's.
+     */
+    getTcpPort(port?: number): Effect.Effect<SandboxPortOf<R>, SandboxPortError, R>;
+}
+/** Looking up a sandbox port's tunnel. */
+export type SandboxPortError = SandboxOpError<"getTunnels"> | SandboxUnexpectedResponse;
+/**
+ * A port inside a sandbox, with the tunnel Modal opened to it. `fetch` keeps
+ * the request's method, path, query, headers and body, and sends it to the
+ * tunnel; given the server request a handler received, it proxies it and
+ * returns the server response.
+ */
+export interface SandboxPortOf<R> extends SandboxTunnel {
+    fetch(request: HttpClientRequest.HttpClientRequest): Effect.Effect<HttpClientResponse.HttpClientResponse, SandboxPortError | HttpClientError.HttpClientError, R>;
+    fetch(request: HttpServerRequest.HttpServerRequest): Effect.Effect<HttpServerResponse.HttpServerResponse, SandboxPortError | HttpClientError.HttpClientError, R>;
+    /**
+     * A TCP socket to the port through its tunnel: TLS for an encrypted tunnel
+     * (`encryptedPorts`), plain TCP for an unencrypted one (`unencryptedPorts`).
+     * It connects when run.
+     */
+    connect(): Effect.Effect<Socket.Socket>;
+}
+/** A sandbox port as bindings return it. */
+export type SandboxPort = SandboxPortOf<RuntimeContext>;
+/**
+ * A sandbox handle as bindings return it: calls run inside a deployed
+ * runtime. It has the shared `alchemy/Sandbox` shape plus Modal's own calls.
+ */
+export interface SandboxHandle extends SandboxHandleOf<RuntimeContext>, Sandbox.SandboxExec<SandboxExecError, ExecResult, ExecOptions>, Sandbox.SandboxProcesses<SandboxProcessError, ExecOptions>, Sandbox.SandboxFiles<SandboxFilesError, SandboxFileEntry>, Sandbox.SandboxPty<SandboxPtyError, SandboxPtyOptions>, Sandbox.SandboxPorts<SandboxPortError, SandboxPort> {
+    readonly files: SandboxFilesOf<RuntimeContext>;
+    getTcpPort(port?: number): Effect.Effect<SandboxPort, SandboxPortError, RuntimeContext>;
+}
+/** A sandbox handle whose calls need Modal credentials and an HTTP client. */
+export type RawSandboxHandle = SandboxHandleOf<never>;
+/** Where a sandbox client creates sandboxes. */
+export interface SandboxTarget {
+    readonly appId: string;
+    /** Environment of the app (for name lookups and tag updates). */
+    readonly environment?: string;
+    /** Name of the app (for name lookups). */
+    readonly appName?: string;
+    /** Image used when `create` names none. */
+    readonly imageId?: string;
+    /** A `Modal.Sandbox` program: the secret holding its env, its command, its port and mounts. */
+    readonly program?: {
+        readonly secretId: string;
+        readonly command: ReadonlyArray<string>;
+        readonly port: number;
+        readonly mounts?: ModalMounts;
+    };
+}
+/**
+ * The operations sandbox clients call, resolved once by
+ * `ModalBindings.withCredentials` (or at deploy, with the deployer's).
+ */
+export declare const SandboxOps: Effect.Effect<{
+    readonly create: (input: sandbox.SandboxCreateV2Request) => Effect.Effect<sandbox.SandboxCreateV2Response, sandbox.SandboxCreateV2Error, never>;
+    readonly getFromName: (input: sandbox.SandboxGetFromNameV2Request) => Effect.Effect<sandbox.SandboxGetFromNameV2Response, sandbox.SandboxGetFromNameV2Error, never>;
+    readonly list: (input: sandbox.SandboxListV2Request) => Effect.Effect<sandbox.SandboxListV2Response, persistent.ModalOpError, never>;
+    readonly restore: (input: sandbox.SandboxRestoreV2Request) => Effect.Effect<sandbox.SandboxRestoreV2Response, sandbox.SandboxRestoreV2Error, never>;
+    readonly getTaskId: (input: sandbox.SandboxGetTaskIdV2Request) => Effect.Effect<sandbox.SandboxGetTaskIdV2Response, sandbox.SandboxGetTaskIdV2Error, never>;
+    readonly getCommandRouterAccess: (input: sandbox.SandboxGetCommandRouterAccessRequest) => Effect.Effect<sandbox.SandboxGetCommandRouterAccessResponse, sandbox.SandboxGetCommandRouterAccessError, never>;
+    readonly getTunnels: (input: sandbox.SandboxGetTunnelsV2Request) => Effect.Effect<sandbox.SandboxGetTunnelsV2Response, sandbox.SandboxGetTunnelsV2Error, never>;
+    readonly createConnectToken: (input: sandbox.SandboxCreateConnectTokenV2Request) => Effect.Effect<sandbox.SandboxCreateConnectTokenV2Response, sandbox.SandboxCreateConnectTokenV2Error, never>;
+    readonly setOutboundPolicy: (input: sandbox.SandboxSetOutboundPolicyV2Request) => Effect.Effect<sandbox.SandboxSetOutboundPolicyV2Response, persistent.ModalOpError, never>;
+    readonly setTags: (input: sandbox.SandboxTagsSetV2Request) => Effect.Effect<sandbox.SandboxTagsSetV2Response, sandbox.SandboxTagsSetV2Error, never>;
+    readonly getTags: (input: sandbox.SandboxTagsGetV2Request) => Effect.Effect<sandbox.SandboxTagsGetV2Response, sandbox.SandboxTagsGetV2Error, never>;
+    readonly setName: (input: sandbox.SandboxSetNameRequest) => Effect.Effect<sandbox.SandboxSetNameResponse, sandbox.SandboxSetNameError, never>;
+    readonly getResourceUsage: (input: sandbox.SandboxGetResourceUsageRequest) => Effect.Effect<sandbox.SandboxGetResourceUsageResponse, sandbox.SandboxGetResourceUsageError, never>;
+    readonly wait: (input: sandbox.SandboxWaitV2Request) => Effect.Effect<sandbox.SandboxWaitV2Response, sandbox.SandboxWaitV2Error, never>;
+    readonly terminate: (input: sandbox.SandboxTerminateV2Request) => Effect.Effect<sandbox.SandboxTerminateV2Response, sandbox.SandboxTerminateV2Error, never>;
+    readonly usage: import("@distilled.cloud/core/api").PaginatedCall<sandbox.SandboxGetTimeRangeStatsRequest, sandbox.SandboxGetTimeRangeStatsResponse, persistent.ModalOpError, never, sandbox.SandboxStatsGroup>;
+    readonly createPersistent: (input: persistent.CreatePersistentSandboxRequest) => Effect.Effect<persistent.CreatePersistentSandboxResponse, persistent.CreatePersistentSandboxError, never>;
+    readonly getPersistent: (input: persistent.GetPersistentSandboxRequest) => Effect.Effect<persistent.GetPersistentSandboxResponse, persistent.GetPersistentSandboxError, never>;
+    readonly resumePersistent: (input: persistent.ResumePersistentSandboxRequest) => Effect.Effect<persistent.ResumePersistentSandboxResponse, persistent.ResumePersistentSandboxError, never>;
+    readonly terminatePersistent: (input: persistent.TerminatePersistentSandboxRequest) => Effect.Effect<persistent.TerminatePersistentSandboxResponse, persistent.TerminatePersistentSandboxError, never>;
+    readonly images: {
+        readonly getOrCreate: (input: import("@distilled.cloud/modal/image").ImageGetOrCreateRequest) => Effect.Effect<import("@distilled.cloud/modal/image").ImageGetOrCreateResponse, persistent.ModalOpError, never>;
+        readonly joinStreaming: import("@distilled.cloud/core/api").StreamingCall<import("@distilled.cloud/modal/image").ImageJoinStreamingRequest, import("@distilled.cloud/modal/image").ImageJoinStreamingStream, import("@distilled.cloud/modal/image").ImageJoinStreamingError, never, import("@distilled.cloud/modal/image").ImageJoinStreamingResponse>;
+        readonly putFile: (input: import("@distilled.cloud/modal/mount").MountPutFileRequest) => Effect.Effect<import("@distilled.cloud/modal/mount").MountPutFileResponse, persistent.ModalOpError, never>;
+        readonly getOrCreateMount: (input: import("@distilled.cloud/modal/mount").MountGetOrCreateRequest) => Effect.Effect<import("@distilled.cloud/modal/mount").MountGetOrCreateResponse, import("@distilled.cloud/modal/mount").MountGetOrCreateError, never>;
+        readonly blobs: {
+            readonly create: (input: import("@distilled.cloud/modal/blob").CreateBlobRequest) => Effect.Effect<import("@distilled.cloud/modal/blob").CreateBlobResponse, persistent.ModalOpError, never>;
+            readonly get: (input: import("@distilled.cloud/modal/blob").GetBlobRequest) => Effect.Effect<import("@distilled.cloud/modal/blob").GetBlobResponse, persistent.ModalOpError, never>;
+            readonly http: HttpClient.HttpClient;
+        };
+    };
+    readonly http: HttpClient.HttpClient;
+}, never, import("./internal.ts").OperationServices>;
+export type SandboxOps = Effect.Success<typeof SandboxOps>;
+/** Task command router operations, resolved per sandbox with its router access. */
+declare const routerOps: {
+    execStart: (access: import("./ModalBindings.ts").RouterAccess) => Effect.Effect<(input: router.TaskExecStartRequest) => Effect.Effect<router.TaskExecStartResponse, persistent.ModalOpError, never>, never, never>;
+    execStdinWrite: (access: import("./ModalBindings.ts").RouterAccess) => Effect.Effect<(input: router.TaskExecStdinWriteRequest) => Effect.Effect<router.TaskExecStdinWriteResponse, persistent.ModalOpError, never>, never, never>;
+    execStdioRead: (access: import("./ModalBindings.ts").RouterAccess) => Effect.Effect<(input: router.TaskExecStdioReadRequest) => Effect.Effect<router.TaskExecStdioReadStream, persistent.ModalOpError, never>, never, never>;
+    execWait: (access: import("./ModalBindings.ts").RouterAccess) => Effect.Effect<(input: router.TaskExecWaitRequest) => Effect.Effect<router.TaskExecWaitResponse, persistent.ModalOpError, never>, never, never>;
+    execStdioFollow: (access: import("./ModalBindings.ts").RouterAccess) => Effect.Effect<(input: router.TaskExecStdioReadRequest) => Stream.Stream<router.TaskExecStdioReadResponse, persistent.ModalOpError, never>, never, never>;
+    snapshotFilesystem: (access: import("./ModalBindings.ts").RouterAccess) => Effect.Effect<(input: router.TaskSnapshotFilesystemRequest) => Effect.Effect<router.TaskSnapshotFilesystemResponse, persistent.ModalOpError, never>, never, never>;
+    snapshotMemory: (access: import("./ModalBindings.ts").RouterAccess) => Effect.Effect<(input: router.TaskSnapshotMemoryRequest) => Effect.Effect<router.TaskSnapshotMemoryResponse, persistent.ModalOpError, never>, never, never>;
+    snapshotDirectory: (access: import("./ModalBindings.ts").RouterAccess) => Effect.Effect<(input: router.TaskSnapshotDirectoryRequest) => Effect.Effect<router.TaskSnapshotDirectoryResponse, persistent.ModalOpError, never>, never, never>;
+    mountDirectory: (access: import("./ModalBindings.ts").RouterAccess) => Effect.Effect<(input: router.TaskMountDirectoryRequest) => Effect.Effect<router.TaskMountDirectoryResponse, persistent.ModalOpError, never>, never, never>;
+    setNetworkAccess: (access: import("./ModalBindings.ts").RouterAccess) => Effect.Effect<(input: router.TaskSetNetworkAccessRequest) => Effect.Effect<router.TaskSetNetworkAccessResponse, persistent.ModalOpError, never>, never, never>;
+    mainStdio: (access: import("./ModalBindings.ts").RouterAccess) => Effect.Effect<(input: router.SandboxStdioReadV2Request) => Stream.Stream<router.SandboxStdioReadV2Response, persistent.ModalOpError, never>, never, never>;
+};
+/**
+ * The image to boot: a `Modal.Image`'s id, or a registry ref built (and
+ * cached by Modal) into an image in the target app.
+ */
+export declare const resolveSandboxImage: (ops: {
+    readonly create: (input: sandbox.SandboxCreateV2Request) => Effect.Effect<sandbox.SandboxCreateV2Response, sandbox.SandboxCreateV2Error, never>;
+    readonly getFromName: (input: sandbox.SandboxGetFromNameV2Request) => Effect.Effect<sandbox.SandboxGetFromNameV2Response, sandbox.SandboxGetFromNameV2Error, never>;
+    readonly list: (input: sandbox.SandboxListV2Request) => Effect.Effect<sandbox.SandboxListV2Response, persistent.ModalOpError, never>;
+    readonly restore: (input: sandbox.SandboxRestoreV2Request) => Effect.Effect<sandbox.SandboxRestoreV2Response, sandbox.SandboxRestoreV2Error, never>;
+    readonly getTaskId: (input: sandbox.SandboxGetTaskIdV2Request) => Effect.Effect<sandbox.SandboxGetTaskIdV2Response, sandbox.SandboxGetTaskIdV2Error, never>;
+    readonly getCommandRouterAccess: (input: sandbox.SandboxGetCommandRouterAccessRequest) => Effect.Effect<sandbox.SandboxGetCommandRouterAccessResponse, sandbox.SandboxGetCommandRouterAccessError, never>;
+    readonly getTunnels: (input: sandbox.SandboxGetTunnelsV2Request) => Effect.Effect<sandbox.SandboxGetTunnelsV2Response, sandbox.SandboxGetTunnelsV2Error, never>;
+    readonly createConnectToken: (input: sandbox.SandboxCreateConnectTokenV2Request) => Effect.Effect<sandbox.SandboxCreateConnectTokenV2Response, sandbox.SandboxCreateConnectTokenV2Error, never>;
+    readonly setOutboundPolicy: (input: sandbox.SandboxSetOutboundPolicyV2Request) => Effect.Effect<sandbox.SandboxSetOutboundPolicyV2Response, persistent.ModalOpError, never>;
+    readonly setTags: (input: sandbox.SandboxTagsSetV2Request) => Effect.Effect<sandbox.SandboxTagsSetV2Response, sandbox.SandboxTagsSetV2Error, never>;
+    readonly getTags: (input: sandbox.SandboxTagsGetV2Request) => Effect.Effect<sandbox.SandboxTagsGetV2Response, sandbox.SandboxTagsGetV2Error, never>;
+    readonly setName: (input: sandbox.SandboxSetNameRequest) => Effect.Effect<sandbox.SandboxSetNameResponse, sandbox.SandboxSetNameError, never>;
+    readonly getResourceUsage: (input: sandbox.SandboxGetResourceUsageRequest) => Effect.Effect<sandbox.SandboxGetResourceUsageResponse, sandbox.SandboxGetResourceUsageError, never>;
+    readonly wait: (input: sandbox.SandboxWaitV2Request) => Effect.Effect<sandbox.SandboxWaitV2Response, sandbox.SandboxWaitV2Error, never>;
+    readonly terminate: (input: sandbox.SandboxTerminateV2Request) => Effect.Effect<sandbox.SandboxTerminateV2Response, sandbox.SandboxTerminateV2Error, never>;
+    readonly usage: import("@distilled.cloud/core/api").PaginatedCall<sandbox.SandboxGetTimeRangeStatsRequest, sandbox.SandboxGetTimeRangeStatsResponse, persistent.ModalOpError, never, sandbox.SandboxStatsGroup>;
+    readonly createPersistent: (input: persistent.CreatePersistentSandboxRequest) => Effect.Effect<persistent.CreatePersistentSandboxResponse, persistent.CreatePersistentSandboxError, never>;
+    readonly getPersistent: (input: persistent.GetPersistentSandboxRequest) => Effect.Effect<persistent.GetPersistentSandboxResponse, persistent.GetPersistentSandboxError, never>;
+    readonly resumePersistent: (input: persistent.ResumePersistentSandboxRequest) => Effect.Effect<persistent.ResumePersistentSandboxResponse, persistent.ResumePersistentSandboxError, never>;
+    readonly terminatePersistent: (input: persistent.TerminatePersistentSandboxRequest) => Effect.Effect<persistent.TerminatePersistentSandboxResponse, persistent.TerminatePersistentSandboxError, never>;
+    readonly images: {
+        readonly getOrCreate: (input: import("@distilled.cloud/modal/image").ImageGetOrCreateRequest) => Effect.Effect<import("@distilled.cloud/modal/image").ImageGetOrCreateResponse, persistent.ModalOpError, never>;
+        readonly joinStreaming: import("@distilled.cloud/core/api").StreamingCall<import("@distilled.cloud/modal/image").ImageJoinStreamingRequest, import("@distilled.cloud/modal/image").ImageJoinStreamingStream, import("@distilled.cloud/modal/image").ImageJoinStreamingError, never, import("@distilled.cloud/modal/image").ImageJoinStreamingResponse>;
+        readonly putFile: (input: import("@distilled.cloud/modal/mount").MountPutFileRequest) => Effect.Effect<import("@distilled.cloud/modal/mount").MountPutFileResponse, persistent.ModalOpError, never>;
+        readonly getOrCreateMount: (input: import("@distilled.cloud/modal/mount").MountGetOrCreateRequest) => Effect.Effect<import("@distilled.cloud/modal/mount").MountGetOrCreateResponse, import("@distilled.cloud/modal/mount").MountGetOrCreateError, never>;
+        readonly blobs: {
+            readonly create: (input: import("@distilled.cloud/modal/blob").CreateBlobRequest) => Effect.Effect<import("@distilled.cloud/modal/blob").CreateBlobResponse, persistent.ModalOpError, never>;
+            readonly get: (input: import("@distilled.cloud/modal/blob").GetBlobRequest) => Effect.Effect<import("@distilled.cloud/modal/blob").GetBlobResponse, persistent.ModalOpError, never>;
+            readonly http: HttpClient.HttpClient;
+        };
+    };
+    readonly http: HttpClient.HttpClient;
+}, target: SandboxTarget, image: SandboxImage | undefined) => Effect.Effect<string, import("@distilled.cloud/core/errors").BadGateway | import("./Blob.ts").BlobTransferFailed | import("@distilled.cloud/core/config").ConfigError | import("@distilled.cloud/core/errors").GatewayTimeout | HttpClientError.HttpClientError | import("./ImageBuild.ts").ImageBuildFailed | import("./ImageBuild.ts").ImageBuildTimeout | import("./ImageBuild.ts").ImageBuildUnexpectedResponse | import("@distilled.cloud/modal/image").ImageNotFound | import("@distilled.cloud/core/errors").InternalServerError | import("@distilled.cloud/core/protocol-http").InvalidInput | import("@distilled.cloud/modal/Errors").ModalParseError | import("@distilled.cloud/modal/mount").MountNotFound | import("@distilled.cloud/core/sdk-error").SdkError | import("@distilled.cloud/core/errors").ServiceUnavailable | import("@distilled.cloud/core/errors").TooManyRequests | import("@distilled.cloud/core/errors").Unauthorized | import("@distilled.cloud/modal/Errors").UnknownModalError, never>;
+/** The handle for an existing sandbox id. */
+export declare const sandboxHandle: (ops: SandboxOps, sandboxId: string, target: Pick<SandboxTarget, "environment" | "program">) => RawSandboxHandle;
+/**
+ * Create a sandbox in `target`'s app and return its handle. The one
+ * implementation behind `CreateSandbox` and warm-base image builds.
+ */
+export declare const createSandbox: (ops: {
+    readonly create: (input: sandbox.SandboxCreateV2Request) => Effect.Effect<sandbox.SandboxCreateV2Response, sandbox.SandboxCreateV2Error, never>;
+    readonly getFromName: (input: sandbox.SandboxGetFromNameV2Request) => Effect.Effect<sandbox.SandboxGetFromNameV2Response, sandbox.SandboxGetFromNameV2Error, never>;
+    readonly list: (input: sandbox.SandboxListV2Request) => Effect.Effect<sandbox.SandboxListV2Response, persistent.ModalOpError, never>;
+    readonly restore: (input: sandbox.SandboxRestoreV2Request) => Effect.Effect<sandbox.SandboxRestoreV2Response, sandbox.SandboxRestoreV2Error, never>;
+    readonly getTaskId: (input: sandbox.SandboxGetTaskIdV2Request) => Effect.Effect<sandbox.SandboxGetTaskIdV2Response, sandbox.SandboxGetTaskIdV2Error, never>;
+    readonly getCommandRouterAccess: (input: sandbox.SandboxGetCommandRouterAccessRequest) => Effect.Effect<sandbox.SandboxGetCommandRouterAccessResponse, sandbox.SandboxGetCommandRouterAccessError, never>;
+    readonly getTunnels: (input: sandbox.SandboxGetTunnelsV2Request) => Effect.Effect<sandbox.SandboxGetTunnelsV2Response, sandbox.SandboxGetTunnelsV2Error, never>;
+    readonly createConnectToken: (input: sandbox.SandboxCreateConnectTokenV2Request) => Effect.Effect<sandbox.SandboxCreateConnectTokenV2Response, sandbox.SandboxCreateConnectTokenV2Error, never>;
+    readonly setOutboundPolicy: (input: sandbox.SandboxSetOutboundPolicyV2Request) => Effect.Effect<sandbox.SandboxSetOutboundPolicyV2Response, persistent.ModalOpError, never>;
+    readonly setTags: (input: sandbox.SandboxTagsSetV2Request) => Effect.Effect<sandbox.SandboxTagsSetV2Response, sandbox.SandboxTagsSetV2Error, never>;
+    readonly getTags: (input: sandbox.SandboxTagsGetV2Request) => Effect.Effect<sandbox.SandboxTagsGetV2Response, sandbox.SandboxTagsGetV2Error, never>;
+    readonly setName: (input: sandbox.SandboxSetNameRequest) => Effect.Effect<sandbox.SandboxSetNameResponse, sandbox.SandboxSetNameError, never>;
+    readonly getResourceUsage: (input: sandbox.SandboxGetResourceUsageRequest) => Effect.Effect<sandbox.SandboxGetResourceUsageResponse, sandbox.SandboxGetResourceUsageError, never>;
+    readonly wait: (input: sandbox.SandboxWaitV2Request) => Effect.Effect<sandbox.SandboxWaitV2Response, sandbox.SandboxWaitV2Error, never>;
+    readonly terminate: (input: sandbox.SandboxTerminateV2Request) => Effect.Effect<sandbox.SandboxTerminateV2Response, sandbox.SandboxTerminateV2Error, never>;
+    readonly usage: import("@distilled.cloud/core/api").PaginatedCall<sandbox.SandboxGetTimeRangeStatsRequest, sandbox.SandboxGetTimeRangeStatsResponse, persistent.ModalOpError, never, sandbox.SandboxStatsGroup>;
+    readonly createPersistent: (input: persistent.CreatePersistentSandboxRequest) => Effect.Effect<persistent.CreatePersistentSandboxResponse, persistent.CreatePersistentSandboxError, never>;
+    readonly getPersistent: (input: persistent.GetPersistentSandboxRequest) => Effect.Effect<persistent.GetPersistentSandboxResponse, persistent.GetPersistentSandboxError, never>;
+    readonly resumePersistent: (input: persistent.ResumePersistentSandboxRequest) => Effect.Effect<persistent.ResumePersistentSandboxResponse, persistent.ResumePersistentSandboxError, never>;
+    readonly terminatePersistent: (input: persistent.TerminatePersistentSandboxRequest) => Effect.Effect<persistent.TerminatePersistentSandboxResponse, persistent.TerminatePersistentSandboxError, never>;
+    readonly images: {
+        readonly getOrCreate: (input: import("@distilled.cloud/modal/image").ImageGetOrCreateRequest) => Effect.Effect<import("@distilled.cloud/modal/image").ImageGetOrCreateResponse, persistent.ModalOpError, never>;
+        readonly joinStreaming: import("@distilled.cloud/core/api").StreamingCall<import("@distilled.cloud/modal/image").ImageJoinStreamingRequest, import("@distilled.cloud/modal/image").ImageJoinStreamingStream, import("@distilled.cloud/modal/image").ImageJoinStreamingError, never, import("@distilled.cloud/modal/image").ImageJoinStreamingResponse>;
+        readonly putFile: (input: import("@distilled.cloud/modal/mount").MountPutFileRequest) => Effect.Effect<import("@distilled.cloud/modal/mount").MountPutFileResponse, persistent.ModalOpError, never>;
+        readonly getOrCreateMount: (input: import("@distilled.cloud/modal/mount").MountGetOrCreateRequest) => Effect.Effect<import("@distilled.cloud/modal/mount").MountGetOrCreateResponse, import("@distilled.cloud/modal/mount").MountGetOrCreateError, never>;
+        readonly blobs: {
+            readonly create: (input: import("@distilled.cloud/modal/blob").CreateBlobRequest) => Effect.Effect<import("@distilled.cloud/modal/blob").CreateBlobResponse, persistent.ModalOpError, never>;
+            readonly get: (input: import("@distilled.cloud/modal/blob").GetBlobRequest) => Effect.Effect<import("@distilled.cloud/modal/blob").GetBlobResponse, persistent.ModalOpError, never>;
+            readonly http: HttpClient.HttpClient;
+        };
+    };
+    readonly http: HttpClient.HttpClient;
+}, target: SandboxTarget, options?: SandboxCreateOptions | undefined) => Effect.Effect<RawSandboxHandle, import("./Blob.ts").BlobTransferFailed | import("./ImageBuild.ts").ImageBuildFailed | import("./ImageBuild.ts").ImageBuildTimeout | import("./ImageBuild.ts").ImageBuildUnexpectedResponse | import("@distilled.cloud/modal/image").ImageNotFound | import("./Mounts.ts").MountNotBound | import("@distilled.cloud/modal/mount").MountNotFound | SandboxUnexpectedResponse | sandbox.SandboxCreateV2Error, never>;
+/** A running sandbox of `target`'s app by name, or `undefined`. */
+export declare const sandboxFromName: (ops: {
+    readonly create: (input: sandbox.SandboxCreateV2Request) => Effect.Effect<sandbox.SandboxCreateV2Response, sandbox.SandboxCreateV2Error, never>;
+    readonly getFromName: (input: sandbox.SandboxGetFromNameV2Request) => Effect.Effect<sandbox.SandboxGetFromNameV2Response, sandbox.SandboxGetFromNameV2Error, never>;
+    readonly list: (input: sandbox.SandboxListV2Request) => Effect.Effect<sandbox.SandboxListV2Response, persistent.ModalOpError, never>;
+    readonly restore: (input: sandbox.SandboxRestoreV2Request) => Effect.Effect<sandbox.SandboxRestoreV2Response, sandbox.SandboxRestoreV2Error, never>;
+    readonly getTaskId: (input: sandbox.SandboxGetTaskIdV2Request) => Effect.Effect<sandbox.SandboxGetTaskIdV2Response, sandbox.SandboxGetTaskIdV2Error, never>;
+    readonly getCommandRouterAccess: (input: sandbox.SandboxGetCommandRouterAccessRequest) => Effect.Effect<sandbox.SandboxGetCommandRouterAccessResponse, sandbox.SandboxGetCommandRouterAccessError, never>;
+    readonly getTunnels: (input: sandbox.SandboxGetTunnelsV2Request) => Effect.Effect<sandbox.SandboxGetTunnelsV2Response, sandbox.SandboxGetTunnelsV2Error, never>;
+    readonly createConnectToken: (input: sandbox.SandboxCreateConnectTokenV2Request) => Effect.Effect<sandbox.SandboxCreateConnectTokenV2Response, sandbox.SandboxCreateConnectTokenV2Error, never>;
+    readonly setOutboundPolicy: (input: sandbox.SandboxSetOutboundPolicyV2Request) => Effect.Effect<sandbox.SandboxSetOutboundPolicyV2Response, persistent.ModalOpError, never>;
+    readonly setTags: (input: sandbox.SandboxTagsSetV2Request) => Effect.Effect<sandbox.SandboxTagsSetV2Response, sandbox.SandboxTagsSetV2Error, never>;
+    readonly getTags: (input: sandbox.SandboxTagsGetV2Request) => Effect.Effect<sandbox.SandboxTagsGetV2Response, sandbox.SandboxTagsGetV2Error, never>;
+    readonly setName: (input: sandbox.SandboxSetNameRequest) => Effect.Effect<sandbox.SandboxSetNameResponse, sandbox.SandboxSetNameError, never>;
+    readonly getResourceUsage: (input: sandbox.SandboxGetResourceUsageRequest) => Effect.Effect<sandbox.SandboxGetResourceUsageResponse, sandbox.SandboxGetResourceUsageError, never>;
+    readonly wait: (input: sandbox.SandboxWaitV2Request) => Effect.Effect<sandbox.SandboxWaitV2Response, sandbox.SandboxWaitV2Error, never>;
+    readonly terminate: (input: sandbox.SandboxTerminateV2Request) => Effect.Effect<sandbox.SandboxTerminateV2Response, sandbox.SandboxTerminateV2Error, never>;
+    readonly usage: import("@distilled.cloud/core/api").PaginatedCall<sandbox.SandboxGetTimeRangeStatsRequest, sandbox.SandboxGetTimeRangeStatsResponse, persistent.ModalOpError, never, sandbox.SandboxStatsGroup>;
+    readonly createPersistent: (input: persistent.CreatePersistentSandboxRequest) => Effect.Effect<persistent.CreatePersistentSandboxResponse, persistent.CreatePersistentSandboxError, never>;
+    readonly getPersistent: (input: persistent.GetPersistentSandboxRequest) => Effect.Effect<persistent.GetPersistentSandboxResponse, persistent.GetPersistentSandboxError, never>;
+    readonly resumePersistent: (input: persistent.ResumePersistentSandboxRequest) => Effect.Effect<persistent.ResumePersistentSandboxResponse, persistent.ResumePersistentSandboxError, never>;
+    readonly terminatePersistent: (input: persistent.TerminatePersistentSandboxRequest) => Effect.Effect<persistent.TerminatePersistentSandboxResponse, persistent.TerminatePersistentSandboxError, never>;
+    readonly images: {
+        readonly getOrCreate: (input: import("@distilled.cloud/modal/image").ImageGetOrCreateRequest) => Effect.Effect<import("@distilled.cloud/modal/image").ImageGetOrCreateResponse, persistent.ModalOpError, never>;
+        readonly joinStreaming: import("@distilled.cloud/core/api").StreamingCall<import("@distilled.cloud/modal/image").ImageJoinStreamingRequest, import("@distilled.cloud/modal/image").ImageJoinStreamingStream, import("@distilled.cloud/modal/image").ImageJoinStreamingError, never, import("@distilled.cloud/modal/image").ImageJoinStreamingResponse>;
+        readonly putFile: (input: import("@distilled.cloud/modal/mount").MountPutFileRequest) => Effect.Effect<import("@distilled.cloud/modal/mount").MountPutFileResponse, persistent.ModalOpError, never>;
+        readonly getOrCreateMount: (input: import("@distilled.cloud/modal/mount").MountGetOrCreateRequest) => Effect.Effect<import("@distilled.cloud/modal/mount").MountGetOrCreateResponse, import("@distilled.cloud/modal/mount").MountGetOrCreateError, never>;
+        readonly blobs: {
+            readonly create: (input: import("@distilled.cloud/modal/blob").CreateBlobRequest) => Effect.Effect<import("@distilled.cloud/modal/blob").CreateBlobResponse, persistent.ModalOpError, never>;
+            readonly get: (input: import("@distilled.cloud/modal/blob").GetBlobRequest) => Effect.Effect<import("@distilled.cloud/modal/blob").GetBlobResponse, persistent.ModalOpError, never>;
+            readonly http: HttpClient.HttpClient;
+        };
+    };
+    readonly http: HttpClient.HttpClient;
+}, target: SandboxTarget, name: string) => Effect.Effect<RawSandboxHandle | undefined, persistent.ModalOpError, never>;
+/** Running sandboxes of `target`'s app, optionally filtered by tags. */
+export declare const listSandboxes: (ops: {
+    readonly create: (input: sandbox.SandboxCreateV2Request) => Effect.Effect<sandbox.SandboxCreateV2Response, sandbox.SandboxCreateV2Error, never>;
+    readonly getFromName: (input: sandbox.SandboxGetFromNameV2Request) => Effect.Effect<sandbox.SandboxGetFromNameV2Response, sandbox.SandboxGetFromNameV2Error, never>;
+    readonly list: (input: sandbox.SandboxListV2Request) => Effect.Effect<sandbox.SandboxListV2Response, persistent.ModalOpError, never>;
+    readonly restore: (input: sandbox.SandboxRestoreV2Request) => Effect.Effect<sandbox.SandboxRestoreV2Response, sandbox.SandboxRestoreV2Error, never>;
+    readonly getTaskId: (input: sandbox.SandboxGetTaskIdV2Request) => Effect.Effect<sandbox.SandboxGetTaskIdV2Response, sandbox.SandboxGetTaskIdV2Error, never>;
+    readonly getCommandRouterAccess: (input: sandbox.SandboxGetCommandRouterAccessRequest) => Effect.Effect<sandbox.SandboxGetCommandRouterAccessResponse, sandbox.SandboxGetCommandRouterAccessError, never>;
+    readonly getTunnels: (input: sandbox.SandboxGetTunnelsV2Request) => Effect.Effect<sandbox.SandboxGetTunnelsV2Response, sandbox.SandboxGetTunnelsV2Error, never>;
+    readonly createConnectToken: (input: sandbox.SandboxCreateConnectTokenV2Request) => Effect.Effect<sandbox.SandboxCreateConnectTokenV2Response, sandbox.SandboxCreateConnectTokenV2Error, never>;
+    readonly setOutboundPolicy: (input: sandbox.SandboxSetOutboundPolicyV2Request) => Effect.Effect<sandbox.SandboxSetOutboundPolicyV2Response, persistent.ModalOpError, never>;
+    readonly setTags: (input: sandbox.SandboxTagsSetV2Request) => Effect.Effect<sandbox.SandboxTagsSetV2Response, sandbox.SandboxTagsSetV2Error, never>;
+    readonly getTags: (input: sandbox.SandboxTagsGetV2Request) => Effect.Effect<sandbox.SandboxTagsGetV2Response, sandbox.SandboxTagsGetV2Error, never>;
+    readonly setName: (input: sandbox.SandboxSetNameRequest) => Effect.Effect<sandbox.SandboxSetNameResponse, sandbox.SandboxSetNameError, never>;
+    readonly getResourceUsage: (input: sandbox.SandboxGetResourceUsageRequest) => Effect.Effect<sandbox.SandboxGetResourceUsageResponse, sandbox.SandboxGetResourceUsageError, never>;
+    readonly wait: (input: sandbox.SandboxWaitV2Request) => Effect.Effect<sandbox.SandboxWaitV2Response, sandbox.SandboxWaitV2Error, never>;
+    readonly terminate: (input: sandbox.SandboxTerminateV2Request) => Effect.Effect<sandbox.SandboxTerminateV2Response, sandbox.SandboxTerminateV2Error, never>;
+    readonly usage: import("@distilled.cloud/core/api").PaginatedCall<sandbox.SandboxGetTimeRangeStatsRequest, sandbox.SandboxGetTimeRangeStatsResponse, persistent.ModalOpError, never, sandbox.SandboxStatsGroup>;
+    readonly createPersistent: (input: persistent.CreatePersistentSandboxRequest) => Effect.Effect<persistent.CreatePersistentSandboxResponse, persistent.CreatePersistentSandboxError, never>;
+    readonly getPersistent: (input: persistent.GetPersistentSandboxRequest) => Effect.Effect<persistent.GetPersistentSandboxResponse, persistent.GetPersistentSandboxError, never>;
+    readonly resumePersistent: (input: persistent.ResumePersistentSandboxRequest) => Effect.Effect<persistent.ResumePersistentSandboxResponse, persistent.ResumePersistentSandboxError, never>;
+    readonly terminatePersistent: (input: persistent.TerminatePersistentSandboxRequest) => Effect.Effect<persistent.TerminatePersistentSandboxResponse, persistent.TerminatePersistentSandboxError, never>;
+    readonly images: {
+        readonly getOrCreate: (input: import("@distilled.cloud/modal/image").ImageGetOrCreateRequest) => Effect.Effect<import("@distilled.cloud/modal/image").ImageGetOrCreateResponse, persistent.ModalOpError, never>;
+        readonly joinStreaming: import("@distilled.cloud/core/api").StreamingCall<import("@distilled.cloud/modal/image").ImageJoinStreamingRequest, import("@distilled.cloud/modal/image").ImageJoinStreamingStream, import("@distilled.cloud/modal/image").ImageJoinStreamingError, never, import("@distilled.cloud/modal/image").ImageJoinStreamingResponse>;
+        readonly putFile: (input: import("@distilled.cloud/modal/mount").MountPutFileRequest) => Effect.Effect<import("@distilled.cloud/modal/mount").MountPutFileResponse, persistent.ModalOpError, never>;
+        readonly getOrCreateMount: (input: import("@distilled.cloud/modal/mount").MountGetOrCreateRequest) => Effect.Effect<import("@distilled.cloud/modal/mount").MountGetOrCreateResponse, import("@distilled.cloud/modal/mount").MountGetOrCreateError, never>;
+        readonly blobs: {
+            readonly create: (input: import("@distilled.cloud/modal/blob").CreateBlobRequest) => Effect.Effect<import("@distilled.cloud/modal/blob").CreateBlobResponse, persistent.ModalOpError, never>;
+            readonly get: (input: import("@distilled.cloud/modal/blob").GetBlobRequest) => Effect.Effect<import("@distilled.cloud/modal/blob").GetBlobResponse, persistent.ModalOpError, never>;
+            readonly http: HttpClient.HttpClient;
+        };
+    };
+    readonly http: HttpClient.HttpClient;
+}, target: SandboxTarget, options?: {
+    readonly tags?: Record<string, string>;
+    readonly includeFinished?: boolean;
+} | undefined) => Effect.Effect<{
+    sandboxId: string;
+    name: string | undefined;
+    createdAt: number;
+    tags: {
+        [k: string]: string;
+    };
+}[], persistent.ModalOpError, never>;
+/** Restore a memory snapshot into a new sandbox. */
+export declare const restoreSandbox: (ops: {
+    readonly create: (input: sandbox.SandboxCreateV2Request) => Effect.Effect<sandbox.SandboxCreateV2Response, sandbox.SandboxCreateV2Error, never>;
+    readonly getFromName: (input: sandbox.SandboxGetFromNameV2Request) => Effect.Effect<sandbox.SandboxGetFromNameV2Response, sandbox.SandboxGetFromNameV2Error, never>;
+    readonly list: (input: sandbox.SandboxListV2Request) => Effect.Effect<sandbox.SandboxListV2Response, persistent.ModalOpError, never>;
+    readonly restore: (input: sandbox.SandboxRestoreV2Request) => Effect.Effect<sandbox.SandboxRestoreV2Response, sandbox.SandboxRestoreV2Error, never>;
+    readonly getTaskId: (input: sandbox.SandboxGetTaskIdV2Request) => Effect.Effect<sandbox.SandboxGetTaskIdV2Response, sandbox.SandboxGetTaskIdV2Error, never>;
+    readonly getCommandRouterAccess: (input: sandbox.SandboxGetCommandRouterAccessRequest) => Effect.Effect<sandbox.SandboxGetCommandRouterAccessResponse, sandbox.SandboxGetCommandRouterAccessError, never>;
+    readonly getTunnels: (input: sandbox.SandboxGetTunnelsV2Request) => Effect.Effect<sandbox.SandboxGetTunnelsV2Response, sandbox.SandboxGetTunnelsV2Error, never>;
+    readonly createConnectToken: (input: sandbox.SandboxCreateConnectTokenV2Request) => Effect.Effect<sandbox.SandboxCreateConnectTokenV2Response, sandbox.SandboxCreateConnectTokenV2Error, never>;
+    readonly setOutboundPolicy: (input: sandbox.SandboxSetOutboundPolicyV2Request) => Effect.Effect<sandbox.SandboxSetOutboundPolicyV2Response, persistent.ModalOpError, never>;
+    readonly setTags: (input: sandbox.SandboxTagsSetV2Request) => Effect.Effect<sandbox.SandboxTagsSetV2Response, sandbox.SandboxTagsSetV2Error, never>;
+    readonly getTags: (input: sandbox.SandboxTagsGetV2Request) => Effect.Effect<sandbox.SandboxTagsGetV2Response, sandbox.SandboxTagsGetV2Error, never>;
+    readonly setName: (input: sandbox.SandboxSetNameRequest) => Effect.Effect<sandbox.SandboxSetNameResponse, sandbox.SandboxSetNameError, never>;
+    readonly getResourceUsage: (input: sandbox.SandboxGetResourceUsageRequest) => Effect.Effect<sandbox.SandboxGetResourceUsageResponse, sandbox.SandboxGetResourceUsageError, never>;
+    readonly wait: (input: sandbox.SandboxWaitV2Request) => Effect.Effect<sandbox.SandboxWaitV2Response, sandbox.SandboxWaitV2Error, never>;
+    readonly terminate: (input: sandbox.SandboxTerminateV2Request) => Effect.Effect<sandbox.SandboxTerminateV2Response, sandbox.SandboxTerminateV2Error, never>;
+    readonly usage: import("@distilled.cloud/core/api").PaginatedCall<sandbox.SandboxGetTimeRangeStatsRequest, sandbox.SandboxGetTimeRangeStatsResponse, persistent.ModalOpError, never, sandbox.SandboxStatsGroup>;
+    readonly createPersistent: (input: persistent.CreatePersistentSandboxRequest) => Effect.Effect<persistent.CreatePersistentSandboxResponse, persistent.CreatePersistentSandboxError, never>;
+    readonly getPersistent: (input: persistent.GetPersistentSandboxRequest) => Effect.Effect<persistent.GetPersistentSandboxResponse, persistent.GetPersistentSandboxError, never>;
+    readonly resumePersistent: (input: persistent.ResumePersistentSandboxRequest) => Effect.Effect<persistent.ResumePersistentSandboxResponse, persistent.ResumePersistentSandboxError, never>;
+    readonly terminatePersistent: (input: persistent.TerminatePersistentSandboxRequest) => Effect.Effect<persistent.TerminatePersistentSandboxResponse, persistent.TerminatePersistentSandboxError, never>;
+    readonly images: {
+        readonly getOrCreate: (input: import("@distilled.cloud/modal/image").ImageGetOrCreateRequest) => Effect.Effect<import("@distilled.cloud/modal/image").ImageGetOrCreateResponse, persistent.ModalOpError, never>;
+        readonly joinStreaming: import("@distilled.cloud/core/api").StreamingCall<import("@distilled.cloud/modal/image").ImageJoinStreamingRequest, import("@distilled.cloud/modal/image").ImageJoinStreamingStream, import("@distilled.cloud/modal/image").ImageJoinStreamingError, never, import("@distilled.cloud/modal/image").ImageJoinStreamingResponse>;
+        readonly putFile: (input: import("@distilled.cloud/modal/mount").MountPutFileRequest) => Effect.Effect<import("@distilled.cloud/modal/mount").MountPutFileResponse, persistent.ModalOpError, never>;
+        readonly getOrCreateMount: (input: import("@distilled.cloud/modal/mount").MountGetOrCreateRequest) => Effect.Effect<import("@distilled.cloud/modal/mount").MountGetOrCreateResponse, import("@distilled.cloud/modal/mount").MountGetOrCreateError, never>;
+        readonly blobs: {
+            readonly create: (input: import("@distilled.cloud/modal/blob").CreateBlobRequest) => Effect.Effect<import("@distilled.cloud/modal/blob").CreateBlobResponse, persistent.ModalOpError, never>;
+            readonly get: (input: import("@distilled.cloud/modal/blob").GetBlobRequest) => Effect.Effect<import("@distilled.cloud/modal/blob").GetBlobResponse, persistent.ModalOpError, never>;
+            readonly http: HttpClient.HttpClient;
+        };
+    };
+    readonly http: HttpClient.HttpClient;
+}, target: SandboxTarget, snapshot: {
+    readonly snapshotId: string;
+}, options?: {
+    readonly name?: string;
+} | undefined) => Effect.Effect<RawSandboxHandle, SandboxUnexpectedResponse | sandbox.SandboxRestoreV2Error, never>;
+/**
+ * Options for a persistent sandbox. Modal fixes each session's lifetime (an
+ * hour, paused after five idle minutes) and doesn't support names, GPUs,
+ * `env`, tags or memory snapshots on persistent sandboxes yet.
+ */
+export type PersistentSandboxCreateOptions = Omit<SandboxCreateOptions, "timeout" | "idleTimeout" | "name" | "gpu" | "env" | "tags" | "enableSnapshot">;
+/** A persistent sandbox: one box whose filesystem outlives its sessions. */
+export interface PersistentSandboxHandleOf<R> {
+    readonly persistentSandboxId: string;
+    /**
+     * The running session, resuming the box from its last session's
+     * filesystem when it's paused.
+     */
+    session(): Effect.Effect<SandboxHandleOf<R>, SandboxOpError<"getPersistent"> | SandboxOpError<"resumePersistent"> | SandboxUnexpectedResponse, R>;
+    /** Terminate the box for good. */
+    terminate(): Effect.Effect<void, Exclude<SandboxOpError<"terminatePersistent">, {
+        readonly _tag: "PersistentSandboxNotFound";
+    }>, R>;
+}
+export type RawPersistentSandboxHandle = PersistentSandboxHandleOf<never>;
+export type PersistentSandboxHandle = PersistentSandboxHandleOf<RuntimeContext>;
+/** The handle for an existing persistent sandbox id. */
+export declare const persistentSandboxHandle: (ops: SandboxOps, persistentSandboxId: string, target: Pick<SandboxTarget, "environment" | "program">) => RawPersistentSandboxHandle;
+/** Create a persistent sandbox in `target`'s app. */
+export declare const createPersistentSandbox: (ops: {
+    readonly create: (input: sandbox.SandboxCreateV2Request) => Effect.Effect<sandbox.SandboxCreateV2Response, sandbox.SandboxCreateV2Error, never>;
+    readonly getFromName: (input: sandbox.SandboxGetFromNameV2Request) => Effect.Effect<sandbox.SandboxGetFromNameV2Response, sandbox.SandboxGetFromNameV2Error, never>;
+    readonly list: (input: sandbox.SandboxListV2Request) => Effect.Effect<sandbox.SandboxListV2Response, persistent.ModalOpError, never>;
+    readonly restore: (input: sandbox.SandboxRestoreV2Request) => Effect.Effect<sandbox.SandboxRestoreV2Response, sandbox.SandboxRestoreV2Error, never>;
+    readonly getTaskId: (input: sandbox.SandboxGetTaskIdV2Request) => Effect.Effect<sandbox.SandboxGetTaskIdV2Response, sandbox.SandboxGetTaskIdV2Error, never>;
+    readonly getCommandRouterAccess: (input: sandbox.SandboxGetCommandRouterAccessRequest) => Effect.Effect<sandbox.SandboxGetCommandRouterAccessResponse, sandbox.SandboxGetCommandRouterAccessError, never>;
+    readonly getTunnels: (input: sandbox.SandboxGetTunnelsV2Request) => Effect.Effect<sandbox.SandboxGetTunnelsV2Response, sandbox.SandboxGetTunnelsV2Error, never>;
+    readonly createConnectToken: (input: sandbox.SandboxCreateConnectTokenV2Request) => Effect.Effect<sandbox.SandboxCreateConnectTokenV2Response, sandbox.SandboxCreateConnectTokenV2Error, never>;
+    readonly setOutboundPolicy: (input: sandbox.SandboxSetOutboundPolicyV2Request) => Effect.Effect<sandbox.SandboxSetOutboundPolicyV2Response, persistent.ModalOpError, never>;
+    readonly setTags: (input: sandbox.SandboxTagsSetV2Request) => Effect.Effect<sandbox.SandboxTagsSetV2Response, sandbox.SandboxTagsSetV2Error, never>;
+    readonly getTags: (input: sandbox.SandboxTagsGetV2Request) => Effect.Effect<sandbox.SandboxTagsGetV2Response, sandbox.SandboxTagsGetV2Error, never>;
+    readonly setName: (input: sandbox.SandboxSetNameRequest) => Effect.Effect<sandbox.SandboxSetNameResponse, sandbox.SandboxSetNameError, never>;
+    readonly getResourceUsage: (input: sandbox.SandboxGetResourceUsageRequest) => Effect.Effect<sandbox.SandboxGetResourceUsageResponse, sandbox.SandboxGetResourceUsageError, never>;
+    readonly wait: (input: sandbox.SandboxWaitV2Request) => Effect.Effect<sandbox.SandboxWaitV2Response, sandbox.SandboxWaitV2Error, never>;
+    readonly terminate: (input: sandbox.SandboxTerminateV2Request) => Effect.Effect<sandbox.SandboxTerminateV2Response, sandbox.SandboxTerminateV2Error, never>;
+    readonly usage: import("@distilled.cloud/core/api").PaginatedCall<sandbox.SandboxGetTimeRangeStatsRequest, sandbox.SandboxGetTimeRangeStatsResponse, persistent.ModalOpError, never, sandbox.SandboxStatsGroup>;
+    readonly createPersistent: (input: persistent.CreatePersistentSandboxRequest) => Effect.Effect<persistent.CreatePersistentSandboxResponse, persistent.CreatePersistentSandboxError, never>;
+    readonly getPersistent: (input: persistent.GetPersistentSandboxRequest) => Effect.Effect<persistent.GetPersistentSandboxResponse, persistent.GetPersistentSandboxError, never>;
+    readonly resumePersistent: (input: persistent.ResumePersistentSandboxRequest) => Effect.Effect<persistent.ResumePersistentSandboxResponse, persistent.ResumePersistentSandboxError, never>;
+    readonly terminatePersistent: (input: persistent.TerminatePersistentSandboxRequest) => Effect.Effect<persistent.TerminatePersistentSandboxResponse, persistent.TerminatePersistentSandboxError, never>;
+    readonly images: {
+        readonly getOrCreate: (input: import("@distilled.cloud/modal/image").ImageGetOrCreateRequest) => Effect.Effect<import("@distilled.cloud/modal/image").ImageGetOrCreateResponse, persistent.ModalOpError, never>;
+        readonly joinStreaming: import("@distilled.cloud/core/api").StreamingCall<import("@distilled.cloud/modal/image").ImageJoinStreamingRequest, import("@distilled.cloud/modal/image").ImageJoinStreamingStream, import("@distilled.cloud/modal/image").ImageJoinStreamingError, never, import("@distilled.cloud/modal/image").ImageJoinStreamingResponse>;
+        readonly putFile: (input: import("@distilled.cloud/modal/mount").MountPutFileRequest) => Effect.Effect<import("@distilled.cloud/modal/mount").MountPutFileResponse, persistent.ModalOpError, never>;
+        readonly getOrCreateMount: (input: import("@distilled.cloud/modal/mount").MountGetOrCreateRequest) => Effect.Effect<import("@distilled.cloud/modal/mount").MountGetOrCreateResponse, import("@distilled.cloud/modal/mount").MountGetOrCreateError, never>;
+        readonly blobs: {
+            readonly create: (input: import("@distilled.cloud/modal/blob").CreateBlobRequest) => Effect.Effect<import("@distilled.cloud/modal/blob").CreateBlobResponse, persistent.ModalOpError, never>;
+            readonly get: (input: import("@distilled.cloud/modal/blob").GetBlobRequest) => Effect.Effect<import("@distilled.cloud/modal/blob").GetBlobResponse, persistent.ModalOpError, never>;
+            readonly http: HttpClient.HttpClient;
+        };
+    };
+    readonly http: HttpClient.HttpClient;
+}, target: SandboxTarget, options?: PersistentSandboxCreateOptions | undefined) => Effect.Effect<RawPersistentSandboxHandle, import("./Blob.ts").BlobTransferFailed | import("./ImageBuild.ts").ImageBuildFailed | import("./ImageBuild.ts").ImageBuildTimeout | import("./ImageBuild.ts").ImageBuildUnexpectedResponse | import("@distilled.cloud/modal/image").ImageNotFound | import("./Mounts.ts").MountNotBound | import("@distilled.cloud/modal/mount").MountNotFound | SandboxUnexpectedResponse | persistent.CreatePersistentSandboxError, never>;
+export {};
+//# sourceMappingURL=SandboxClient.d.ts.map