@cloudflare/sandbox 0.13.0-next.776.1 → 1.0.0-rc.0

package/dist/index.d.ts

@@ -1,576 +0,0 @@
-import { H as RPCTransportErrorKind, V as RPCTransportContext, Z as ErrorCode } from "./contexts-1EsLHByO.js";
-import { c as WaitForLogResult, i as ProcessLogEvent, n as ProcessFailure, o as ProcessStatus, r as ProcessLogCursor, s as SandboxCommand, t as ProcessExit } from "./process-types-GStiZ8f8.js";
-import { A as CreateTerminalOptions, C as BucketCredentials, D as MountBucketOptions, E as LocalMountBucketOptions, F as TerminalOutputOptions, G as ProcessTextOutputOptions, H as ProcessLogsOptions, I as TerminalOutputSubscriptionAPI, J as WaitForExitOptions, K as SandboxOptions, L as TerminalSnapshot, M as Terminal, N as TerminalOutputCursor, O as RemoteMountBucketOptions, P as TerminalOutputEvent, R as ExecOptions, S as BackupOptions, T as DirectoryBackup, U as ProcessOutput, W as ProcessOutputOptions, X as WaitForPortOptions, Y as WaitForLogOptions, _ as RenameFileResult, a as FileChunk, b as WriteFileResult, c as FileMetadata, d as ListFilesOptions, f as ListFilesResult, g as ReadFileStreamResult, h as ReadFileResult, i as DeleteFileResult, k as RestoreBackupResult, l as FileStreamEvent, m as MoveFileResult, o as FileEncoding, p as MkdirResult, q as SandboxProcess, r as CheckChangesResult, s as FileExistsResult, t as CheckChangesOptions, u as FileWatchSSEEvent, v as WatchOptions, w as BucketProvider } from "./filesystem-BWAZCZER.js";
-import { t as ISandbox } from "./sandbox-BbAabq93.js";
-import { _ as QuickTunnelInfo, d as sandboxRuntimeCall, f as ProcessPullSubscriptionRPC, g as NamedTunnelInfo, n as ExtensionRuntimeCall, p as ProcessRPCDescriptor, s as HTTPAuthInterceptorParams, v as TunnelInfo, y as TunnelOptions } from "./index-Bs4bqXDR.js";
-import { $ as TerminalNotFoundError, G as ContainerUnavailableError, H as BackupExpiredError, J as InvalidTerminalCwdError, K as InvalidBackupConfigError, Q as TerminalControlError, U as BackupNotFoundError, V as BackupCreateError, W as BackupRestoreError, X as RPCTransportError, Y as OperationInterruptedError, Z as StaleTerminalHandleError, a as InvalidProcessCursorError, c as ProcessAbortedError, d as ProcessExitedBeforeReadyError, f as ProcessNotFoundError, g as StaleProcessHandleError, h as ProcessWaitTimeoutError, l as ProcessError, m as ProcessSpawnFailedError, n as RuntimeControlProtocolError, o as InvalidProcessCwdError, p as ProcessReadyTimeoutError, q as InvalidTerminalCursorError, s as InvalidProcessEnvironmentError, t as RuntimeIdentityInactiveError, u as ProcessExitedBeforeLogError } from "./index-HNYBk-az.js";
-import { Container, ContainerProxy as ContainerProxy$1, ContainerStartConfigOptions } from "@cloudflare/containers";
-import { RpcTarget, RpcTransport } from "capnweb";
-
-//#region src/file-stream.d.ts
-
-/**
- * Stream a file from the sandbox with automatic base64 decoding for binary files
- *
- * @param stream - The ReadableStream from readFileStream()
- * @returns AsyncGenerator that yields FileChunk (string for text, Uint8Array for binary)
- *
- * @example
- * ```ts
- * const stream = await sandbox.readFileStream('/path/to/file.png');
- * for await (const chunk of streamFile(stream)) {
- *   if (chunk instanceof Uint8Array) {
- *     // Binary chunk
- *     console.log('Binary chunk:', chunk.length, 'bytes');
- *   } else {
- *     // Text chunk
- *     console.log('Text chunk:', chunk);
- *   }
- * }
- * ```
- */
-declare function streamFile(stream: ReadableStream<Uint8Array>): AsyncGenerator<FileChunk, FileMetadata>;
-/**
- * Collect an entire file into memory from a stream
- *
- * @param stream - The ReadableStream from readFileStream()
- * @returns Object containing the file content and metadata
- *
- * @example
- * ```ts
- * const stream = await sandbox.readFileStream('/path/to/file.txt');
- * const { content, metadata } = await collectFile(stream);
- * console.log('Content:', content);
- * console.log('MIME type:', metadata.mimeType);
- * ```
- */
-declare function collectFile(stream: ReadableStream<Uint8Array>): Promise<{
-  content: string | Uint8Array;
-  metadata: FileMetadata;
-}>;
-//#endregion
-//#region src/platform-errors.d.ts
-/**
- * Whether an error was raised because the current Durable Object isolate was
- * superseded by a deploy/code update. In-process retries are futile for this
- * class because the invocation keeps running on the old isolate; callers
- * should return control to the platform or retry from a fresh request.
- */
-declare function isDurableObjectCodeUpdateReset(error: unknown): boolean;
-/**
- * Whether an error represents a transient platform lifecycle/storage failure,
- * not an application-level sandbox failure.
- */
-declare function isPlatformTransientError(error: unknown): boolean;
-//#endregion
-//#region src/pty/rpc-types.d.ts
-interface TerminalCapabilityRPC {
-  getSnapshot(): Promise<TerminalSnapshot | null>;
-  openOutput(options?: Omit<TerminalOutputOptions, 'signal'>): Promise<ProcessPullSubscriptionRPC<TerminalOutputEvent>>;
-  write(data: Uint8Array): Promise<void>;
-  resize(cols: number, rows: number): Promise<void>;
-  interrupt(): Promise<void>;
-  terminate(): Promise<void>;
-  authorizeConnection(): Promise<string>;
-}
-interface TerminalRPCDescriptor {
-  snapshot: TerminalSnapshot;
-  runtimeIncarnationID: string;
-  capability: TerminalCapabilityRPC;
-}
-//#endregion
-//#region src/pty/proxy.d.ts
-interface TerminalHandleStub {
-  get(id: string): Promise<TerminalSnapshot | null>;
-  output(id: string, options?: Omit<TerminalOutputOptions, 'signal'>): Promise<TerminalOutputSubscriptionAPI | ProcessPullSubscriptionRPC<TerminalOutputEvent>>;
-  write(id: string, data: Uint8Array): Promise<void>;
-  resize(id: string, cols: number, rows: number): Promise<void>;
-  interrupt(id: string): Promise<void>;
-  terminate(id: string): Promise<void>;
-  fetch(request: Request): Promise<Response>;
-}
-declare function proxyTerminal(stub: Pick<TerminalHandleStub, 'fetch'>, terminalId: string, request: Request, options: {
-  cursor?: TerminalOutputCursor;
-  cols?: number;
-  rows?: number;
-  runtimeIncarnationID: string;
-}): Promise<Response>;
-//#endregion
-//#region src/backup/restore-fault-injection.d.ts
-type BackupRestoreFaultPhase = 'after_archive_ready';
-type BackupRestoreTestFault = {
-  phase: BackupRestoreFaultPhase;
-  mode: 'transport_disposed';
-  times: number;
-};
-//#endregion
-//#region src/storage-mount/errors.d.ts
-/**
- * Base error for bucket mounting operations
- */
-declare class BucketMountError extends Error {
-  readonly code: ErrorCode;
-  constructor(message: string, code?: ErrorCode);
-}
-/**
- * Thrown when S3FS mount command fails
- */
-declare class S3FSMountError extends BucketMountError {
-  constructor(message: string);
-}
-/**
- * Thrown when fusermount -u fails to unmount a FUSE filesystem
- */
-declare class BucketUnmountError extends BucketMountError {
-  constructor(message: string);
-}
-/**
- * Thrown when no credentials found in environment
- */
-declare class MissingCredentialsError extends BucketMountError {
-  constructor(message: string);
-}
-/**
- * Thrown when bucket name, mount path, or options are invalid
- */
-declare class InvalidMountConfigError extends BucketMountError {
-  constructor(message: string);
-}
-//#endregion
-//#region src/storage-mount/outbound/container-proxy.d.ts
-declare class ContainerProxy extends ContainerProxy$1 {
-  fetch(request: Request): Promise<Response>;
-}
-//#endregion
-//#region src/tunnels/tunnel-service.d.ts
-interface TunnelsHandler {
-  get(port: number, options?: TunnelOptions): Promise<TunnelInfo>;
-  list(): Promise<TunnelInfo[]>;
-  destroy(portOrInfo: number | TunnelInfo): Promise<void>;
-}
-//#endregion
-//#region src/sandbox.d.ts
-type SandboxConfiguration = {
-  sandboxName?: {
-    name: string;
-    normalizeId?: boolean;
-  };
-  sleepAfter?: string | number;
-  keepAlive?: boolean;
-  containerTimeouts?: NonNullable<SandboxOptions['containerTimeouts']>;
-};
-type InternalSandboxRPCMethod = 'authorizePortRequest';
-type SandboxClient<T> = Omit<T, keyof ISandbox | InternalSandboxRPCMethod> & ISandbox;
-type CancellationOptions = {
-  abort?: AbortSignal;
-  instanceGetTimeoutMS?: number;
-  portReadyTimeoutMS?: number;
-  waitInterval?: number;
-};
-type StartAndWaitForPortsOptions = {
-  startOptions?: ContainerStartConfigOptions;
-  ports?: number | number[];
-  cancellationOptions?: CancellationOptions;
-};
-declare function getSandbox<T extends Sandbox<any>>(ns: DurableObjectNamespace<T>, id: string, options?: SandboxOptions): SandboxClient<T>;
-declare class Sandbox<Env = unknown> extends Container<Env> {
-  #private;
-  defaultPort: number;
-  sleepAfter: string | number;
-  private runtimeSessions;
-  private runtimeLifecycle;
-  private runtimeRunner;
-  private sandboxName;
-  private tunnelServiceHandle;
-  private tunnelsHandler;
-  private tunnelExitHandler;
-  private readonly controlCallback;
-  private normalizeId;
-  envVars: Record<string, string>;
-  private readonly portRequestTokens;
-  private logger;
-  private keepAliveEnabled;
-  private bucketMounts;
-  private currentLifetime;
-  private backupService;
-  private previewService;
-  private resourceActivityGate;
-  private r2AccessKeyId;
-  private r2SecretAccessKey;
-  private namedTunnelConfigResolver;
-  /**
-   * Default container startup timeouts (conservative for production)
-   * Based on Cloudflare docs: "Containers take several minutes to provision"
-   */
-  private readonly DEFAULT_CONTAINER_TIMEOUTS;
-  /**
-   * Active container timeout configuration
-   * Can be set via options, env vars, or defaults
-   */
-  private containerTimeouts;
-  /**
-   * True once containerTimeouts has been written to storage at least once
-   * (either via setContainerTimeouts or restored on cold start). Gates the
-   * idempotency check in setContainerTimeouts so a first explicit call
-   * persists even when the requested values already equal the in-memory
-   * defaults, distinguishing "user intent recorded" from "running on
-   * env/SDK defaults".
-   */
-  private hasStoredContainerTimeouts;
-  /**
-   * Dispatch method for tunnel operations.
-   * Called by the client-side proxy created in getSandbox() to provide
-   * the `sandbox.tunnels` API without relying on RPC pipelining through
-   * property getters, which vite-plugin does not currently support. This
-   * local method dispatch uses standard function application, so new
-   * Workers RPC pipelining traits on `TunnelsRpcTarget` also need an
-   * explicit path here before the proxy can expose them.
-   */
-  callTunnels(method: string, args: unknown[]): Promise<unknown>;
-  callExtension(extensionName: string, method: string, args: unknown[]): Promise<unknown>;
-  private renewActivityTimeoutIfAvailable;
-  private getRuntimePortStub;
-  constructor(ctx: DurableObjectState<{}>, env: Env);
-  setSandboxName(name: string, normalizeId?: boolean): Promise<void>;
-  configure(configuration: SandboxConfiguration): Promise<void>;
-  setSleepAfter(sleepAfter: string | number): Promise<void>;
-  setKeepAlive(keepAlive: boolean): Promise<void>;
-  setEnvVars(envVars: Record<string, string | undefined>): Promise<void>;
-  setContainerTimeouts(timeouts: NonNullable<SandboxOptions['containerTimeouts']>): Promise<void>;
-  private validateTimeout;
-  private getDefaultTimeouts;
-  /**
-   * Mount an S3-compatible bucket as a local directory.
-   */
-  mountBucket(bucket: string, mountPath: string, options: MountBucketOptions): Promise<void>;
-  /**
-   * Manually unmount a bucket filesystem.
-   */
-  unmountBucket(mountPath: string): Promise<void>;
-  /**
-   * In-flight `destroy()` promise. While set, concurrent callers coalesce
-   * onto the same teardown instead of triggering a second one. Cleared when
-   * the underlying work settles, so a later call that genuinely needs to
-   * recreate a destroyed sandbox still runs.
-   *
-   * If the underlying teardown hangs (e.g. `super.destroy()` never resolves
-   * because the Containers control plane is unresponsive), every coalesced
-   * caller hangs on the same promise until the Durable Object is evicted.
-   * This is deliberate: a second concurrent teardown would not make a stuck
-   * control plane unstuck, and spawning one would defeat the point of
-   * coalescing. Callers that need bounded waits must apply their own
-   * timeout around `destroy()`.
-   */
-  private inflightDestroy;
-  /**
-   * Cleanup and destroy the sandbox container.
-   *
-   * Concurrent calls coalesce: if a previous `destroy()` is still in flight,
-   * subsequent calls await the same underlying work instead of starting a
-   * second teardown. A canonical `sandbox.destroy.coalesced` event is logged
-   * per coalesced call so repeated destroy traffic is observable.
-   */
-  destroy(): Promise<void>;
-  private doDestroy;
-  private performRuntimeStop;
-  private runBoundedDestroyRuntimeCleanup;
-  private cleanupRuntimeBeforeDestroy;
-  private createTeardownTunnelsHandle;
-  private createDurableDestroyTunnelsHandle;
-  private createDestroyTunnelsHandle;
-  onStart(): Promise<void>;
-  start(options?: Parameters<Container<Env>['start']>[0]): Promise<void>;
-  startAndWaitForPorts(args: StartAndWaitForPortsOptions): Promise<void>;
-  startAndWaitForPorts(portsOrArgs?: number | number[] | StartAndWaitForPortsOptions, cancellationOptions?: CancellationOptions, startOptions?: ContainerStartConfigOptions): Promise<void>;
-  stop(signal?: Parameters<Container<Env>['stop']>[0]): Promise<void>;
-  onStop(): Promise<void>;
-  onError(error: unknown): void;
-  /**
-   * Override Container.containerFetch to route direct forwarding through runtime admission.
-   */
-  containerFetch(requestOrUrl: Request | string | URL, portOrInit?: number | RequestInit, portParam?: number): Promise<Response>;
-  private containerStartupErrorResponse;
-  /**
-   * Helper: Check if error is "no container instance available"
-   * This indicates the container VM is still being provisioned.
-   */
-  private isNoInstanceError;
-  /**
-   * Helper: Check if error is a transient startup error that should trigger retry
-   *
-   * These errors occur during normal container startup and are recoverable:
-   * - Port not yet mapped (container starting, app not listening yet)
-   * - Connection refused (port mapped but app not ready)
-   * - Timeouts during startup (recoverable with retry)
-   * - Network transients (temporary connectivity issues)
-   *
-   * Errors NOT included (permanent failures):
-   * - "no such image" - missing Docker image
-   * - "container already exists" - name collision
-   * - Configuration errors
-   */
-  private isTransientStartupError;
-  /**
-   * Helper: Check if error is a permanent startup failure that will never recover
-   *
-   * These errors indicate resource exhaustion, misconfiguration, or missing images.
-   * Retrying will never succeed, so the SDK should fail fast with HTTP 500.
-   *
-   * Error sources (traced from platform internals):
-   *   - Container runtime: OOM, PID limit
-   *   - Scheduling/provisioning: no matching app, no namespace configured
-   *   - workerd container-client.c++: no such image
-   *   - @cloudflare/containers: did not call start
-   */
-  private isPermanentStartupError;
-  /**
-   * Helper: Parse containerFetch arguments (supports multiple signatures)
-   */
-  private parseContainerFetchArgs;
-  onActivityExpired(): Promise<void>;
-  private getPreviewForwardingContainer;
-  fetch(request: Request): Promise<Response>;
-  wsConnect(request: Request, port: number): Promise<Response>;
-  authorizePortRequest(port: number, path: string): Promise<string>;
-  private connectWebSocket;
-  createTerminal(options: CreateTerminalOptions): Promise<TerminalRPCDescriptor>;
-  getTerminal(id: string): Promise<TerminalRPCDescriptor | null>;
-  listTerminals(): Promise<TerminalRPCDescriptor[]>;
-  private terminalDescriptor;
-  private terminalStub;
-  private determinePort;
-  exec(command: SandboxCommand, options?: ExecOptions): Promise<ProcessRPCDescriptor>;
-  private processDescriptor;
-  private processCapabilityLifecycle;
-  /** Internal bridge liveness read that neither starts nor renews a runtime. */
-  isRuntimeActive(): Promise<boolean>;
-  getProcess(id: string): Promise<ProcessRPCDescriptor | null>;
-  listProcesses(): Promise<ProcessStatus[]>;
-  mkdir(path: string, options?: {
-    recursive?: boolean;
-  }): Promise<MkdirResult>;
-  writeFile(path: string, content: string | ReadableStream<Uint8Array>, options?: {
-    encoding?: string;
-  }): Promise<{
-    success: boolean;
-    path: string;
-    bytesWritten: number;
-    timestamp: string;
-  } | WriteFileResult>;
-  deleteFile(path: string): Promise<DeleteFileResult>;
-  renameFile(oldPath: string, newPath: string): Promise<RenameFileResult>;
-  moveFile(sourcePath: string, destinationPath: string): Promise<MoveFileResult>;
-  /**
-   * Read a file from the sandbox.
-   *
-   * @param encoding - How to encode the returned content:
-   *   - `undefined` (default): auto-detect from MIME type (text → UTF-8 string, binary → base64 string)
-   *   - `'utf-8'` / `'utf8'`: always return as UTF-8 string
-   *   - `'base64'`: always return as base64-encoded string
-   *   - `'none'`: return a result whose `content` is a raw binary `ReadableStream<Uint8Array>`
-   *              with no encoding overhead.
-   */
-  readFile(path: string, options: {
-    encoding: 'none';
-  }): Promise<ReadFileStreamResult>;
-  readFile(path: string, options?: {
-    encoding?: Exclude<FileEncoding, 'none'>;
-  }): Promise<ReadFileResult>;
-  /**
-   * Stream a file from the sandbox using Server-Sent Events
-   * Returns a ReadableStream that can be consumed with streamFile() or collectFile() utilities
-   * @param path - Path to the file to stream
-   */
-  createWorkspaceArchive(options?: {
-    root: string;
-    excludes?: readonly string[];
-  }): Promise<string>;
-  extractWorkspaceArchive(options: {
-    root: string;
-    archivePath: string;
-  }): Promise<void>;
-  cleanupWorkspaceArchive(archivePath: string): Promise<void>;
-  cleanupMountDirectory(mountPath: string): Promise<void>;
-  readFileStream(path: string): Promise<ReadableStream<Uint8Array>>;
-  listFiles(path: string, options?: ListFilesOptions): Promise<ListFilesResult>;
-  exists(path: string): Promise<FileExistsResult>;
-  /**
-   * Watch a directory for file system changes using native inotify.
-   *
-   * The returned promise resolves only after the watcher is established on the
-   * filesystem, so callers can immediately perform actions that depend on the
-   * watch being active. The returned stream contains the full event sequence
-   * starting with the `watching` event.
-   *
-   * Consume the stream with `parseSSEStream<FileWatchSSEEvent>(stream)`.
-   *
-   * @param path - Path to watch (absolute or relative to /workspace)
-   * @param options - Watch options
-   */
-  watch(path: string, options?: WatchOptions): Promise<ReadableStream<Uint8Array>>;
-  /**
-   * Check whether a path changed while this caller was disconnected.
-   *
-   * Pass the `version` returned from a prior call in `options.since` to learn
-   * whether the path is unchanged, changed, or needs a full resync because the
-   * retained change state was reset.
-   *
-   * @param path - Path to check (absolute or relative to /workspace)
-   * @param options - Change-check options
-   */
-  checkChanges(path: string, options?: CheckChangesOptions): Promise<CheckChangesResult>;
-  /**
-   * Expose a port and get a preview URL for accessing services running in the sandbox
-   *
-   * Preview URL authorization survives transient container restarts, but
-   * forwarding is active only for the runtime where `exposePort()` was last
-   * called. Call `exposePort()` again after a restart to reactivate an
-   * existing URL for the current runtime.
-   *
-   * @param port - Port number to expose (1024-65535)
-   * @param options - Configuration options
-   * @param options.hostname - Your Worker's domain name (required for preview URL construction)
-   * @param options.name - Optional friendly name for the port
-   * @param options.token - Optional custom token for the preview URL (1-16 characters: lowercase letters, numbers, underscores)
-   *                       If not provided, a random 16-character token will be generated automatically
-   * @returns Preview URL information including the full URL, port number, and optional name
-   *
-   * @example
-   * // With auto-generated token
-   * const { url } = await sandbox.exposePort(8080, { hostname: 'example.com' });
-   * // url: https://8080-sandbox-id-abc123random4567.example.com
-   *
-   * @example
-   * // With custom token for stable URLs across deployments
-   * const { url } = await sandbox.exposePort(8080, {
-   *   hostname: 'example.com',
-   *   token: 'my_token_v1'
-   * });
-   * // url: https://8080-sandbox-id-my_token_v1.example.com
-   */
-  private runWakingComposite;
-  [sandboxRuntimeCall]: ExtensionRuntimeCall;
-  exposePort(port: number, options: {
-    name?: string;
-    hostname: string;
-    token?: string;
-  }): Promise<{
-    url: string;
-    port: number;
-    name?: string;
-  }>;
-  /**
-   * Revoke preview URL authorization and current-runtime activation for a port.
-   *
-   * Revocation is idempotent: calling this for a port with no preview state is
-   * still successful. The operation clears Durable Object-owned preview state
-   * only and does not contact, probe, wake, or clean up the container runtime.
-   */
-  unexposePort(port: number): Promise<void>;
-  /**
-   * Returns preview URLs that are currently forwardable in the active runtime.
-   * Durable authorization without current-runtime activation is omitted.
-   */
-  getExposedPorts(hostname: string): Promise<{
-    url: string;
-    port: number;
-    status: "active";
-  }[]>;
-  /**
-   * Returns whether a port is currently preview-forwardable.
-   * This checks Durable Object-owned auth and runtime activation without
-   * contacting or waking the container.
-   */
-  isPortExposed(port: number): Promise<boolean>;
-  /**
-   * Checks durable preview URL authorization for a port/token pair.
-   *
-   * This does not check whether the port is activated for the current runtime
-   * and is not sufficient to decide whether preview traffic may forward.
-   */
-  validatePortToken(port: number, token: string): Promise<boolean>;
-  /**
-   * Namespaced tunnel API. Quick tunnels are zero-config preview URLs
-   * backed by Cloudflare's trycloudflare service. Named tunnels bind a
-   * stable hostname under the configured Cloudflare zone.
-   *
-   * - `tunnels.get(port)` — idempotent. Returns the cached tunnel for
-   *   `port` if one exists in DO storage, otherwise spawns a fresh
-   *   cloudflared process and persists the record.
-   * - `tunnels.list()` — returns tunnels currently usable through this
-   *   sandbox runtime.
-   * - `tunnels.destroy(portOrInfo)` — tear down by port number or by
-   *   the record returned from `get()`.
-   *
-   * Container restarts drop quick-tunnel records because their
-   * `*.trycloudflare.com` URLs are tied to the dead cloudflared process.
-   * Named-tunnel records stay in storage and are marked for respawn so the
-   * next `get(port, { name })` call reuses the Cloudflare tunnel and DNS
-   * record while starting a fresh cloudflared process.
-   */
-  get tunnels(): TunnelsHandler;
-  /**
-   * Lazily construct the tunnel subsystem handle. Called from the
-   * `tunnels` getter on first access and from sandbox lifecycle hooks
-   * when tunnel reconciliation or cleanup is needed.
-   */
-  private ensureTunnelsBuilt;
-  /**
-   * Create a backup of a directory and upload it to R2.
-   *
-   * The returned DirectoryBackup handle is serializable. Store it anywhere
-   * (KV, D1, DO storage) and pass it to restoreBackup() later.
-   *
-   * Concurrent backup/restore calls on the same sandbox are serialized.
-   */
-  createBackup(options: BackupOptions): Promise<DirectoryBackup>;
-  /**
-   * Restore a backup from R2 into a directory.
-   *
-   * Production restores use a FUSE overlay mount. Local-bucket restores stream
-   * the archive through the R2 binding and extract it with unsquashfs.
-   *
-   * Concurrent backup/restore calls on the same sandbox are serialized.
-   */
-  restoreBackup(backup: DirectoryBackup): Promise<RestoreBackupResult>;
-  __setBackupRestoreFaultForTesting(fault: BackupRestoreTestFault | null): Promise<void>;
-  registerGitAuthInterceptor(params: HTTPAuthInterceptorParams): Promise<void>;
-  private getMountOutboundHost;
-}
-//#endregion
-//#region src/request-handler.d.ts
-interface SandboxEnv<T extends Sandbox<any> = Sandbox<any>> {
-  Sandbox: DurableObjectNamespace<T>;
-}
-declare function proxyToSandbox<T extends Sandbox<any>, E extends SandboxEnv<T>>(request: Request, env: E): Promise<Response | null>;
-//#endregion
-//#region src/sse-parser.d.ts
-/**
- * Server-Sent Events (SSE) parser for streaming responses
- * Converts ReadableStream<Uint8Array> to typed AsyncIterable<T>
- */
-/**
- * Parse a ReadableStream of SSE events into typed AsyncIterable
- * @param stream - The ReadableStream from fetch response
- * @param signal - Optional AbortSignal for cancellation
- */
-declare function parseSSEStream<T>(stream: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncIterable<T>;
-/**
- * Helper to convert a Response with SSE stream directly to AsyncIterable
- * @param response - Response object with SSE stream
- * @param signal - Optional AbortSignal for cancellation
- */
-declare function responseToAsyncIterable<T>(response: Response, signal?: AbortSignal): AsyncIterable<T>;
-/**
- * Create an SSE-formatted ReadableStream from an AsyncIterable
- * (Useful for Worker endpoints that need to forward AsyncIterable as SSE)
- * @param events - AsyncIterable of events
- * @param options - Stream options
- */
-declare function asyncIterableToSSEStream<T>(events: AsyncIterable<T>, options?: {
-  signal?: AbortSignal;
-  serialize?: (event: T) => string;
-}): ReadableStream<Uint8Array>;
-//#endregion
-export { BackupCreateError, BackupExpiredError, BackupNotFoundError, type BackupOptions, BackupRestoreError, type BucketCredentials, BucketMountError, type BucketProvider, BucketUnmountError, type CheckChangesOptions, type CheckChangesResult, ContainerProxy, ContainerUnavailableError, type CreateTerminalOptions, type DirectoryBackup, type ExecOptions, type FileChunk, type FileMetadata, type FileStreamEvent, type FileWatchSSEEvent, type ISandbox, InvalidBackupConfigError, InvalidMountConfigError, InvalidProcessCursorError, InvalidProcessCwdError, InvalidProcessEnvironmentError, InvalidTerminalCursorError, InvalidTerminalCwdError, type ListFilesOptions, type LocalMountBucketOptions, MissingCredentialsError, type MountBucketOptions, type NamedTunnelInfo, OperationInterruptedError, ProcessAbortedError, ProcessError, type ProcessExit, ProcessExitedBeforeLogError, ProcessExitedBeforeReadyError, type ProcessFailure, type ProcessLogCursor, type ProcessLogEvent, type ProcessLogsOptions, ProcessNotFoundError, type ProcessOutput, type ProcessOutputOptions, ProcessReadyTimeoutError, ProcessSpawnFailedError, type ProcessStatus, type ProcessTextOutputOptions, ProcessWaitTimeoutError, type QuickTunnelInfo, type RPCTransportContext, RPCTransportError, type RPCTransportErrorKind, type RemoteMountBucketOptions, type RestoreBackupResult, RuntimeControlProtocolError, RuntimeIdentityInactiveError, S3FSMountError, Sandbox, type SandboxCommand, type SandboxEnv, type SandboxOptions, type SandboxProcess, StaleProcessHandleError, StaleTerminalHandleError, type Terminal, TerminalControlError, TerminalNotFoundError, type TerminalOutputCursor, type TerminalOutputEvent, type TerminalOutputOptions, type TerminalSnapshot, type TunnelInfo, type TunnelOptions, type WaitForExitOptions, type WaitForLogOptions, type WaitForLogResult, type WaitForPortOptions, type WatchOptions, asyncIterableToSSEStream, collectFile, getSandbox, isDurableObjectCodeUpdateReset, isPlatformTransientError, parseSSEStream, proxyTerminal, proxyToSandbox, responseToAsyncIterable, streamFile };
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/file-stream.ts","../src/platform-errors.ts","../src/pty/rpc-types.ts","../src/pty/proxy.ts","../src/backup/restore-fault-injection.ts","../src/storage-mount/errors.ts","../src/storage-mount/outbound/container-proxy.ts","../src/tunnels/tunnel-service.ts","../src/sandbox.ts","../src/request-handler.ts","../src/sse-parser.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index.js

@@ -1,33 +0,0 @@
-import "./errors-CXR0xBpw.js";
-import { $ as TerminalControlError, G as BackupRestoreError, H as BackupCreateError, J as InvalidTerminalCursorError, K as ContainerUnavailableError, Q as StaleTerminalHandleError, U as BackupExpiredError, W as BackupNotFoundError, X as OperationInterruptedError, Y as InvalidTerminalCwdError, Z as RPCTransportError, _ as StaleProcessHandleError, c as InvalidProcessEnvironmentError, d as ProcessExitedBeforeLogError, et as TerminalNotFoundError, f as ProcessExitedBeforeReadyError, g as ProcessWaitTimeoutError, h as ProcessSpawnFailedError, l as ProcessAbortedError, m as ProcessReadyTimeoutError, n as RuntimeIdentityInactiveError, o as InvalidProcessCursorError, p as ProcessNotFoundError, q as InvalidBackupConfigError, r as RuntimeControlProtocolError, s as InvalidProcessCwdError, u as ProcessError } from "./errors-QYlSkVGz.js";
-import { a as TraceContext, r as createLogger } from "./dist-Duor5GbS.js";
-import { _ as proxyTerminal, a as responseToAsyncIterable, b as collectFile, c as BucketUnmountError, d as S3FSMountError, f as parsePreviewRoute, i as parseSSEStream, l as InvalidMountConfigError, n as getSandbox, o as ContainerProxy, p as withPreviewProxyMetadata, r as asyncIterableToSSEStream, s as BucketMountError, t as Sandbox, u as MissingCredentialsError, v as isDurableObjectCodeUpdateReset, x as streamFile, y as isPlatformTransientError } from "./sandbox-cmlgGVYX.js";
-import "./extensions-CFB2xHqY.js";
-
-//#region src/request-handler.ts
-function createProxyLogger(request) {
-	return createLogger({
-		component: "sandbox-do",
-		traceId: TraceContext.fromHeaders(request.headers) || TraceContext.generate(),
-		operation: "proxy"
-	});
-}
-async function proxyToSandbox(request, env) {
-	try {
-		const routeInfo = parsePreviewRoute(new URL(request.url));
-		if (!routeInfo) return null;
-		const { sandboxId, port, token } = routeInfo;
-		return await getSandbox(env.Sandbox, sandboxId, { normalizeId: true }).fetch(withPreviewProxyMetadata(request, {
-			port,
-			token,
-			sandboxId
-		}));
-	} catch (error) {
-		createProxyLogger(request).error("Proxy routing error", error instanceof Error ? error : new Error(String(error)));
-		return new Response("Proxy routing error", { status: 500 });
-	}
-}
-
-//#endregion
-export { BackupCreateError, BackupExpiredError, BackupNotFoundError, BackupRestoreError, BucketMountError, BucketUnmountError, ContainerProxy, ContainerUnavailableError, InvalidBackupConfigError, InvalidMountConfigError, InvalidProcessCursorError, InvalidProcessCwdError, InvalidProcessEnvironmentError, InvalidTerminalCursorError, InvalidTerminalCwdError, MissingCredentialsError, OperationInterruptedError, ProcessAbortedError, ProcessError, ProcessExitedBeforeLogError, ProcessExitedBeforeReadyError, ProcessNotFoundError, ProcessReadyTimeoutError, ProcessSpawnFailedError, ProcessWaitTimeoutError, RPCTransportError, RuntimeControlProtocolError, RuntimeIdentityInactiveError, S3FSMountError, Sandbox, StaleProcessHandleError, StaleTerminalHandleError, TerminalControlError, TerminalNotFoundError, asyncIterableToSSEStream, collectFile, getSandbox, isDurableObjectCodeUpdateReset, isPlatformTransientError, parseSSEStream, proxyTerminal, proxyToSandbox, responseToAsyncIterable, streamFile };
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/request-handler.ts"],"sourcesContent":["import { createLogger, TraceContext } from '@repo/shared';\nimport { withPreviewProxyMetadata } from './preview/protocol';\nimport { parsePreviewRoute } from './preview/route';\nimport { getSandbox, type Sandbox } from './sandbox';\n\nexport interface SandboxEnv<T extends Sandbox<any> = Sandbox<any>> {\n  Sandbox: DurableObjectNamespace<T>;\n}\n\nfunction createProxyLogger(request: Request) {\n  const traceId =\n    TraceContext.fromHeaders(request.headers) || TraceContext.generate();\n  return createLogger({\n    component: 'sandbox-do',\n    traceId,\n    operation: 'proxy'\n  });\n}\n\nexport async function proxyToSandbox<\n  T extends Sandbox<any>,\n  E extends SandboxEnv<T>\n>(request: Request, env: E): Promise<Response | null> {\n  try {\n    const url = new URL(request.url);\n    const routeInfo = parsePreviewRoute(url);\n\n    if (!routeInfo) {\n      return null; // Not a request to an exposed container port\n    }\n\n    const { sandboxId, port, token } = routeInfo;\n    // Preview URLs always use normalized (lowercase) IDs\n    const sandbox = getSandbox(env.Sandbox, sandboxId, { normalizeId: true });\n\n    return await sandbox.fetch(\n      withPreviewProxyMetadata(request, { port, token, sandboxId })\n    );\n  } catch (error) {\n    const logger = createProxyLogger(request);\n    logger.error(\n      'Proxy routing error',\n      error instanceof Error ? error : new Error(String(error))\n    );\n    return new Response('Proxy routing error', { status: 500 });\n  }\n}\n"],"mappings":";;;;;;;AASA,SAAS,kBAAkB,SAAkB;AAG3C,QAAO,aAAa;EAClB,WAAW;EACX,SAHA,aAAa,YAAY,QAAQ,QAAQ,IAAI,aAAa,UAAU;EAIpE,WAAW;EACZ,CAAC;;AAGJ,eAAsB,eAGpB,SAAkB,KAAkC;AACpD,KAAI;EAEF,MAAM,YAAY,kBADN,IAAI,IAAI,QAAQ,IAAI,CACQ;AAExC,MAAI,CAAC,UACH,QAAO;EAGT,MAAM,EAAE,WAAW,MAAM,UAAU;AAInC,SAAO,MAFS,WAAW,IAAI,SAAS,WAAW,EAAE,aAAa,MAAM,CAAC,CAEpD,MACnB,yBAAyB,SAAS;GAAE;GAAM;GAAO;GAAW,CAAC,CAC9D;UACM,OAAO;AAEd,EADe,kBAAkB,QAAQ,CAClC,MACL,uBACA,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,MAAM,CAAC,CAC1D;AACD,SAAO,IAAI,SAAS,uBAAuB,EAAE,QAAQ,KAAK,CAAC"}