@fungi.computer/computer-contract 0.0.0-stage → 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,742 @@
+import * as z from "zod";
+/**
+ * The stable Workspace id of one attached execution backend: `container`,
+ * `vm-` followed by a lowercase letter-or-digit name that may contain hyphens,
+ * or `local-` followed by 16 lowercase base32 characters. A command request
+ * names one to run there; omitted, the Computer routes by its default order.
+ */
+export declare const attachedBackendIdSchema: z.ZodLazy<z.ZodString>;
+/**
+ * Most bytes of file content one Computer read or write carries, counted as
+ * UTF-8.
+ */
+export declare const maximumFileBytes: number;
+/** Most entries one list, glob or grep reply returns in a single page. */
+export declare const maximumListEntries = 256;
+/** Longest glob or search pattern a request may send. */
+export declare const maximumPatternCharacters = 512;
+/** Longest command string a request may send. */
+export declare const maximumCommandCharacters: number;
+/**
+ * Most bytes of stdout or stderr kept from one command. A longer stream is cut
+ * and marked.
+ */
+export declare const maximumStreamBytes: number;
+/** Room inside the stream cap for the visible truncation marker. */
+export declare const truncationMarkerReserveBytes = 256;
+/** The bound for ordinary Computer commands; hosts own any admitted job budget. */
+export declare const maximumExecutionTimeMs = 120000;
+/** Host-owned policy, never supplied in a Computer request body. */
+export type ComputerExecutionBudget = Readonly<{
+    /** Longest time, in milliseconds, a command may be asked to run. */
+    maximumTimeMs: number;
+}>;
+/**
+ * The budget for ordinary Computer commands. Hosts that admit a job principal
+ * choose their own.
+ */
+export declare const genericComputerExecutionBudget: ComputerExecutionBudget;
+/**
+ * Accepts any JSON value. Capability descriptions and other transport data are
+ * checked against it.
+ */
+export declare const computerValueSchema: z.ZodJSONSchema;
+/** A JSON value accepted by `computerValueSchema`. */
+export type ComputerValue = z.output<typeof computerValueSchema>;
+/**
+ * Accepts the name of one Computer operation: a letter, then letters, digits or
+ * underscores.
+ */
+export declare const capabilityNameSchema: z.ZodLazy<z.ZodString>;
+/** One valid TCP port number, used only with this Computer's container. */
+export declare const computerPortSchema: z.ZodLazy<z.ZodNumber>;
+/** Most preview ports one Computer admits at once. */
+export declare const maximumExposedPorts = 64;
+/** computerd's Workspace RPC port, pinned by the Cloudflare container backend. */
+export declare const computerDaemonPort = 8080;
+/** The Computer-owned terminal server inside the container image. */
+export declare const computerTerminalPort = 7681;
+/**
+ * Ports served by the Computer's own in-container daemons. An admitted
+ * preview must never reach a control plane.
+ */
+export declare const computerReservedPorts: ReadonlySet<number>;
+/**
+ * Whether a Computer daemon owns this port, so it can never be admitted for
+ * preview.
+ */
+export declare function isComputerReservedPort(port: number): boolean;
+/** Names one container port to expose or remove. */
+export declare const computerPortInputSchema: z.ZodObject<{
+    port: z.ZodLazy<z.ZodNumber>;
+}, z.core.$strict>;
+/** Reply to a request to expose a port. */
+export declare const computerPortOutputSchema: z.ZodLazy<z.ZodObject<{
+    port: z.ZodLazy<z.ZodNumber>;
+    exposed: z.ZodBoolean;
+}, z.core.$strict>>;
+/** Reply to a request to stop exposing a port. */
+export declare const computerPortRemovalOutputSchema: z.ZodLazy<z.ZodObject<{
+    port: z.ZodLazy<z.ZodNumber>;
+    removed: z.ZodBoolean;
+}, z.core.$strict>>;
+/** The ports this Computer currently admits for preview. */
+export declare const computerPortsOutputSchema: z.ZodLazy<z.ZodObject<{
+    ports: z.ZodArray<z.ZodLazy<z.ZodNumber>>;
+}, z.core.$strict>>;
+/** The port belongs to a Computer daemon and cannot be admitted for preview. */
+export declare class ComputerPortReservedError extends Error {
+    constructor(port: number);
+}
+/** A requested port cannot be reserved; no other process identity is disclosed. */
+export declare class ComputerPortConflictError extends Error {
+    constructor();
+}
+/** This Computer already admits the maximum number of preview ports. */
+export declare class ComputerPortLimitError extends Error {
+    constructor();
+}
+/** Native operation descriptions shared by discovery and its OpenAPI document. */
+export declare const computerCapabilitiesSchema: z.ZodLazy<z.ZodArray<z.ZodObject<{
+    id: z.ZodLazy<z.ZodString>;
+    name: z.ZodLazy<z.ZodString>;
+    kind: z.ZodString;
+    description: z.ZodString;
+    parameters: z.ZodLazy<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    output: z.ZodLazy<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>>>;
+/**
+ * Accepts an absolute path inside the Computer: it starts with a slash and
+ * holds no null byte.
+ */
+export declare const pathSchema: z.ZodString;
+/**
+ * Builds a schema for text of at least the given length whose UTF-8 size stays
+ * within `maximumFileBytes`.
+ */
+export declare const boundedTextSchema: (minimumLength?: number) => z.ZodString;
+/** Complete bounded UTF-8 text reads. Binary reads use the same path input. */
+export declare const readInputSchema: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strict>;
+/** A request to read one whole file as text. */
+export type ComputerFileReadInput = z.output<typeof readInputSchema>;
+/** The whole contents of one file, as text. */
+export declare const readOutputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strict>>;
+/** The reply to reading one whole file as text. */
+export type ComputerFileReadOutput = z.output<typeof readOutputSchema>;
+/** Optional byte window; text reads remain complete and independently bounded. */
+export declare const readBytesInputSchema: z.ZodObject<{
+    path: z.ZodString;
+    byteOffset: z.ZodOptional<z.ZodNumber>;
+    byteLength: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/** A request to read a window of bytes from one file. */
+export type ComputerFileByteReadInput = z.output<typeof readBytesInputSchema>;
+/** Finite byte-read reply used by admitted App frame bindings. */
+export declare const computerByteReadReplySchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodString;
+    byteOffset: z.ZodNumber;
+    content: z.ZodString;
+    encoding: z.ZodLiteral<"base64">;
+    truncated: z.ZodBoolean;
+}, z.core.$strict>>;
+/** Host-admitted App method preview; parsing does not grant port access. */
+export declare const appMethodPreviewResultSchema: z.ZodLazy<z.ZodObject<{
+    previewUrl: z.ZodURL;
+    expiresAt: z.ZodNumber;
+}, z.core.$strict>>;
+/**
+ * Accepts how many entries a list returns: 1 up to `maximumListEntries`, 100
+ * when omitted.
+ */
+export declare const listLimitSchema: z.ZodDefault<z.ZodNumber>;
+/** Accepts how many entries a list skips. Zero when omitted. */
+export declare const listOffsetSchema: z.ZodDefault<z.ZodNumber>;
+/** A request for one page of a directory's entries. */
+export declare const listInputSchema: z.ZodObject<{
+    path: z.ZodDefault<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+/** One page of a directory's entries. */
+export declare const listOutputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodString;
+    entries: z.ZodArray<z.ZodLazy<z.ZodObject<{
+        name: z.ZodString;
+        size: z.ZodNumber;
+        modifiedAt: z.ZodNumber;
+        type: z.ZodEnum<{
+            /** A regular file. */
+            readonly file: "file";
+            /** A directory. */
+            readonly directory: "directory";
+            /** A symbolic link. */
+            readonly symlink: "symlink";
+        }>;
+    }, z.core.$strict>>>;
+    nextOffset: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>>;
+/** A request for one page of a directory's entries. */
+export type ComputerFileListInput = z.output<typeof listInputSchema>;
+/** The reply to a directory listing. */
+export type ComputerFileListOutput = z.output<typeof listOutputSchema>;
+/** Accepts text to store in a file, within `maximumFileBytes`. */
+export declare const fileContentSchema: z.ZodLazy<z.ZodString>;
+/** A request to write one file, creating or replacing its contents. */
+export declare const writeInputSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodLazy<z.ZodString>;
+}, z.core.$strict>;
+/** The reply to a committed file write. */
+export declare const writeOutputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodString;
+    bytes: z.ZodNumber;
+}, z.core.$strict>>;
+/** A request to write one file. */
+export type ComputerFileWriteInput = z.output<typeof writeInputSchema>;
+/** The reply to a committed file write. */
+export type ComputerFileWriteOutput = z.output<typeof writeOutputSchema>;
+/** Names the file for a binary write. The bytes travel as the request body. */
+export declare const writeBytesInputSchema: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strict>;
+/**
+ * A request to replace a file's contents only if they still equal what the
+ * caller last saw.
+ */
+export declare const replaceInputSchema: z.ZodObject<{
+    path: z.ZodString;
+    expectedContent: z.ZodLazy<z.ZodString>;
+    content: z.ZodLazy<z.ZodString>;
+}, z.core.$strict>;
+/** The reply to a committed replacement. It has the shape of a write reply. */
+export declare const replaceOutputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodString;
+    bytes: z.ZodNumber;
+}, z.core.$strict>>;
+/** A request to find paths under a directory that match a glob. */
+export declare const globInputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodString;
+    pattern: z.ZodString;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>>;
+/** The paths a glob found. */
+export declare const globOutputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodString;
+    matches: z.ZodArray<z.ZodString>;
+    truncated: z.ZodBoolean;
+}, z.core.$strict>>;
+/** A request to search file contents under a directory. */
+export declare const grepInputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodString;
+    pattern: z.ZodString;
+    regex: z.ZodDefault<z.ZodBoolean>;
+    ignoreCase: z.ZodDefault<z.ZodBoolean>;
+    include: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>>;
+/** The lines a search found. */
+export declare const grepOutputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodString;
+    matches: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        line: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+    truncated: z.ZodBoolean;
+}, z.core.$strict>>;
+/** A request to find paths that match a glob. */
+export type ComputerFileGlobInput = z.output<typeof globInputSchema>;
+/** A request to search file contents. */
+export type ComputerFileGrepInput = z.output<typeof grepInputSchema>;
+/** A request to replace one piece of text in a file. */
+export declare const editInputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodString;
+    oldText: z.ZodString;
+    newText: z.ZodString;
+}, z.core.$strict>>;
+/** The reply to a committed edit. */
+export declare const editOutputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodString;
+    bytes: z.ZodNumber;
+    diff: z.ZodString;
+    firstChangedLine: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>>;
+export { patchInputSchema, patchOutputSchema, } from "@fungi.computer/knapsack/files-patch";
+/** A request to create a directory. */
+export declare const mkdirInputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodString;
+    recursive: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>>;
+/** The reply to a directory creation. */
+export declare const mkdirOutputSchema: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strict>;
+/**
+ * Host-owned idempotency key for one `exec` or `bash` tool invocation. The
+ * host mints it once per invocation and keeps it across its own retries of that
+ * invocation; the model never sees or supplies it.
+ */
+export declare const computerRequestIdSchema: z.ZodUUID;
+/** A request id that passed `computerRequestIdSchema`. */
+export type ComputerRequestId = z.output<typeof computerRequestIdSchema>;
+/** Mint the request ID for one host tool invocation. */
+export declare function mintComputerRequestId(): ComputerRequestId;
+/**
+ * The model's command input: command, directory, backend and timeout. It
+ * carries no request id.
+ */
+export declare const execInputSchema: z.ZodObject<{
+    command: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    backend: z.ZodOptional<z.ZodLazy<z.ZodString>>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+/** Resource hosts select a budget only after admitting their job principal. */
+export declare function computerExecutionRequestSchema(budget: ComputerExecutionBudget): z.ZodObject<{
+    command: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    backend: z.ZodOptional<z.ZodLazy<z.ZodString>>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+    requestId: z.ZodUUID;
+}, z.core.$strict>;
+/** Host-to-Computer command request: the model input plus the host's ID. */
+export declare const execRequestSchema: z.ZodObject<{
+    command: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    backend: z.ZodOptional<z.ZodLazy<z.ZodString>>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+    requestId: z.ZodUUID;
+}, z.core.$strict>;
+/** One command stream cut at `maximumStreamBytes`; absent streams were whole. */
+export declare const execTruncationSchema: z.ZodObject<{
+    stream: z.ZodEnum<{
+        /** The command's standard output. */
+        readonly stdout: "stdout";
+        /** The command's standard error. */
+        readonly stderr: "stderr";
+    }>;
+    keptBytes: z.ZodNumber;
+    totalBytes: z.ZodNumber;
+}, z.core.$strict>;
+/** The visible line appended to a cut stream; sizes exclude the line itself. */
+export declare function execTruncationMarker(entry: ComputerExecTruncation): string;
+/** Matches the marker line `execTruncationMarker` appends at the end of a stream. */
+export declare const execTruncationMarkerPattern: RegExp;
+/** Longest prefix of `bytes` within `limit` that ends on a UTF-8 character boundary. */
+export declare function utf8Prefix(bytes: Uint8Array, limit: number): Uint8Array<ArrayBuffer>;
+/** A record that one command stream was cut. */
+export type ComputerExecTruncation = z.output<typeof execTruncationSchema>;
+/** What a finished command left behind. */
+export declare const execOutputSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        /** The command exited with code 0. */
+        readonly completed: "completed";
+        /** The command exited with a nonzero code that is not a cancellation. */
+        readonly failed: "failed";
+        /** The command was cancelled. */
+        readonly cancelled: "cancelled";
+    }>;
+    exitCode: z.ZodNumber;
+    stdout: z.ZodString;
+    stderr: z.ZodString;
+    truncated: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodArray<z.ZodObject<{
+        stream: z.ZodEnum<{
+            /** The command's standard output. */
+            readonly stdout: "stdout";
+            /** The command's standard error. */
+            readonly stderr: "stderr";
+        }>;
+        keptBytes: z.ZodNumber;
+        totalBytes: z.ZodNumber;
+    }, z.core.$strict>>]>;
+}, z.core.$strict>;
+/** Accepts the durable id of one started process. */
+export declare const computerProcessIdSchema: z.ZodLazy<z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string>>>;
+/** A process id that passed `computerProcessIdSchema`. */
+export type ComputerProcessId = z.output<typeof computerProcessIdSchema>;
+/** At most this many processes may be running in one host scope at once. */
+export declare const maximumRunningProcesses = 16;
+/** At most this many process records, running or exited, are kept per host scope. */
+export declare const maximumProcessRecords = 64;
+/** Mint the durable identity of one started process. */
+export declare function mintComputerProcessId(): ComputerProcessId;
+/** The host's request to start one long-running process. */
+export declare const processStartInputSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    requestScope: z.ZodString;
+    port: z.ZodOptional<z.ZodLazy<z.ZodNumber>>;
+    command: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** Model input excludes the host's replay identity and authority scope. */
+export declare const processStartToolInputSchema: z.ZodObject<{
+    port: z.ZodOptional<z.ZodLazy<z.ZodNumber>>;
+    command: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** A trusted App host binds replay identity to its admitted installation and caller. */
+export declare function installationProcessScope(installation: string, method: string, actor: Readonly<{
+    kind: "member" | "agent" | "team-key";
+    id: string;
+}>): string;
+/** Names one started process. */
+export declare const processIdInputSchema: z.ZodObject<{
+    id: z.ZodLazy<z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string>>>;
+}, z.core.$strict>;
+/**
+ * `running`: computerd still reports the execution live. `exited`: it ended;
+ * `exitCode` is null when the runtime that ran it was replaced or its record
+ * expired before the exit code was observed. `uncertain`: the Computer could
+ * not reach its container to check, so neither is claimed.
+ */
+export declare const computerProcessStateSchema: z.ZodEnum<{
+    /** computerd still reports the execution live. */
+    readonly running: "running";
+    /** The execution ended. */
+    readonly exited: "exited";
+    /** The Computer could not reach its container to check. */
+    readonly uncertain: "uncertain";
+}>;
+/**
+ * `synced`: the drain that recorded this exit read all the way to EOF,
+ * which is also the read that runs computerd's post-command pull.
+ * `pending`: that drain gave up waiting at its own deadline (a
+ * backgrounded child, for example `node server.js &`, can hold the
+ * transport open long after its parent exits) -- a background
+ * continuation keeps watching and upgrades this row to `synced` once it
+ * reaches that real EOF, so `pending` rows stay updatable. `unknown`:
+ * this exit was recorded with no pull evidence at all (a replaced
+ * runtime, an expired record, or any other exit path that never drained
+ * for one). Never claim `synced` without the specific evidence for this
+ * exit; default to `unknown`, not `synced`.
+ */
+export declare const computerProcessSyncSchema: z.ZodEnum<{
+    /** The drain that recorded the exit read to the end of the stream. */
+    readonly synced: "synced";
+    /** The drain gave up at its deadline. A background watcher upgrades it to synced. */
+    readonly pending: "pending";
+    /** The exit was recorded with no pull evidence. */
+    readonly unknown: "unknown";
+}>;
+/** A value of `computerProcessSyncSchema`. */
+export type ComputerProcessSync = z.output<typeof computerProcessSyncSchema>;
+/** One started process, as the Computer reports it. */
+export declare const computerProcessSchema: z.ZodObject<{
+    id: z.ZodLazy<z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string>>>;
+    port: z.ZodNullable<z.ZodLazy<z.ZodNumber>>;
+    command: z.ZodString;
+    cwd: z.ZodNullable<z.ZodString>;
+    state: z.ZodEnum<{
+        /** computerd still reports the execution live. */
+        readonly running: "running";
+        /** The execution ended. */
+        readonly exited: "exited";
+        /** The Computer could not reach its container to check. */
+        readonly uncertain: "uncertain";
+    }>;
+    exitCode: z.ZodNullable<z.ZodNumber>;
+    sync: z.ZodEnum<{
+        /** The drain that recorded the exit read to the end of the stream. */
+        readonly synced: "synced";
+        /** The drain gave up at its deadline. A background watcher upgrades it to synced. */
+        readonly pending: "pending";
+        /** The exit was recorded with no pull evidence. */
+        readonly unknown: "unknown";
+    }>;
+    startedAt: z.ZodNumber;
+    endedAt: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+/** One started process, as the Computer reports it. */
+export type ComputerProcess = z.output<typeof computerProcessSchema>;
+/** The processes started on this Computer. */
+export declare const processListOutputSchema: z.ZodObject<{
+    processes: z.ZodArray<z.ZodObject<{
+        id: z.ZodLazy<z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string>>>;
+        port: z.ZodNullable<z.ZodLazy<z.ZodNumber>>;
+        command: z.ZodString;
+        cwd: z.ZodNullable<z.ZodString>;
+        state: z.ZodEnum<{
+            /** computerd still reports the execution live. */
+            readonly running: "running";
+            /** The execution ended. */
+            readonly exited: "exited";
+            /** The Computer could not reach its container to check. */
+            readonly uncertain: "uncertain";
+        }>;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        sync: z.ZodEnum<{
+            /** The drain that recorded the exit read to the end of the stream. */
+            readonly synced: "synced";
+            /** The drain gave up at its deadline. A background watcher upgrades it to synced. */
+            readonly pending: "pending";
+            /** The exit was recorded with no pull evidence. */
+            readonly unknown: "unknown";
+        }>;
+        startedAt: z.ZodNumber;
+        endedAt: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** The reply to a request to stop a process. */
+export declare const processKillOutputSchema: z.ZodLazy<z.ZodObject<{
+    process: z.ZodObject<{
+        id: z.ZodLazy<z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"computer-process", "process", 1>, string>>>;
+        port: z.ZodNullable<z.ZodLazy<z.ZodNumber>>;
+        command: z.ZodString;
+        cwd: z.ZodNullable<z.ZodString>;
+        state: z.ZodEnum<{
+            /** computerd still reports the execution live. */
+            readonly running: "running";
+            /** The execution ended. */
+            readonly exited: "exited";
+            /** The Computer could not reach its container to check. */
+            readonly uncertain: "uncertain";
+        }>;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        sync: z.ZodEnum<{
+            /** The drain that recorded the exit read to the end of the stream. */
+            readonly synced: "synced";
+            /** The drain gave up at its deadline. A background watcher upgrades it to synced. */
+            readonly pending: "pending";
+            /** The exit was recorded with no pull evidence. */
+            readonly unknown: "unknown";
+        }>;
+        startedAt: z.ZodNumber;
+        endedAt: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>;
+    signalled: z.ZodBoolean;
+}, z.core.$strict>>;
+/** No process with this id was started on this Computer. */
+export declare class ComputerProcessNotFoundError extends Error {
+    constructor(id: string);
+}
+/** Every process slot is occupied by a running process. */
+export declare class ComputerProcessLimitError extends Error {
+    constructor();
+}
+/** The model's command input. */
+export type ComputerExecInput = z.output<typeof execInputSchema>;
+/** The host's command request: the model's input plus the host's request id. */
+export type ComputerExecRequest = z.output<typeof execRequestSchema>;
+/** What a finished command left behind. */
+export type ComputerExecOutput = z.output<typeof execOutputSchema>;
+/** Host-memory-only native inputs. Never part of a tool, replay row or log. */
+export type ComputerExecutionCarriage = Readonly<{
+    /** Command-local environment supplied only to this actual native invocation. */
+    env?: Readonly<Record<string, string>>;
+    /** String or byte input supplied to the same native invocation's stdin. */
+    stdin?: string | Uint8Array;
+}>;
+/** Non-secret identity of the actual native invocation, not its credential. */
+export type ComputerExecutionInvocation = Readonly<{
+    /** Stable public native identity, reused on replay without another dispatch. */
+    id: string;
+    /** The existing admission owner for this command or managed process. */
+    kind: "exec" | "process";
+}>;
+/** Authority closure is distinct from asserting a native exit code. */
+export type ComputerExecutionCloseReason = "refused_start" | "native_exit" | "unknown" | "reconstructed";
+/**
+ * The resource host owns cargo meaning and issuance. Computer owns NEW/replay,
+ * dispatch and actual native liveness. Only non-secret context is durable;
+ * hooks and carriage stay in host memory.
+ */
+export type ComputerExecutionHostHooks = Readonly<{
+    /** Open host authority after NEW admission, immediately before native dispatch. */
+    open(invocation: ComputerExecutionInvocation, context: ComputerValue): Promise<ComputerExecutionCarriage>;
+    /** Renew from a caller observation only after actual native liveness is proven. */
+    renew(invocation: ComputerExecutionInvocation, context: ComputerValue): Promise<void>;
+    /** Release host authority after Computer durably records its closure reason. */
+    close(invocation: ComputerExecutionInvocation, context: ComputerValue, reason: ComputerExecutionCloseReason): Promise<void>;
+}>;
+/** Protected host seam only. Public command/process parsers do not accept cargo. */
+export type ComputerExecutionHostPort = Readonly<{
+    /** The trusted host's in-memory hooks, absent when no such host is attached. */
+    executionHooks(): ComputerExecutionHostHooks | undefined;
+    /** Observe the selected native invocation without consuming its output reader. */
+    executionIsLive(invocationId: string): Promise<boolean>;
+    /** Admit a command with optional non-secret context supplied by the trusted host. */
+    executeOperationAfterAcceptance(input: ComputerExecRequest, accept: () => void, kind: "exec" | "bash" | "hosted", budget?: ComputerExecutionBudget, signal?: AbortSignal, executionContext?: ComputerValue): Promise<ComputerOperationResult>;
+    /** Admit or replay a managed process without accepting public credential cargo. */
+    startProcessAfterAcceptance(input: ComputerValue, accept: () => void, executionContext?: ComputerValue): Promise<ComputerProcess>;
+    /** Dispatch an ordinary capability while preserving the trusted host's context. */
+    callAfterAcceptance(capabilityId: ComputerValue, input: ComputerValue, accept: () => void, executionContext?: ComputerValue): Promise<ComputerValue>;
+}>;
+/**
+ * Where one command invocation stands: accepted, running, succeeded, failed,
+ * unknown (the outcome cannot be established, because the Computer restarted
+ * mid-command or the id has no record yet is still inside the admission
+ * window) or expired (no record, and older than the admission window).
+ */
+export declare const computerOperationStatusSchema: z.ZodEnum<{
+    /** The request id is recorded and the command has not started. */
+    readonly accepted: "accepted";
+    /** The command is running. */
+    readonly running: "running";
+    /** The command completed. */
+    readonly succeeded: "succeeded";
+    /** The command ended without completing. */
+    readonly failed: "failed";
+    /**
+     * The outcome cannot be established: the Computer restarted mid-command, or
+     * the id has no record yet is still inside the admission window.
+     */
+    readonly unknown: "unknown";
+    /** The id has no record and is older than the admission window. */
+    readonly expired: "expired";
+}>;
+/** Durable operation status returned to the host that owns the request ID. */
+export declare const computerOperationResultSchema: z.ZodObject<{
+    requestId: z.ZodUUID;
+    status: z.ZodEnum<{
+        /** The request id is recorded and the command has not started. */
+        readonly accepted: "accepted";
+        /** The command is running. */
+        readonly running: "running";
+        /** The command completed. */
+        readonly succeeded: "succeeded";
+        /** The command ended without completing. */
+        readonly failed: "failed";
+        /**
+         * The outcome cannot be established: the Computer restarted mid-command, or
+         * the id has no record yet is still inside the admission window.
+         */
+        readonly unknown: "unknown";
+        /** The id has no record and is older than the admission window. */
+        readonly expired: "expired";
+    }>;
+    output: z.ZodNullable<z.ZodObject<{
+        status: z.ZodEnum<{
+            /** The command exited with code 0. */
+            readonly completed: "completed";
+            /** The command exited with a nonzero code that is not a cancellation. */
+            readonly failed: "failed";
+            /** The command was cancelled. */
+            readonly cancelled: "cancelled";
+        }>;
+        exitCode: z.ZodNumber;
+        stdout: z.ZodString;
+        stderr: z.ZodString;
+        truncated: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodArray<z.ZodObject<{
+            stream: z.ZodEnum<{
+                /** The command's standard output. */
+                readonly stdout: "stdout";
+                /** The command's standard error. */
+                readonly stderr: "stderr";
+            }>;
+            keptBytes: z.ZodNumber;
+            totalBytes: z.ZodNumber;
+        }, z.core.$strict>>]>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * The durable status of one command invocation, for the host that owns its
+ * request id.
+ */
+export type ComputerOperationResult = z.output<typeof computerOperationResultSchema>;
+/** Model-facing command result: the durable status without the host's ID. */
+export declare const computerToolResultSchema: z.ZodObject<{
+    output: z.ZodNullable<z.ZodObject<{
+        status: z.ZodEnum<{
+            /** The command exited with code 0. */
+            readonly completed: "completed";
+            /** The command exited with a nonzero code that is not a cancellation. */
+            readonly failed: "failed";
+            /** The command was cancelled. */
+            readonly cancelled: "cancelled";
+        }>;
+        exitCode: z.ZodNumber;
+        stdout: z.ZodString;
+        stderr: z.ZodString;
+        truncated: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodArray<z.ZodObject<{
+            stream: z.ZodEnum<{
+                /** The command's standard output. */
+                readonly stdout: "stdout";
+                /** The command's standard error. */
+                readonly stderr: "stderr";
+            }>;
+            keptBytes: z.ZodNumber;
+            totalBytes: z.ZodNumber;
+        }, z.core.$strict>>]>;
+    }, z.core.$strict>>;
+    status: z.ZodEnum<{
+        /** The request id is recorded and the command has not started. */
+        readonly accepted: "accepted";
+        /** The command is running. */
+        readonly running: "running";
+        /** The command completed. */
+        readonly succeeded: "succeeded";
+        /** The command ended without completing. */
+        readonly failed: "failed";
+        /**
+         * The outcome cannot be established: the Computer restarted mid-command, or
+         * the id has no record yet is still inside the admission window.
+         */
+        readonly unknown: "unknown";
+        /** The id has no record and is older than the admission window. */
+        readonly expired: "expired";
+    }>;
+}, z.core.$strict>;
+/** The status of one command invocation without the host's request id. */
+export type ComputerToolResult = z.output<typeof computerToolResultSchema>;
+/** Project one host operation result onto the model-facing tool result. */
+export declare function computerToolResult(result: ComputerOperationResult): ComputerToolResult;
+/** Public operation vocabulary; transport adapters map these to routes. */
+export declare const computerOperationSchema: z.ZodEnum<{
+    /** Read one whole file as text. */
+    readonly "files.read": "files.read";
+    /** Read a window of bytes from one file. */
+    readonly "files.readBytes": "files.readBytes";
+    /** Write one file as text. */
+    readonly "files.write": "files.write";
+    /** Write one file from binary bytes. */
+    readonly "files.writeBytes": "files.writeBytes";
+    /** List one page of a directory. */
+    readonly "files.list": "files.list";
+    /** Find paths that match a glob. */
+    readonly "files.glob": "files.glob";
+    /** Search file contents. */
+    readonly "files.grep": "files.grep";
+    /** Replace one piece of text in a file. */
+    readonly "files.edit": "files.edit";
+    /** Apply a patch to files. */
+    readonly "files.patch": "files.patch";
+    /** Create a directory. */
+    readonly mkdir: "mkdir";
+    /** Run a command in the Computer's container. */
+    readonly bash: "bash";
+    /** Run a command in the Computer's lightweight Worker shell. */
+    readonly exec: "exec";
+}>;
+/** One public operation name. */
+export type ComputerOperation = z.output<typeof computerOperationSchema>;
+/** A request to replace a file's contents if they still match. */
+export type ComputerFileReplacement = z.output<typeof replaceInputSchema>;
+/** The reply to a committed replacement. */
+export type ComputerFileReplacementResult = z.output<typeof replaceOutputSchema>;
+/** The expected file contents no longer match at atomic replacement. */
+export declare class ComputerFileConflict extends Error {
+    constructor();
+}
+/** A byte window starts beyond the current file extent. */
+export declare class ComputerFileRangeError extends Error {
+    /** The file's current size in bytes. */
+    readonly size: number;
+    constructor(
+    /** The file's current size in bytes. */
+    size: number);
+}
+/** The requested file bytes exceed the admitted read bound. */
+export declare class ComputerFileTooLargeError extends Error {
+    constructor();
+}
+/**
+ * The operations every Computer advertises; static, so hosts can describe them
+ * without a call. Built on first read: deriving JSON Schema for every operation
+ * is real work that a Worker should not pay at startup.
+ */
+export declare function computerCapabilities(): z.output<typeof computerCapabilitiesSchema>;