@fungi.computer/computer 0.1.0 → 0.2.1

package/dist/files.js

@@ -1,4 +1,8 @@
-import { replaceOutputSchema, } from "./operation-contract.js";
+import { posix } from "node:path";
+import { z } from "zod";
+import { SearchVisibility } from "@fungi.computer/knapsack/files-search";
+import { imageReadResult, imageSniffBytes, imageTooLargeMessage, maximumImageBytes, sniffImageMimeType, } from "@fungi.computer/knapsack/files-read";
+import { replaceOutputSchema, } from "@fungi.computer/computer-contract";
 const utf8 = new TextEncoder();
 function entryType(entry) {
     if (entry.isSymbolicLink)
@@ -52,7 +56,7 @@ export function readBoundedWorkspaceText(provider, path, maximumBytes) {
 }
 /** Adapt native Workspace.fs at the one real file boundary. */
 export function createWorkspaceFilesPort(workspace, owner) {
-    return Object.freeze({
+    const port = {
         async read(input) {
             const stat = await workspace.fs.stat(input.path);
             if (!stat.isFile)
@@ -69,10 +73,22 @@ export function createWorkspaceFilesPort(workspace, owner) {
                     truncated: false,
                 };
             }
-            const pageBytes = await readBytes(workspace, input.path, input.offset, Math.min(input.limit, stat.size - input.offset));
-            if (pageBytes.byteLength === 0) {
+            // The first read covers the sniff window whatever the caller's limit.
+            const windowBytes = await readBytes(workspace, input.path, input.offset, Math.min(input.offset === 0
+                ? Math.max(input.limit, imageSniffBytes)
+                : input.limit, stat.size - input.offset));
+            if (windowBytes.byteLength === 0) {
                 throw new Error(`Files path changed during read: ${input.path}`);
             }
+            const mimeType = input.offset === 0 ? sniffImageMimeType(windowBytes) : undefined;
+            if (mimeType !== undefined) {
+                if (stat.size > maximumImageBytes)
+                    throw new Error(imageTooLargeMessage(input.path, stat.size, maximumImageBytes));
+                return imageReadResult(input.path, mimeType, windowBytes.byteLength === stat.size
+                    ? windowBytes
+                    : await readBytes(workspace, input.path, 0, stat.size));
+            }
+            const pageBytes = windowBytes.subarray(0, input.limit);
             const page = decodeUtf8Page(pageBytes, input.path, input.offset + pageBytes.byteLength < stat.size);
             const nextOffset = input.offset + page.byteLength;
             return {
@@ -83,54 +99,171 @@ export function createWorkspaceFilesPort(workspace, owner) {
                 truncated: nextOffset < stat.size,
             };
         },
-        async list(input) {
-            const rows = await workspace.fs.readdir(input.path, {
-                limit: input.limit + 1,
-            });
-            const entries = rows.slice(0, input.limit).map((entry) => {
-                const path = childPath(input.path, entry.name);
-                return {
-                    path,
-                    name: entry.name,
-                    type: entryType(entry),
-                    size: entry.size,
-                    modifiedAt: entry.mtime,
-                };
-            });
+        async list(input, context) {
+            const output = await searchWorkspaceDirectory(workspace, { ...input, offset: 0 }, context?.signal);
             return {
                 path: input.path,
-                entries,
-                truncated: rows.length > input.limit,
+                ...output,
+                results: output.results.map((entry) => ({
+                    path: entry.path,
+                    type: entryType(entry),
+                })),
             };
         },
-        async glob(input) {
-            const rows = await workspace.fs.find(input.path, input.pattern, {
-                limit: input.limit + 1,
-            });
+        async glob(input, context) {
+            const output = await visibleSearch(workspace, workspacePath(input.path), input.limit, (options) => workspace.fs.find(workspacePath(input.path), input.pattern, options), (entry) => entry.type === "dir", context?.signal);
             return {
                 path: input.path,
-                matches: rows.slice(0, input.limit).map((entry) => entry.path),
-                truncated: rows.length > input.limit,
+                ...output,
+                results: output.results.map((row) => ({
+                    path: row.path,
+                    type: row.type === "dir" ? "directory" : "file",
+                })),
             };
         },
-        async grep(input) {
-            const rows = await workspace.fs.grep(input.pattern, input.path, {
+        async grep(input, context) {
+            const options = {
                 regex: input.regex,
                 ignoreCase: input.ignoreCase,
                 limit: input.limit + 1,
-            });
+            };
+            if (input.include !== undefined)
+                options.include = input.include;
+            const output = await visibleSearch(workspace, workspacePath(input.path), input.limit, (page) => workspace.fs.grep(input.pattern, workspacePath(input.path), {
+                ...options,
+                ...page,
+            }), () => false, context?.signal);
             return {
                 path: input.path,
-                matches: rows.slice(0, input.limit).map((row) => ({
+                ...output,
+                results: output.results.map((row) => ({
                     path: row.path,
                     line: row.line,
                     text: row.text,
                 })),
-                truncated: rows.length > input.limit,
             };
         },
         async replace(input) {
             return replaceOutputSchema.parse(await owner.replaceFileIfUnchanged(input));
         },
+    };
+    return Object.freeze({
+        ...port,
+        // The Computer REST contract keeps its own path and content searches for
+        // Apps and Hub routes; its matches/boolean results are not Agent results.
+        rest: Object.freeze({
+            list: (input) => listWorkspaceFiles(workspace, input),
+            async glob(input) {
+                const output = await port.glob(input);
+                return {
+                    path: input.path,
+                    matches: output.results.map((entry) => entry.path),
+                    truncated: output.truncated !== null,
+                };
+            },
+            async grep(input) {
+                const output = await port.grep(input);
+                return {
+                    path: input.path,
+                    matches: output.results,
+                    truncated: output.truncated !== null,
+                };
+            },
+        }),
+    });
+}
+function searchWorkspaceDirectory(workspace, input, signal) {
+    const path = workspacePath(input.path);
+    return visibleSearch(workspace, path, input.limit, async (options) => (await workspace.fs.readdir(path, options)).map((entry) => ({
+        ...entry,
+        path: childPath(path, entry.name),
+    })), (entry) => entry.isDirectory, signal, input.offset);
+}
+/** Shared REST listing: offsets count visible entries, never ignored candidates. */
+export async function listWorkspaceFiles(workspace, input) {
+    const output = await searchWorkspaceDirectory(workspace, input);
+    // The existing list wire has no scan-reason field. Do not disguise an
+    // exhausted scan as an empty finished page or a fabricated next offset.
+    if (output.truncated === "scan")
+        throw new Error("Files listing reached the search scan bound; narrow path");
+    return {
+        path: input.path,
+        entries: output.results.map((entry) => ({
+            name: entry.name,
+            size: entry.size,
+            modifiedAt: entry.mtime,
+            type: entryType(entry),
+        })),
+        nextOffset: output.truncated === null ? null : input.offset + output.results.length,
+    };
+}
+/** Computer wire paths are absolute within its Workspace, even for relative Files inputs. */
+function workspacePath(path) {
+    if (path === ".")
+        return "/";
+    return path.startsWith("/") ? path : `/${path}`;
+}
+const missingSchema = z.object({ code: z.literal("ENOENT") });
+/** A regular file's stat, or null when the path is absent or not a file. */
+async function fileStat(workspace, path) {
+    try {
+        const stat = await workspace.fs.stat(path);
+        return stat.isFile ? stat : null;
+    }
+    catch (error) {
+        if (missingSchema.safeParse(error).success)
+            return null;
+        throw error;
+    }
+}
+/** Storage adapter only; shared Files policy owns visibility and grammar. */
+function workspaceSearchVisibility(workspace) {
+    let bytes = 0;
+    return new SearchVisibility(async (directory) => {
+        const path = posix.join("/", directory, ".gitignore");
+        const stat = await fileStat(workspace, path);
+        if (stat !== null) {
+            // Match Local's bounded text reads; never silently omit unreadable rules.
+            if (stat.size > 128 * 1_024 || bytes + stat.size > 64 * 1_024 * 1_024)
+                throw new Error(`Files ignore rules exceed the search byte bound: ${path}`);
+            bytes += stat.size;
+            return decodeUtf8(await readBytes(workspace, path, 0, stat.size), path);
+        }
+        return undefined;
     });
 }
+function searchRelativePath(path) {
+    return posix.relative("/", posix.resolve("/", path));
+}
+/** Page the SDK's traversal; filtering must not spend the visible-result limit. */
+async function visibleSearch(workspace, root, limit, page, isDirectory, signal, visibleOffset = 0) {
+    const rules = workspaceSearchVisibility(workspace);
+    const results = [];
+    signal?.throwIfAborted();
+    const metadata = await workspace.fs.stat(root);
+    if (!(await rules.visible(searchRelativePath(root), metadata.isDirectory)))
+        return { results, truncated: null };
+    const maximumCandidates = 50_000;
+    let offset = 0;
+    while (offset < maximumCandidates) {
+        signal?.throwIfAborted();
+        const count = Math.min(offset === 0 ? limit + 1 : Math.max(128, limit + 1), maximumCandidates - offset);
+        const rows = await page(offset === 0 ? { limit: count } : { limit: count, offset });
+        for (const row of rows) {
+            signal?.throwIfAborted();
+            if (!(await rules.visible(searchRelativePath(row.path), isDirectory(row))))
+                continue;
+            if (visibleOffset > 0) {
+                visibleOffset--;
+                continue;
+            }
+            if (results.length === limit)
+                return { results, truncated: "limit" };
+            results.push(row);
+        }
+        if (rows.length < count)
+            return { results, truncated: null };
+        offset += rows.length;
+    }
+    return { results, truncated: "scan" };
+}

package/dist/fleet/index.d.ts

@@ -5,7 +5,7 @@ export { computerActionSchema, computerProvenanceSchema, computerGrantSchema, co
 export { ComputerRuntimeUsage } from "./runtime-usage.js";
 export { computerUsageIntervalSchema, type ComputerUsageInterval, } from "./wire.js";
 export { createFleetInventory } from "./inventory.js";
-export { ComputerInventoryError, type FleetActor, type FleetComputer, } from "./inventory-wire.js";
+export { ComputerInventoryError, computerCreateRequestSchema, computerPageSchema, type ComputerCreateRequest, type ComputerPage, type FleetActor, type FleetComputer, } from "./inventory-wire.js";
 export { createFleetSlots } from "./slots.js";
 export { FleetLifecycle, FleetGrantRefused, type FleetLifecyclePorts, type FleetLifecycleFact, } from "./lifecycle.js";
 export { createFleetComputers } from "./computers.js";

package/dist/fleet/index.js

@@ -5,7 +5,7 @@ export { computerActionSchema, computerProvenanceSchema, computerGrantSchema, co
 export { ComputerRuntimeUsage } from "./runtime-usage.js";
 export { computerUsageIntervalSchema, } from "./wire.js";
 export { createFleetInventory } from "./inventory.js";
-export { ComputerInventoryError, } from "./inventory-wire.js";
+export { ComputerInventoryError, computerCreateRequestSchema, computerPageSchema, } from "./inventory-wire.js";
 export { createFleetSlots } from "./slots.js";
 export { FleetLifecycle, FleetGrantRefused, } from "./lifecycle.js";
 export { createFleetComputers } from "./computers.js";

package/dist/fleet/inventory-wire.d.ts

@@ -12,15 +12,19 @@ export type FleetComputer = Readonly<{
     updatedAt: number;
 }>;
 /** A durable create receipt binds the complete request to its actor. */
+export declare const computerCreateRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    requestId: z.ZodString;
+}, z.core.$strict>;
 export type ComputerCreateRequest = Readonly<{
     name?: string | undefined;
     requestId: string;
 }>;
 /** Inventory pages retain stable ordering and a bounded response. */
-export declare const computerPageSchema: z.ZodLazy<z.ZodObject<{
+export declare const computerPageSchema: z.ZodObject<{
     limit: z.ZodDefault<z.ZodNumber>;
     offset: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strict>>;
+}, z.core.$strict>;
 export type ComputerPage = z.input<typeof computerPageSchema>;
 /** Inventory failures, independent of a host's public error mapping. */
 export declare class ComputerInventoryError extends Error {

package/dist/fleet/inventory-wire.js

@@ -1,9 +1,14 @@
 import { z } from "zod";
+/** A durable create receipt binds the complete request to its actor. */
+export const computerCreateRequestSchema = z.strictObject({
+    name: z.string().min(1).max(256).optional(),
+    requestId: z.string().min(1).max(256),
+});
 /** Inventory pages retain stable ordering and a bounded response. */
-export const computerPageSchema = z.lazy(() => z.strictObject({
+export const computerPageSchema = z.strictObject({
     limit: z.number().int().min(1).max(100).default(100),
     offset: z.number().int().nonnegative().default(0),
-}));
+});
 /** Inventory failures, independent of a host's public error mapping. */
 export class ComputerInventoryError extends Error {
     code;

package/dist/fleet/lifecycle.d.ts

@@ -53,10 +53,16 @@ export declare class FleetLifecycle {
     readonly usage: ComputerRuntimeUsage;
     constructor(ports: FleetLifecyclePorts);
     get recycleRuntimeId(): string | undefined;
+    /** A successful stop cannot race an admitted boot or in-flight operation. */
+    get hasPendingOperations(): boolean;
     takeFacts(): FleetLifecycleFact[];
     private diagnostic;
     /** Keep pending starts visible while the host obtains admission and capacity. */
-    beginHostedStart(): () => void;
+    private beginHostedStart;
+    /** Start the selected hosted backend under the host's admission and slot policy. */
+    startHostedComputer(admitted: (backing: HostedBacking, run: () => Promise<void>) => Promise<void>): Promise<{
+        state: "running";
+    }>;
     /** Read liveness without waking a sleeping backend. Queue state wins over booting. */
     readComputerState(): Promise<{
         state: "queued";

package/dist/fleet/lifecycle.js

@@ -40,6 +40,12 @@ export class FleetLifecycle {
     get recycleRuntimeId() {
         return this.#recycleRuntimeId;
     }
+    /** A successful stop cannot race an admitted boot or in-flight operation. */
+    get hasPendingOperations() {
+        return (this.#hostedOperations > 0 ||
+            this.#startingHosted > 0 ||
+            this.#recycling !== undefined);
+    }
     takeFacts() {
         const facts = this.#facts;
         this.#facts = [];
@@ -55,6 +61,22 @@ export class FleetLifecycle {
             this.#startingHosted--;
         };
     }
+    /** Start the selected hosted backend under the host's admission and slot policy. */
+    async startHostedComputer(admitted) {
+        const hosted = this.ports.backend.requireHostedRoute();
+        const finish = this.beginHostedStart();
+        try {
+            await admitted(hosted.backing, async () => {
+                await this.ports.backend.workspace().push(hosted.id);
+            });
+            if (!(await this.ports.backend.containerRunning(hosted.backing)))
+                throw new Error("Hosted Computer disconnected while starting");
+            return { state: "running" };
+        }
+        finally {
+            finish();
+        }
+    }
     /** Read liveness without waking a sleeping backend. Queue state wins over booting. */
     async readComputerState() {
         const backends = await this.readAttachedBackends();

package/dist/fleet/wire.d.ts

@@ -5,6 +5,12 @@ export declare const computerActionSchema: z.ZodEnum<{
     exec: "exec";
     start: "start";
     delete: "delete";
+    mkdir: "mkdir";
+    backing: "backing";
+    bash: "bash";
+    exposePort: "exposePort";
+    listPorts: "listPorts";
+    unexposePort: "unexposePort";
     "files.read": "files.read";
     "files.readBytes": "files.readBytes";
     "files.write": "files.write";
@@ -14,12 +20,6 @@ export declare const computerActionSchema: z.ZodEnum<{
     "files.grep": "files.grep";
     "files.edit": "files.edit";
     "files.patch": "files.patch";
-    mkdir: "mkdir";
-    bash: "bash";
-    backing: "backing";
-    exposePort: "exposePort";
-    listPorts: "listPorts";
-    unexposePort: "unexposePort";
     terminal: "terminal";
     stop: "stop";
     processStart: "processStart";
@@ -40,6 +40,12 @@ export declare const computerGrantSchema: z.ZodObject<{
         exec: "exec";
         start: "start";
         delete: "delete";
+        mkdir: "mkdir";
+        backing: "backing";
+        bash: "bash";
+        exposePort: "exposePort";
+        listPorts: "listPorts";
+        unexposePort: "unexposePort";
         "files.read": "files.read";
         "files.readBytes": "files.readBytes";
         "files.write": "files.write";
@@ -49,12 +55,6 @@ export declare const computerGrantSchema: z.ZodObject<{
         "files.grep": "files.grep";
         "files.edit": "files.edit";
         "files.patch": "files.patch";
-        mkdir: "mkdir";
-        bash: "bash";
-        backing: "backing";
-        exposePort: "exposePort";
-        listPorts: "listPorts";
-        unexposePort: "unexposePort";
         terminal: "terminal";
         stop: "stop";
         processStart: "processStart";

package/dist/fleet/wire.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { computerOperationSchema, computerValueSchema, pathSchema, } from "../operation-contract.js";
+import { computerOperationSchema, computerValueSchema, pathSchema, } from "@fungi.computer/computer-contract";
 import { attachedBackendId, hostedBackingSchema, localBackendSchema, } from "../computer-backends.js";
 /** Operations the host may admit on one Computer. */
 export const computerActionSchema = z.enum([

package/dist/index.d.ts

@@ -1,10 +1,11 @@
+export { createLocalBackendReplayStore } from "./local-backend-replay.js";
 import { Workspace, WorkspaceProxy, WorkspaceServiceProxy, type WorkspaceStubHost } from "@fungi.computer/cloudflare-computer";
 import { type WorkerShellBackendOptions } from "@fungi.computer/cloudflare-computer/backends/worker-shell";
 import { type IWorkspaceContainerAPI } from "@fungi.computer/cloudflare-computer/backends/container";
 import { DurableObject } from "cloudflare:workers";
 import type { FilesPort } from "@fungi.computer/knapsack";
 import { z } from "zod";
-import { type ComputerExecutionBudget, type ComputerExecRequest, type ComputerOperationResult, type ComputerFileReadInput, type ComputerFileByteReadInput, type ComputerFileReplacement, type ComputerFileReplacementResult, type ComputerValue, writeInputSchema, writeOutputSchema, type ComputerProcess } from "./operation-contract.js";
+import { type ComputerExecutionBudget, type ComputerExecutionHostHooks, type ComputerExecRequest, type ComputerOperationResult, type ComputerFileReadInput, type ComputerFileByteReadInput, type ComputerFileReplacement, type ComputerFileReplacementResult, type ComputerValue, writeInputSchema, writeOutputSchema, type ComputerProcess } from "@fungi.computer/computer-contract";
 import { createWorkspaceFilesPort } from "./files.js";
 import { OnBoxVmContainerHost, type OnBoxVmEnv, type OnBoxVmPlacement } from "./on-box-vm.js";
 import { type AttachedBackend, type AttachedBackendView, type BackendNeed, type BackendRoute, type ContainerRuntimeStart, type HostedBacking } from "./computer-backends.js";
@@ -89,7 +90,7 @@ declare class ContainerComputer extends ContainerComputerBase {
      * The hosted backend that terminals, processes and ports use: the first in
      * the default order, or none when only local machines are attached.
      */
-    protected hostedRoute(): Readonly<{
+    protected hostedRoute(backend?: string): Readonly<{
         id: string;
         backing: HostedBacking;
     }> | undefined;
@@ -114,9 +115,8 @@ declare class ContainerComputer extends ContainerComputerBase {
     protected workspace(): Workspace;
     /**
      * The current Workspace once its mount index is ready and its guest mount
-     * root exists. Every backend mounts `/workspace`, so a host write there
-     * (such as a Workflow step's one-shot Git credential file) must not depend
-     * on a guest having booted first.
+     * root exists. Every backend mounts `/workspace`, so an ordinary host file
+     * write there must not depend on a guest having booted first.
      */
     protected readyWorkspace(): Promise<Workspace>;
     /** `getWorkspace(stub)` reaches the current generation through this door. */
@@ -132,6 +132,16 @@ declare class ContainerComputer extends ContainerComputerBase {
 /** One upstream Cloudflare Workspace that advertises and runs its capabilities. */
 export declare class ComputerDO extends ContainerComputer {
     #private;
+    constructor(ctx: DurableObjectState, env: ComputerEnv);
+    /** Host-admitted settings write; egress reads the current durable value. */
+    internetAccess(enabled?: boolean): boolean;
+    /** Ordinary Computers have no credential host; resource hosts override it. */
+    protected executionHooks(): ComputerExecutionHostHooks | undefined;
+    /**
+     * Admission observes the actual native subscriber, never App completion,
+     * output silence, an accepted signal or this isolate's warm state.
+     */
+    executionIsLive(invocationId: string): Promise<boolean>;
     /** Persist the bounded set of ports admitted for preview on this Computer. */
     exposePort(input: {
         port: number;
@@ -201,17 +211,25 @@ export declare class ComputerDO extends ContainerComputer {
     protected applyPatchAfterAcceptance(input: {
         patch: string;
     }, accept: () => void): Promise<{
-        status: "completed" | "failed" | "cancelled";
+        status: "failed" | "completed" | "cancelled";
         exitCode: number;
         stdout: string;
         stderr: string;
-        truncated: boolean;
+        truncated: false | {
+            stream: "stdout" | "stderr";
+            keptBytes: number;
+            totalBytes: number;
+        }[];
     } | {
-        status: "completed" | "failed" | "cancelled";
+        status: "failed" | "completed" | "cancelled";
         exitCode: number;
         stdout: string;
         stderr: string;
-        truncated: boolean;
+        truncated: false | {
+            stream: "stdout" | "stderr";
+            keptBytes: number;
+            totalBytes: number;
+        }[];
         error: {
             kind: "mismatch";
         };
@@ -220,14 +238,15 @@ export declare class ComputerDO extends ContainerComputer {
     protected writeTextAfterAcceptance(input: z.output<typeof writeInputSchema>, accept: () => void): Promise<z.output<typeof writeOutputSchema>>;
     call(capabilityId: ComputerValue, input: ComputerValue): Promise<ComputerValue>;
     /** Resource hosts may accept authority once the Workspace is ready to dispatch. */
-    protected callAfterAcceptance(capabilityId: ComputerValue, input: ComputerValue, accept: () => void): Promise<ComputerValue>;
+    protected callAfterAcceptance(capabilityId: ComputerValue, input: ComputerValue, accept: () => void, executionContext?: ComputerValue): Promise<ComputerValue>;
     /**
      * Execute a host request once, after the host accepts current authority.
      * `exec` runs on the Workspace's built-in Worker shell unless it names an
      * attached backend; `bash` always runs on an attached backend, the named one
-     * or the first available in the default order.
+     * or the first available in the default order. Host-only `hosted` execution
+     * excludes local backends, including an explicitly named local backend.
      */
-    protected executeOperationAfterAcceptance(input: ComputerExecRequest, accept: () => void, kind: "exec" | "bash", budget?: ComputerExecutionBudget, signal?: AbortSignal): Promise<ComputerOperationResult>;
+    protected executeOperationAfterAcceptance(input: ComputerExecRequest, accept: () => void, kind: "exec" | "bash" | "hosted", budget?: ComputerExecutionBudget, signal?: AbortSignal, executionContext?: ComputerValue): Promise<ComputerOperationResult>;
     /**
      * Run one command on a routed backend. Owners admit and meter hosted
      * backends here; a member's own machine is neither reserved nor metered.
@@ -238,7 +257,7 @@ export declare class ComputerDO extends ContainerComputer {
     /** Start one long-running container process with a durable identity. */
     startProcess(input: ComputerValue): Promise<ComputerProcess>;
     /** The host accepts authority when the running slot is reserved. */
-    protected startProcessAfterAcceptance(input: ComputerValue, accept: () => void): Promise<ComputerProcess>;
+    protected startProcessAfterAcceptance(input: ComputerValue, accept: () => void, executionContext?: ComputerValue): Promise<ComputerProcess>;
     /** List this Computer's processes, reconciling live ones with computerd. */
     listProcesses(): Promise<{
         processes: ComputerProcess[];
@@ -270,13 +289,12 @@ export declare class ComputerDO extends ContainerComputer {
     protected replaceFileIfUnchangedAfterAcceptance(input: ComputerFileReplacement, accept: () => void): Promise<ComputerFileReplacementResult>;
 }
 export { WorkspaceProxy, WorkspaceServiceProxy };
-export { OnBoxVmContainerHost, onBoxVmPlacement, onBoxVmIngress, type OnBoxVmEnv, type OnBoxVmState, } from "./on-box-vm.js";
+export { OnBoxVmContainerHost, OnBoxVmTimeoutError, onBoxVmPlacement, onBoxVmIngress, type OnBoxVmEnv, type OnBoxVmOperation, type OnBoxVmState, } from "./on-box-vm.js";
 export { computerContainerSleepAfterMs } from "./container-policy.js";
 export * from "./computer-backends.js";
 export { LocalBackendOfflineError, localBackendAudience, localBackendDialPath, verifyLocalBackendDial, } from "./local-backend.js";
 /** Keep each native Workspace lease inside the operation that uses it. */
 export declare function createComputerFilesPort(computer: ComputerRpc): FilesPort;
 export { createWorkspaceFilesPort, type WorkspaceFilesOwner } from "./files.js";
-export * from "./operation-contract.js";
 export { ComputerOperationConflictError, ComputerOperationLimitError, ComputerRequestInvalidError, } from "./operation-record.js";
 export type { ContainerComputer };