@xopcai/xopc 0.0.423 → 0.0.425

package/dist/src/computer/broker.d.ts

@@ -1,4 +1,4 @@
-import { type ComputerAction, type ComputerCommand, type ComputerModelBinding, type ComputerObservation, type ComputerReceipt, type ComputerTarget, type ComputerApp, type ComputerWindow } from '@xopcai/computer-control-contract';
+import { type ComputerAction, type ComputerCommand, type ComputerModelBinding, type ComputerObservation, type ComputerReceipt, type ComputerTarget, type ComputerApp, type ComputerWindow, type ComputerInputTiming } from '@xopcai/computer-control-contract';
 import { type ComputerConfig } from './config.js';
 import type { ComputerNativeTiming } from './diagnostics.js';
 export interface DriverObservation {
@@ -24,6 +24,7 @@ export interface ComputerDriver {
     }): Promise<ComputerTarget>;
     observe(target: ComputerTarget, signal: AbortSignal): Promise<DriverObservation>;
     perform(target: ComputerTarget, action: ComputerAction, signal: AbortSignal): Promise<void>;
+    getLastInputTiming?(): ComputerInputTiming | undefined;
     /** Must finish only after no further input can be dispatched. */
     stop(): Promise<void>;
 }
@@ -69,6 +70,7 @@ export declare class ComputerBroker {
     private readonly driver;
     private readonly host;
     private readonly now;
+    private readonly durationNow;
     readonly epoch: `${string}-${string}-${string}-${string}-${string}`;
     private session?;
     private busy;
@@ -77,7 +79,7 @@ export declare class ComputerBroker {
     private readonly apps;
     private readonly config;
     private readonly timer;
-    constructor(driver: ComputerDriver, host: ComputerBrokerHost, config?: Partial<ComputerConfig>, now?: () => number);
+    constructor(driver: ComputerDriver, host: ComputerBrokerHost, config?: Partial<ComputerConfig>, now?: () => number, durationNow?: () => number);
     private expired;
     private result;
     private active;

package/dist/src/computer/broker.js

@@ -4,6 +4,7 @@ import { ComputerConfigSchema, init_config } from "./config.js";
 import { ActionEnvelopeSchema, ComputerCommandSchema, init_src } from "../../packages/computer-control-contract/src/index.js";
 import { ComputerTargetError } from "./errors.js";
 import { createHash, randomUUID } from "node:crypto";
+import { setTimeout } from "node:timers/promises";
 //#region src/computer/broker.ts
 init_src();
 init_config();
@@ -19,10 +20,11 @@ var ComputerBroker = class {
 	apps = /* @__PURE__ */ new Map();
 	config;
 	timer;
-	constructor(driver, host, config = {}, now = Date.now) {
+	constructor(driver, host, config = {}, now = Date.now, durationNow = now === Date.now ? () => performance.now() : now) {
 		this.driver = driver;
 		this.host = host;
 		this.now = now;
+		this.durationNow = durationNow;
 		this.config = ComputerConfigSchema.parse(config);
 		this.timer = setInterval(() => {
 			const s = this.session;
@@ -306,9 +308,12 @@ var ComputerBroker = class {
 				return this.result(s);
 			}
 		}
-		const precheckStarted = this.now();
+		const precheckStarted = this.durationNow();
 		let matched = false;
+		let precheckSamples = 0;
 		for (let sample = 0; sample < 4; sample++) {
+			precheckSamples++;
+			if (sample) await setTimeout(100, void 0, { signal: s.controller.signal });
 			let current;
 			try {
 				current = await this.driver.observe(s.target, s.controller.signal);
@@ -337,9 +342,10 @@ var ComputerBroker = class {
 			};
 		}
 		const nativeMs = {
-			precheckMs: Math.max(0, this.now() - precheckStarted),
+			precheckMs: Math.max(0, Math.round(this.durationNow() - precheckStarted)),
 			inputMs: 0,
-			postObserveMs: 0
+			postObserveMs: 0,
+			precheckSamples
 		};
 		const receipt = {
 			actionId: e.actionId,
@@ -355,15 +361,23 @@ var ComputerBroker = class {
 		s.pending = void 0;
 		s.status = "running";
 		try {
-			const inputStarted = this.now();
-			await this.driver.perform(s.target, e.action, s.controller.signal);
-			nativeMs.inputMs = Math.max(0, this.now() - inputStarted);
+			const inputStarted = this.durationNow();
+			try {
+				await this.driver.perform(s.target, e.action, s.controller.signal);
+			} finally {
+				nativeMs.inputMs = Math.max(0, Math.round(this.durationNow() - inputStarted));
+				nativeMs.inputDetail = this.driver.getLastInputTiming?.();
+			}
 			this.active(s);
 			receipt.dispatch = "completed";
 			s.status = "ready";
-			const observationStarted = this.now();
-			const after = await this.observe(s);
-			nativeMs.postObserveMs = Math.max(0, this.now() - observationStarted);
+			const observationStarted = this.durationNow();
+			let after;
+			try {
+				after = await this.observe(s);
+			} finally {
+				nativeMs.postObserveMs = Math.max(0, Math.round(this.durationNow() - observationStarted));
+			}
 			receipt.verification = after.observation ? "visual" : "none";
 			return {
 				...after,
@@ -383,7 +397,8 @@ var ComputerBroker = class {
 			});
 			return {
 				...this.result(s),
-				receipt
+				receipt,
+				nativeMs
 			};
 		}
 	}

package/dist/src/computer/diagnostics.d.ts

@@ -1,12 +1,12 @@
 import { z } from 'zod';
-import type { ComputerAction, ComputerObservation, ComputerReceipt } from '@xopcai/computer-control-contract';
+import { type ComputerAction, type ComputerObservation, type ComputerReceipt } from '@xopcai/computer-control-contract';
 import type { ComputerVerification } from './task-state.js';
 export declare const ComputerFailurePhaseSchema: z.ZodEnum<{
     open: "open";
     executor: "executor";
     model: "model";
-    observe: "observe";
     dispatch: "dispatch";
+    observe: "observe";
     release: "release";
     frame_upload: "frame_upload";
     oracle: "oracle";
@@ -15,8 +15,8 @@ export type ComputerFailurePhase = z.infer<typeof ComputerFailurePhaseSchema>;
 export declare const ComputerFailureCategorySchema: z.ZodEnum<{
     permission: "permission";
     target: "target";
-    cancelled: "cancelled";
     unknown: "unknown";
+    cancelled: "cancelled";
     model: "model";
     observation: "observation";
     budget: "budget";
@@ -29,8 +29,8 @@ export declare const ComputerFailureSchema: z.ZodObject<{
     category: z.ZodEnum<{
         permission: "permission";
         target: "target";
-        cancelled: "cancelled";
         unknown: "unknown";
+        cancelled: "cancelled";
         model: "model";
         observation: "observation";
         budget: "budget";
@@ -43,8 +43,8 @@ export declare const ComputerFailureSchema: z.ZodObject<{
         open: "open";
         executor: "executor";
         model: "model";
-        observe: "observe";
         dispatch: "dispatch";
+        observe: "observe";
         release: "release";
         frame_upload: "frame_upload";
         oracle: "oracle";
@@ -86,6 +86,19 @@ export declare const ComputerNativeTimingSchema: z.ZodObject<{
     precheckMs: z.ZodNumber;
     inputMs: z.ZodNumber;
     postObserveMs: z.ZodNumber;
+    inputDetail: z.ZodOptional<z.ZodObject<{
+        wallMs: z.ZodNumber;
+        identityCheckMs: z.ZodNumber;
+        actionValidationMs: z.ZodNumber;
+        windowsInputGuardMs: z.ZodNullable<z.ZodNumber>;
+        sdkCallMs: z.ZodNumber;
+        resultValidationMs: z.ZodNumber;
+        renderGraceMs: z.ZodNumber;
+        unattributedMs: z.ZodNumber;
+        sdkCalls: z.ZodNumber;
+        completed: z.ZodBoolean;
+    }, z.core.$strict>>;
+    precheckSamples: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 export type ComputerNativeTiming = z.infer<typeof ComputerNativeTimingSchema>;
 export declare const ComputerSessionReportSchema: z.ZodObject<{
@@ -125,8 +138,8 @@ export declare const ComputerSessionReportSchema: z.ZodObject<{
         category: z.ZodEnum<{
             permission: "permission";
             target: "target";
-            cancelled: "cancelled";
             unknown: "unknown";
+            cancelled: "cancelled";
             model: "model";
             observation: "observation";
             budget: "budget";
@@ -139,8 +152,8 @@ export declare const ComputerSessionReportSchema: z.ZodObject<{
             open: "open";
             executor: "executor";
             model: "model";
-            observe: "observe";
             dispatch: "dispatch";
+            observe: "observe";
             release: "release";
             frame_upload: "frame_upload";
             oracle: "oracle";
@@ -175,6 +188,45 @@ export declare const ComputerSessionReportSchema: z.ZodObject<{
             free_pool_unavailable: "free_pool_unavailable";
         }>>;
     }, z.core.$strict>>;
+    timings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        actionId: z.ZodString;
+        nativeMs: z.ZodOptional<z.ZodObject<{
+            precheckMs: z.ZodNumber;
+            inputMs: z.ZodNumber;
+            postObserveMs: z.ZodNumber;
+            inputDetail: z.ZodOptional<z.ZodObject<{
+                wallMs: z.ZodNumber;
+                identityCheckMs: z.ZodNumber;
+                actionValidationMs: z.ZodNumber;
+                windowsInputGuardMs: z.ZodNullable<z.ZodNumber>;
+                sdkCallMs: z.ZodNumber;
+                resultValidationMs: z.ZodNumber;
+                renderGraceMs: z.ZodNumber;
+                unattributedMs: z.ZodNumber;
+                sdkCalls: z.ZodNumber;
+                completed: z.ZodBoolean;
+            }, z.core.$strict>>;
+            precheckSamples: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            wait: "wait";
+            typeText: "typeText";
+            activate: "activate";
+            showMenu: "showMenu";
+            click: "click";
+            drag: "drag";
+            setValue: "setValue";
+            pressKeys: "pressKeys";
+            scroll: "scroll";
+        }>>;
+        transport: z.ZodOptional<z.ZodObject<{
+            brokerWallMs: z.ZodNumber;
+            frameUploadMs: z.ZodNullable<z.ZodNumber>;
+            commandWallMs: z.ZodNumber;
+        }, z.core.$strict>>;
+        endpointRoundTripMs: z.ZodNumber;
+    }, z.core.$strict>>>;
+    timingsTruncated: z.ZodOptional<z.ZodBoolean>;
     recentActions: z.ZodArray<z.ZodObject<{
         kind: z.ZodEnum<{
             wait: "wait";
@@ -210,20 +262,22 @@ export type ComputerSessionReport = z.infer<typeof ComputerSessionReportSchema>;
 /** A bounded metadata-only companion to task history; it never retains action arguments or pixels. */
 export declare class ComputerSessionDiagnostics {
     private readonly now;
+    private readonly durationNow;
     private readonly data;
     private readonly receipts;
     private pending?;
     private endedAt?;
     phase: ComputerFailurePhase;
-    constructor(now?: () => number);
+    constructor(now?: () => number, durationNow?: () => number);
     bind(sessionId: string): void;
     count(key: keyof ComputerSessionReport['counters']): void;
+    timing(value: NonNullable<ComputerSessionReport['timings']>[number]): void;
     measure<T>(phase: keyof ComputerSessionReport['phaseMs'], fn: () => Promise<T>): Promise<T>;
     propose(id: string, kind: ComputerAction['kind']): void;
     discard(): void;
     record(receipt: ComputerReceipt, before?: ComputerObservation, after?: ComputerObservation, verification?: ComputerVerification): void;
     verify(verification?: ComputerVerification): void;
-    fail(error: unknown, phase?: "open" | "executor" | "model" | "observe" | "dispatch" | "release" | "frame_upload" | "oracle", dispatch?: ComputerFailure['dispatch'], aborted?: boolean): void;
+    fail(error: unknown, phase?: "open" | "executor" | "model" | "dispatch" | "observe" | "release" | "frame_upload" | "oracle", dispatch?: ComputerFailure['dispatch'], aborted?: boolean): void;
     finish(released: boolean): void;
     snapshot(): ComputerSessionReport;
 }

package/dist/src/computer/diagnostics.js

@@ -1,7 +1,9 @@
+import { ComputerInputTimingSchema, ComputerTransportTimingSchema, init_src } from "../../packages/computer-control-contract/src/index.js";
 import { ComputerDiagnosticSchema, computerDiagnostic } from "./errors.js";
 import { randomUUID } from "node:crypto";
 import { z } from "zod";
 //#region src/computer/diagnostics.ts
+init_src();
 const ComputerFailurePhaseSchema = z.enum([
 	"open",
 	"observe",
@@ -42,6 +44,15 @@ const ComputerFailureSchema = z.object({
 	serviceErrorCode: ComputerDiagnosticSchema.shape.serviceErrorCode
 }).strict();
 const categories = Object.create(null);
+for (const code of [
+	"AGENT_MODEL_REQUIRED",
+	"AGENT_MODEL_CHANGED",
+	"PLANNER_MISMATCH"
+]) categories[`COMPUTER_${code}`] = "model";
+for (const code of ["PROGRAM_BUDGET", "PROGRAM_STORE_LIMIT"]) categories[`COMPUTER_${code}`] = "budget";
+categories.COMPUTER_PROGRAM_POLICY_REFUSED = "permission";
+categories.COMPUTER_PROGRAM_FAILED = "harness";
+categories.COMPUTER_PROGRAM_UNAWAITED_CALL = "harness";
 for (const [category, codes] of Object.entries({
 	permission: [
 		"DISABLED",
@@ -196,7 +207,9 @@ const Count = z.number().int().nonnegative();
 const ComputerNativeTimingSchema = z.object({
 	precheckMs: Count,
 	inputMs: Count,
-	postObserveMs: Count
+	postObserveMs: Count,
+	inputDetail: ComputerInputTimingSchema.optional(),
+	precheckSamples: Count.optional()
 }).strict();
 const CountersSchema = z.object({
 	observations: Count,
@@ -233,6 +246,24 @@ const ComputerSessionReportSchema = z.object({
 		release: Count
 	}).strict(),
 	failure: ComputerFailureSchema.optional(),
+	timings: z.array(z.object({
+		actionId: z.string().max(200),
+		nativeMs: ComputerNativeTimingSchema.optional(),
+		kind: z.enum([
+			"activate",
+			"showMenu",
+			"click",
+			"drag",
+			"setValue",
+			"typeText",
+			"pressKeys",
+			"scroll",
+			"wait"
+		]).optional(),
+		transport: ComputerTransportTimingSchema.optional(),
+		endpointRoundTripMs: z.number().finite().nonnegative()
+	}).strict()).max(256).optional(),
+	timingsTruncated: z.boolean().optional(),
 	recentActions: z.array(z.object({
 		kind: z.enum([
 			"activate",
@@ -271,8 +302,9 @@ var ComputerSessionDiagnostics = class {
 	pending;
 	endedAt;
 	phase = "open";
-	constructor(now = Date.now) {
+	constructor(now = Date.now, durationNow = now === Date.now ? () => performance.now() : now) {
 		this.now = now;
+		this.durationNow = durationNow;
 		this.data = {
 			version: 1,
 			reportId: randomUUID(),
@@ -310,13 +342,22 @@ var ComputerSessionDiagnostics = class {
 	count(key) {
 		this.data.counters[key]++;
 	}
+	timing(value) {
+		const timings = this.data.timings ??= [];
+		if (timings.some((item) => item.actionId === value.actionId)) return;
+		if (timings.length === 256) {
+			this.data.timingsTruncated = true;
+			return;
+		}
+		timings.push(value);
+	}
 	async measure(phase, fn) {
 		this.phase = phase;
-		const start = this.now();
+		const start = this.durationNow();
 		try {
 			return await fn();
 		} finally {
-			this.data.phaseMs[phase] += Math.max(0, Math.round(this.now() - start));
+			this.data.phaseMs[phase] += Math.max(0, Math.round(this.durationNow() - start));
 		}
 	}
 	propose(id, kind) {

package/dist/src/computer/errors.d.ts

@@ -4,8 +4,8 @@ export declare const ComputerDiagnosticSchema: z.ZodObject<{
     errorCode: z.ZodString;
     phase: z.ZodEnum<{
         model: "model";
-        observe: "observe";
         dispatch: "dispatch";
+        observe: "observe";
         frame_upload: "frame_upload";
     }>;
     diagnosticId: z.ZodUUID;

package/dist/src/computer/errors.js

@@ -54,6 +54,10 @@ var ComputerTargetError = class extends Error {
 };
 /** Recovery instructions are deterministic; never replay an input with unknown delivery. */
 function computerRecovery(code) {
+	if (code === "COMPUTER_AGENT_MODEL_REQUIRED") return "Direct UI programs require an active visual main-model turn. Select a visual model and open with planner:agent; do not change models inside an active desktop session.";
+	if (code === "COMPUTER_AGENT_MODEL_CHANGED" || code === "COMPUTER_PLANNER_MISMATCH") return "The requested UI planner does not match the active session. Close and confirm release before opening the requested mode with the current main model.";
+	if (code === "COMPUTER_PROGRAM_UNAWAITED_CALL") return "The program ended with an unawaited UI call. Earlier inputs may already have completed. Control was released. Reopen and observe current state before performing only the remaining authorized actions; never replay the script. Await every ui.* call, including emitScreenshot. observe({visual:true}) already attaches the screenshot.";
+	if (code.startsWith("COMPUTER_PROGRAM_")) return "The UI program stopped. Inspect completed receipts and the report before continuing with a new program for only the remaining work. Never replay the entire script or bypass a policy refusal.";
 	if (code === "COMPUTER_RECEIPT_MISMATCH") return "The receipt could not be matched to the dispatched action, so its outcome is uncertain. Inspect the application locally; never automatically retry or replay the input. Wait for confirmed release before switching tools.";
 	if (code === "COMPUTER_FLOW_NOT_FOUND" || code === "COMPUTER_FLOW_TARGET_MISMATCH") return "The saved flow is unavailable or belongs to another application/device. Do not replay it or switch targets automatically. List flows and inspect the authorized target before planning again.";
 	if (code === "COMPUTER_FLOW_NOT_VERIFIED" || code === "COMPUTER_FLOW_SAVE_FAILED") return "Control was released. No reusable flow was confirmed saved. Saving requires verified native navigation, non-sensitive labels and working local storage; never repeat desktop input merely to save a flow.";

package/dist/src/computer/evaluation.d.ts

@@ -50,8 +50,8 @@ export declare const ComputerEvaluationRunSchema: z.ZodObject<{
         category: z.ZodEnum<{
             permission: "permission";
             target: "target";
-            cancelled: "cancelled";
             unknown: "unknown";
+            cancelled: "cancelled";
             model: "model";
             observation: "observation";
             budget: "budget";
@@ -64,8 +64,8 @@ export declare const ComputerEvaluationRunSchema: z.ZodObject<{
             open: "open";
             executor: "executor";
             model: "model";
-            observe: "observe";
             dispatch: "dispatch";
+            observe: "observe";
             release: "release";
             frame_upload: "frame_upload";
             oracle: "oracle";
@@ -106,8 +106,8 @@ export declare function isAutonomousComputerSuccess(run: ComputerEvaluationRun):
 /** Export measured runtime values only; an executor must supply independent safety and oracle evidence. */
 export declare function computerReportMeasurements(report: ComputerSessionReport): {
     failure?: {
-        category: "permission" | "target" | "cancelled" | "unknown" | "model" | "observation" | "budget" | "transport" | "native" | "no_progress" | "harness";
-        phase: "open" | "executor" | "model" | "observe" | "dispatch" | "release" | "frame_upload" | "oracle";
+        category: "permission" | "target" | "unknown" | "cancelled" | "model" | "observation" | "budget" | "transport" | "native" | "no_progress" | "harness";
+        phase: "open" | "executor" | "model" | "dispatch" | "observe" | "release" | "frame_upload" | "oracle";
         errorCode: string;
         dispatch: "unknown" | "completed" | "started" | "notStarted";
         diagnosticId?: string;

package/dist/src/computer/native-timing.d.ts

@@ -0,0 +1,15 @@
+import type { ComputerInputTiming } from '@xopcai/computer-control-contract';
+type Stage = 'identityCheckMs' | 'actionValidationMs' | 'windowsInputGuardMs' | 'sdkCallMs' | 'resultValidationMs' | 'renderGraceMs';
+/** Monotonic, non-overlapping input stages. SDK time includes the native RPC. */
+export declare class ComputerInputTimer {
+    private readonly windows;
+    private readonly now;
+    private readonly startedAt;
+    private readonly stages;
+    private sdkCalls;
+    constructor(windows: boolean, now?: () => number);
+    measure<T>(stage: Stage, operation: () => T | Promise<T>): Promise<T>;
+    measureSync<T>(stage: Stage, operation: () => T): T;
+    finish(completed: boolean): ComputerInputTiming;
+}
+export {};

package/dist/src/computer/native-timing.js

@@ -0,0 +1,49 @@
+//#region src/computer/native-timing.ts
+/** Monotonic, non-overlapping input stages. SDK time includes the native RPC. */
+var ComputerInputTimer = class {
+	startedAt;
+	stages = {
+		identityCheckMs: 0,
+		actionValidationMs: 0,
+		windowsInputGuardMs: 0,
+		sdkCallMs: 0,
+		resultValidationMs: 0,
+		renderGraceMs: 0
+	};
+	sdkCalls = 0;
+	constructor(windows, now = () => performance.now()) {
+		this.windows = windows;
+		this.now = now;
+		this.startedAt = now();
+	}
+	async measure(stage, operation) {
+		const start = this.now();
+		if (stage === "sdkCallMs") this.sdkCalls++;
+		try {
+			return await operation();
+		} finally {
+			this.stages[stage] += Math.max(0, this.now() - start);
+		}
+	}
+	measureSync(stage, operation) {
+		const start = this.now();
+		try {
+			return operation();
+		} finally {
+			this.stages[stage] += Math.max(0, this.now() - start);
+		}
+	}
+	finish(completed) {
+		const wallMs = Math.max(0, this.now() - this.startedAt);
+		return {
+			wallMs,
+			...this.stages,
+			windowsInputGuardMs: this.windows ? this.stages.windowsInputGuardMs : null,
+			unattributedMs: Math.max(0, wallMs - Object.values(this.stages).reduce((a, b) => a + b, 0)),
+			sdkCalls: this.sdkCalls,
+			completed
+		};
+	}
+};
+//#endregion
+export { ComputerInputTimer };

package/dist/src/computer/program-runtime.d.ts

@@ -0,0 +1,22 @@
+export type ComputerProgramMethod = 'observe' | 'resolve' | 'act' | 'waitFor' | 'verify' | 'emitScreenshot';
+export type ComputerProgramHost = (method: ComputerProgramMethod, args: unknown, signal: AbortSignal) => Promise<unknown>;
+/** UI-only capability table; no general tool discovery, disk store, or output spill. */
+export declare function executeComputerProgram(code: string, host: ComputerProgramHost, store: Record<string, unknown>, signal: AbortSignal, timeoutMs?: number): Promise<{
+    status: "program_error";
+    output: string;
+    errorCode: string;
+    scriptError: string;
+    scriptErrorMessage?: undefined;
+} | {
+    status: "program_error";
+    output: string;
+    errorCode: string;
+    scriptError: import("@earendil-works/pi-codemode").CodemodeErrorKind;
+    scriptErrorMessage: string;
+} | {
+    status: "program_completed";
+    output: string;
+    errorCode?: undefined;
+    scriptError?: undefined;
+    scriptErrorMessage?: undefined;
+}>;

package/dist/src/computer/program-runtime.js

@@ -0,0 +1,105 @@
+import { existsSync, readFileSync } from "node:fs";
+import { z } from "zod";
+import { CodemodeSandbox } from "@earendil-works/pi-codemode";
+//#region src/computer/program-runtime.ts
+let workerUrl;
+function computerWorkerUrl() {
+	if (workerUrl) return workerUrl;
+	const bundled = new URL("./codemode-worker.js", import.meta.url);
+	const source = existsSync(bundled) ? bundled : new URL("./bundle/chunks/codemode-worker.js", import.meta.resolve("@earendil-works/pi-coding-agent"));
+	workerUrl = new URL(`data:text/javascript;base64,${readFileSync(source).toString("base64")}`);
+	return workerUrl;
+}
+/** UI-only capability table; no general tool discovery, disk store, or output spill. */
+async function executeComputerProgram(code, host, store, signal, timeoutMs = 12e4) {
+	if (Buffer.byteLength(code) > 64 * 1024) throw new Error("COMPUTER_INPUT_LIMIT");
+	let busy = false;
+	let calls = 0;
+	let ended = false;
+	let hostErrorCode;
+	let cancelledHostCall = false;
+	const lifetime = new AbortController();
+	const combined = AbortSignal.any([signal, lifetime.signal]);
+	const inFlight = /* @__PURE__ */ new Set();
+	const sandbox = new CodemodeSandbox({
+		timeoutMs,
+		memoryLimitBytes: 64 * 1024 * 1024,
+		workerUrl: computerWorkerUrl(),
+		globals: [
+			"observe",
+			"resolve",
+			"act",
+			"waitFor",
+			"verify",
+			"emitScreenshot"
+		].map((method) => ({
+			name: `ui.${method}`,
+			async execute(args, context) {
+				if (ended || ++calls > 64) {
+					lifetime.abort();
+					throw new Error("COMPUTER_PROGRAM_BUDGET");
+				}
+				if (busy) {
+					lifetime.abort();
+					throw new Error("COMPUTER_BUSY");
+				}
+				busy = true;
+				const operation = host(method, args, AbortSignal.any([combined, context.signal]));
+				inFlight.add(operation);
+				try {
+					return await operation;
+				} catch (error) {
+					if (error instanceof Error && /^COMPUTER_[A-Z_0-9]{1,80}$/.test(error.message)) hostErrorCode = error.message;
+					lifetime.abort();
+					throw error;
+				} finally {
+					cancelledHostCall ||= context.signal.aborted || combined.aborted;
+					inFlight.delete(operation);
+					busy = false;
+				}
+			}
+		}))
+	});
+	try {
+		const result = await sandbox.execute(code, {
+			store,
+			signal: combined
+		});
+		const unawaited = inFlight.size > 0;
+		ended = true;
+		lifetime.abort();
+		await Promise.allSettled([...inFlight]);
+		const text = result.output.filter((item) => item.type === "text").map((item) => item.text).join("\n").slice(0, 16e3);
+		if (unawaited || cancelledHostCall || hostErrorCode) return {
+			status: "program_error",
+			output: text,
+			errorCode: hostErrorCode ?? "COMPUTER_PROGRAM_UNAWAITED_CALL",
+			scriptError: "aborted"
+		};
+		if (result.ok === false) return {
+			status: "program_error",
+			output: text,
+			errorCode: hostErrorCode ?? "COMPUTER_PROGRAM_FAILED",
+			scriptError: result.error.kind,
+			scriptErrorMessage: result.error.message.slice(0, 1e3)
+		};
+		const next = { ...store };
+		for (const key of result.storeWrites.delete) delete next[key];
+		Object.assign(next, result.storeWrites.set);
+		if (Object.keys(next).length > 64 || Buffer.byteLength(JSON.stringify(next)) > 64 * 1024) throw new Error("COMPUTER_PROGRAM_STORE_LIMIT");
+		z.record(z.string(), z.json()).parse(next);
+		for (const key of Object.keys(store)) delete store[key];
+		Object.assign(store, next);
+		return {
+			status: "program_completed",
+			output: text
+		};
+	} finally {
+		ended = true;
+		lifetime.abort();
+		await sandbox.close();
+		await Promise.allSettled([...inFlight]);
+	}
+}
+//#endregion
+export { executeComputerProgram };