pi-agent-browser-native 0.9.4 → 0.9.6

package/dist/extensions/agent-browser/lib/orchestration/extension-branch-restore.js

@@ -1,275 +0,0 @@
-import { format } from "node:util";
-import { SessionPageState } from "../session-page-state.js";
-import { getBrowserRecord } from "../browser-transcript.js";
-import { readBrowserEntries } from "../browser-journal.js";
-import { createFreshSessionName, isRestorableManagedSessionName, restoreManagedSessionStateFromBranch, } from "../runtime.js";
-import { getAgentBrowserSessionIdentityKey } from "../argv-grammar.js";
-import { getActiveElectronRecords, getSessionContextKey } from "./browser-run/session-state.js";
-import { restoreElectronLaunchRecordsFromBranch, } from "./electron-host/index.js";
-import { restoreArtifactManifestFromBranch } from "./extension-result-state.js";
-import { trackOwnedManagedSession, untrackOwnedManagedSessionFromBranchClose, } from "./extension-managed-ownership.js";
-import { collectBranchManagedResourceEvents } from "./extension-resource-replay.js";
-import { collectPendingOwnedBrowserIntents } from "./extension-intent-replay.js";
-import { restoreAttachedSessionKeysFromBranch } from "./extension-attachment-replay.js";
-async function readBranchForRestore(runtime, ctx, resetRuntimeOwnership) {
-    runtime.branch.beginRestore(ctx.sessionManager.getSessionId());
-    runtime.prompt.restore(ctx);
-    const previous = {
-        active: runtime.managed.active,
-        sessionName: runtime.managed.name,
-        freshOrdinal: runtime.managed.freshOrdinal,
-        attachedKeys: runtime.sessions.attached,
-        pageState: runtime.sessions.pages,
-    };
-    runtime.managed.initializeBase(ctx.sessionManager.getSessionId(), ctx.cwd, runtime.ephemeralSessionSeed);
-    try {
-        const branch = await readBrowserEntries(ctx.sessionManager);
-        runtime.branch.setReplayError(undefined);
-        return { previous, branch, resetRuntimeOwnership };
-    }
-    catch (error) {
-        runtime.branch.setReplayError(error instanceof Error ? error.message : format("%s", error));
-        runtime.sessions.pages.reset();
-        throw error;
-    }
-}
-function headedLaunchTracking(launch) {
-    return {
-        headedManagedAutosaveDisabled: launch?.headedManagedAutosaveDisabled ?? false,
-        headedManagedAutosaveInterval: launch?.headedManagedAutosaveInterval,
-        socketDir: launch?.socketDir,
-    };
-}
-class BrowserBranchRestoration {
-    runtime;
-    ctx;
-    input;
-    branchResourceEvents;
-    restoredState;
-    constructor(runtime, ctx, input) {
-        this.runtime = runtime;
-        this.ctx = ctx;
-        this.input = input;
-        this.branchResourceEvents = collectBranchManagedResourceEvents(input.branch);
-        this.restoredState = restoreManagedSessionStateFromBranch([...input.branch], runtime.managed.baseName);
-    }
-    currentLaunch() {
-        return this.branchResourceEvents.managedSessionLaunchState.get(getSessionContextKey(this.runtime.managed.name, this.runtime.managed.namespace) ??
-            this.runtime.managed.name);
-    }
-    restoreManagedState() {
-        this.runtime.managed.restore.replace([...this.restoredState.managedSessionRestoreDisabledIdentities], {
-            preserveDaemonRestoreKeys: !this.input.resetRuntimeOwnership,
-        });
-        this.runtime.managed.active = this.restoredState.active;
-    }
-    alreadyReservedPostClose(ordinal, shouldReserve) {
-        return (shouldReserve &&
-            !this.input.resetRuntimeOwnership &&
-            !this.input.previous.active &&
-            this.input.previous.freshOrdinal > this.restoredState.freshSessionOrdinal &&
-            this.input.previous.freshOrdinal === ordinal &&
-            this.input.previous.sessionName ===
-                createFreshSessionName(this.runtime.managed.baseName, this.runtime.ephemeralSessionSeed, ordinal));
-    }
-    reserveSession() {
-        const restoredFreshSessionOrdinal = this.input.resetRuntimeOwnership
-            ? this.restoredState.freshSessionOrdinal
-            : Math.max(this.input.previous.freshOrdinal, this.restoredState.freshSessionOrdinal);
-        const shouldReservePostCloseSession = !this.restoredState.active &&
-            this.restoredState.closedSessionName === this.restoredState.sessionName;
-        const alreadyReservedPostCloseSession = this.alreadyReservedPostClose(restoredFreshSessionOrdinal, shouldReservePostCloseSession);
-        const nextFreshSessionOrdinal = shouldReservePostCloseSession && !alreadyReservedPostCloseSession
-            ? restoredFreshSessionOrdinal + 1
-            : restoredFreshSessionOrdinal;
-        if (!shouldReservePostCloseSession) {
-            this.runtime.managed.name = this.restoredState.sessionName;
-        }
-        else if (alreadyReservedPostCloseSession) {
-            this.runtime.managed.name = this.input.previous.sessionName;
-        }
-        else {
-            this.runtime.managed.name = createFreshSessionName(this.runtime.managed.baseName, this.runtime.ephemeralSessionSeed, nextFreshSessionOrdinal);
-        }
-        this.runtime.managed.freshOrdinal = nextFreshSessionOrdinal;
-        this.runtime.managed.namespace = shouldReservePostCloseSession
-            ? undefined
-            : this.restoredState.namespace;
-    }
-    restoreLaunchState() {
-        const currentLaunch = this.currentLaunch();
-        this.runtime.managed.compatibilityWorkaround = this.runtime.managed.active
-            ? currentLaunch?.compatibilityWorkaround
-            : undefined;
-        this.runtime.managed.headedAutosaveDisabled =
-            this.runtime.managed.active && currentLaunch?.headedManagedAutosaveDisabled === true;
-        this.runtime.managed.headedAutosaveInterval = this.runtime.managed.active
-            ? currentLaunch?.headedManagedAutosaveInterval
-            : undefined;
-        this.runtime.managed.cwd = currentLaunch?.cwd ?? this.ctx.cwd;
-    }
-    restoreRecordingState() {
-        this.runtime.sessions.pages = SessionPageState.fromBranch([...this.input.branch]);
-        this.runtime.sessions.traces = new Map();
-        this.runtime.artifacts.manifest = restoreArtifactManifestFromBranch(this.input.branch);
-        this.runtime.recordings.restore(this.input.branch);
-    }
-    restoreAttachments() {
-        this.runtime.sessions.attached = restoreAttachedSessionKeysFromBranch(this.input.branch);
-        this.runtime.sessions.routes = new Map();
-        this.runtime.electron.records = restoreElectronLaunchRecordsFromBranch([...this.input.branch]);
-        for (const record of getActiveElectronRecords(this.runtime.electron.records)) {
-            if (record.sessionName !== undefined && record.sessionName !== "") {
-                this.runtime.sessions.attached.add(getSessionContextKey(record.sessionName, record.namespace) ?? record.sessionName);
-            }
-        }
-    }
-    restoreOwnershipRanks() {
-        if (this.input.resetRuntimeOwnership) {
-            this.runtime.managed.owned.clear();
-            this.runtime.electron.resetOwnership();
-        }
-        else {
-            for (const [sessionName, closeRank] of this.branchResourceEvents.managedSessionCloseRanks) {
-                untrackOwnedManagedSessionFromBranchClose(this.runtime.managed.owned, sessionName, this.branchResourceEvents.managedSessionActiveRanks.get(sessionName), closeRank);
-            }
-            this.runtime.electron.removeInactive(this.runtime.electron.records, this.branchResourceEvents.electronLaunchActiveRanks, this.branchResourceEvents.electronLaunchCleanupRanks);
-        }
-    }
-    restoreManagedOwners() {
-        for (const [sessionKey, identity] of this.branchResourceEvents.managedSessionActiveIdentities) {
-            this.restoreBranchManagedOwner(sessionKey, identity);
-        }
-        if (this.restoredState.active) {
-            trackOwnedManagedSession(this.runtime.managed.owned, this.restoredState.sessionName, this.runtime.managed.cwd, {
-                branchOwned: true,
-                compatibilityWorkaround: this.runtime.managed.compatibilityWorkaround,
-                headedManagedAutosaveDisabled: this.runtime.managed.headedAutosaveDisabled,
-                headedManagedAutosaveInterval: this.runtime.managed.headedAutosaveInterval,
-                namespace: this.restoredState.namespace,
-                socketDir: this.currentLaunch()?.socketDir,
-            });
-        }
-    }
-    sessionActiveOnBranch(key) {
-        const active = this.branchResourceEvents.managedSessionActiveRanks.get(key);
-        const closed = this.branchResourceEvents.managedSessionCloseRanks.get(key);
-        return active !== undefined && (closed === undefined || closed < active);
-    }
-    restoreBranchManagedOwner(key, identity) {
-        if (!this.sessionActiveOnBranch(key) ||
-            !isRestorableManagedSessionName(identity.sessionName, this.runtime.managed.baseName)) {
-            return;
-        }
-        const launch = this.branchResourceEvents.managedSessionLaunchState.get(key);
-        trackOwnedManagedSession(this.runtime.managed.owned, identity.sessionName, launch?.cwd ?? this.ctx.cwd, {
-            branchOwned: true,
-            compatibilityWorkaround: launch?.compatibilityWorkaround,
-            headedManagedAutosaveDisabled: launch?.headedManagedAutosaveDisabled ?? false,
-            headedManagedAutosaveInterval: launch?.headedManagedAutosaveInterval,
-            namespace: identity.namespace,
-            socketDir: launch?.socketDir,
-        });
-    }
-    restoreInterruptedIntents() {
-        for (const begin of collectPendingOwnedBrowserIntents(this.input.branch, this.runtime.branch.ownerSessionId)) {
-            if (typeof begin.state.sessionName !== "string") {
-                continue;
-            }
-            // The persisted wrapper-selected intent proves cleanup scope, not launch success.
-            trackOwnedManagedSession(this.runtime.managed.owned, begin.state.sessionName, typeof begin.state.managedSessionCwd === "string"
-                ? begin.state.managedSessionCwd
-                : this.ctx.cwd, {
-                branchOwned: true,
-                namespace: typeof begin.state.namespace === "string" ? begin.state.namespace : undefined,
-                socketDir: typeof begin.state.managedSessionSocketDir === "string"
-                    ? begin.state.managedSessionSocketDir
-                    : undefined,
-            });
-        }
-    }
-    restoreElectronOwners() {
-        for (const record of getActiveElectronRecords(this.runtime.electron.records)) {
-            this.restoreElectronOwner(record);
-        }
-        this.runtime.electron.mergeActive(new Map([...this.runtime.electron.records].filter(([, record]) => record.ownerSessionId === this.runtime.branch.ownerSessionId)), { markBranchOwned: true });
-    }
-    restoreElectronOwner(record) {
-        const session = record.sessionName;
-        if (session === undefined ||
-            session === "" ||
-            !isRestorableManagedSessionName(session, this.runtime.managed.baseName)) {
-            return;
-        }
-        const key = getSessionContextKey(session) ?? session;
-        if (!this.sessionActiveOnBranch(key)) {
-            return;
-        }
-        const launch = this.branchResourceEvents.managedSessionLaunchState.get(key);
-        trackOwnedManagedSession(this.runtime.managed.owned, session, launch?.cwd ?? this.ctx.cwd, {
-            branchOwned: true,
-            ...headedLaunchTracking(launch),
-        });
-    }
-    restoreDaemonReceipts() {
-        for (const entry of this.input.branch) {
-            const event = getBrowserRecord(entry)?.event;
-            if (event && event.phase !== "begin") {
-                this.restoreDaemonReceipt(event.state);
-            }
-        }
-    }
-    restoreDaemonReceipt(state) {
-        if (state.ownerSessionId !== this.runtime.branch.ownerSessionId ||
-            typeof state.sessionName !== "string") {
-            return;
-        }
-        const namespace = typeof state.namespace === "string" ? state.namespace : undefined;
-        const key = getAgentBrowserSessionIdentityKey(state.sessionName, namespace);
-        if (this.runtime.managed.owned.has(key) &&
-            !this.runtime.managed.restore.hasDaemonRestoreKey(state.sessionName, namespace)) {
-            this.runtime.managed.restore.restoreDaemonReceipt(state.sessionName, namespace, state.managedSessionDaemon);
-        }
-    }
-    preserveLiveOwners() {
-        if (!this.input.resetRuntimeOwnership) {
-            // Off-branch live owners still need their established setting for cleanup.
-            for (const key of this.runtime.managed.owned.keys()) {
-                if (!this.branchResourceEvents.managedSessionActiveIdentities.has(key)) {
-                    this.runtime.sessions.pages.setConfirmActions(key, this.input.previous.pageState.get(key).confirmActions);
-                }
-            }
-            for (const sessionKey of this.input.previous.attachedKeys) {
-                if (this.runtime.managed.owned.has(sessionKey)) {
-                    this.runtime.sessions.attached.add(sessionKey);
-                }
-            }
-            for (const record of this.runtime.electron.ownedRecords.values()) {
-                const sessionKey = getSessionContextKey(record.sessionName);
-                if (sessionKey !== undefined &&
-                    sessionKey !== "" &&
-                    this.input.previous.attachedKeys.has(sessionKey)) {
-                    this.runtime.sessions.attached.add(sessionKey);
-                }
-            }
-        }
-    }
-    run() {
-        this.restoreManagedState();
-        this.reserveSession();
-        this.restoreLaunchState();
-        this.restoreRecordingState();
-        this.restoreAttachments();
-        this.restoreOwnershipRanks();
-        this.restoreManagedOwners();
-        this.restoreInterruptedIntents();
-        this.restoreElectronOwners();
-        this.restoreDaemonReceipts();
-        this.preserveLiveOwners();
-        return [...this.input.branch];
-    }
-}
-export async function restoreBranchBackedState(runtime, ctx, options) {
-    const input = await readBranchForRestore(runtime, ctx, options.resetRuntimeOwnership);
-    return new BrowserBranchRestoration(runtime, ctx, input).run();
-}

package/dist/extensions/agent-browser/lib/orchestration/extension-code.js

@@ -1,280 +0,0 @@
-import { requirePublishedBrowserJournal } from "../browser-journal.js";
-import { buildExecutionPlan } from "../runtime.js";
-import { extractExplicitSessionName, getAgentBrowserSessionIdentityKey } from "../argv-grammar.js";
-import { isRecord } from "../parsing.js";
-import { getAgentBrowserProcessEnvironment, withAgentBrowserProcessEnvironment, } from "../process-environment.js";
-import { withNativeSessionDefaults } from "./native-session-defaults.js";
-import { getBrowserCwdError, resolveExecutionCwd } from "../execution-cwd.js";
-import { AGENT_BROWSER_SCRIPT_DEFAULT_TIMEOUT_MS, bindBrowserCodeCall, runAgentBrowserScript, } from "../input-modes/script.js";
-import { buildValidationFailureResult, resolveAgentBrowserInput, } from "./input-plan.js";
-import { applyAgentBrowserOutputPath } from "./output-file.js";
-import { createBrowserCodeOutput } from "./script-mode.js";
-import { resolveBrowserExecutionIdentity, withBrowserExecutionLock, } from "../managed-session-policy-lock.js";
-import { loadAgentBrowserConfigSync } from "../config.js";
-import { getArtifactPreflightValidationError } from "./extension-artifact-preflight.js";
-import { browserExecutionFailure } from "./extension-result-state.js";
-import { shouldSerializeBrowserCommand } from "./extension-managed-ownership.js";
-import { shouldIncludeProjectConfig } from "./extension-prompt.js";
-import { executeBrowserInvocation } from "./extension-command-admission.js";
-import { createBrowserInvocation } from "./extension-invocation.js";
-function codePreflight(pi, replayError, invocation) {
-    if (replayError !== undefined && replayError !== "") {
-        return {
-            failure: browserExecutionFailure(new Error(replayError), invocation.signal, "validation-error"),
-        };
-    }
-    try {
-        requirePublishedBrowserJournal(invocation.ctx.sessionManager);
-        return { cwd: resolveExecutionCwd(pi, invocation.ctx) };
-    }
-    catch (error) {
-        return { failure: browserExecutionFailure(error, invocation.signal, "validation-error") };
-    }
-}
-class BrowserCodeExecution {
-    runtime;
-    invocation;
-    operationCwd;
-    deadline;
-    output = createBrowserCodeOutput();
-    nativeEnvironment = getAgentBrowserProcessEnvironment();
-    controller = new AbortController();
-    abort = () => {
-        this.controller.abort(this.invocation.signal?.reason);
-    };
-    commandIndex = 0;
-    journalFailed = false;
-    constructor(runtime, invocation, operationCwd) {
-        this.runtime = runtime;
-        this.invocation = invocation;
-        this.operationCwd = operationCwd;
-        this.deadline =
-            Date.now() + (invocation.params.timeoutMs ?? AGENT_BROWSER_SCRIPT_DEFAULT_TIMEOUT_MS);
-    }
-    start() {
-        const { runtime, invocation } = this;
-        invocation.signal?.addEventListener("abort", this.abort, { once: true });
-        if (invocation.signal?.aborted === true) {
-            this.abort();
-        }
-        runtime.code.controllers.add(this.controller);
-    }
-    prepare() {
-        const { params } = this.invocation;
-        const args = [
-            ...(params.namespace !== undefined ? ["--namespace", params.namespace] : []),
-            ...(params.session !== undefined ? ["--session", params.session] : []),
-            "get",
-            "url",
-        ];
-        const input = resolveAgentBrowserInput({
-            params: { args },
-            getBatchPreflightValidationError: () => {
-                // The identity-selection get-url probe has no batch rows to preflight.
-            },
-        });
-        return input;
-    }
-    browserCwd() {
-        const { runtime, invocation } = this;
-        if (this.nativeEnvironment.AGENT_BROWSER_CONFIG !== undefined) {
-            return this.operationCwd;
-        }
-        const session = invocation.params.session;
-        if (session !== undefined && session !== "") {
-            const key = getAgentBrowserSessionIdentityKey(session, invocation.params.namespace ?? this.nativeEnvironment.AGENT_BROWSER_NAMESPACE);
-            return runtime.managed.owned.get(key)?.cwd ?? invocation.ctx.cwd;
-        }
-        return runtime.managed.active ? runtime.managed.cwd : invocation.ctx.cwd;
-    }
-    nativeRoot() {
-        const { invocation } = this;
-        const config = loadAgentBrowserConfigSync({
-            cwd: invocation.ctx.cwd,
-            includeProjectConfig: shouldIncludeProjectConfig(invocation.ctx),
-        });
-        const profile = config.trustedBrowserDefaultProfile;
-        const root = process.env.PI_SUBAGENT_ROOT_SESSION_ID;
-        const id = process.env.PI_SUBAGENT_CHILD === "1" && root !== undefined && root !== ""
-            ? root
-            : invocation.ctx.sessionManager.getSessionId();
-        return {
-            id,
-            profile: profile?.policy === "always" && !/[\\/~]/.test(profile.name) ? profile.name : undefined,
-            executablePath: config.trustedBrowserExecutablePath,
-        };
-    }
-    async runAdmitted(root, input) {
-        const cwd = this.browserCwd();
-        const error = getBrowserCwdError(cwd);
-        if (error !== undefined && error !== "") {
-            return browserExecutionFailure(new Error(error), this.controller.signal, "validation-error");
-        }
-        const selectedRoot = this.runtime.managed.active || this.runtime.managed.freshOrdinal > 0 ? undefined : root;
-        return withNativeSessionDefaults(input, { cwd, signal: this.controller.signal, root: selectedRoot }, (nativeInput) => this.runNative(nativeInput));
-    }
-    async runNative(input) {
-        const { runtime } = this;
-        const plan = buildExecutionPlan(input.toolArgs, {
-            freshSessionName: runtime.managed.name,
-            managedSessionActive: runtime.managed.active,
-            managedSessionName: runtime.managed.name,
-            managedSessionNamespace: runtime.managed.namespace,
-            sessionMode: "auto",
-        });
-        const sessionName = plan.sessionName ?? "default";
-        const namespace = plan.namespace === "" ? undefined : plan.namespace;
-        const key = getAgentBrowserSessionIdentityKey(sessionName, namespace);
-        const identity = {
-            usedImplicitSession: plan.usedImplicitSession,
-            sessionName,
-            namespace,
-            key,
-            owned: plan.managedSessionName !== undefined || runtime.managed.owned.has(key),
-        };
-        const run = () => this.runLocked(identity);
-        return shouldSerializeBrowserCommand(runtime.managed.owned, runtime.electron.ownedRecords, {
-            namespace,
-            explicitSessionName: sessionName,
-            managedSessionName: runtime.managed.name,
-        })
-            ? runtime.managedSessionExecutionQueue.run(run, this.controller.signal)
-            : runtime.callerOwnedSessionExecutionQueues.run(key, namespace, run, this.controller.signal);
-    }
-    async runLocked(identity) {
-        const socketDir = this.runtime.managed.owned.get(identity.key)?.socketDir;
-        const env = socketDir !== undefined && socketDir !== "" ? { PI_AGENT_BROWSER_SOCKET_DIR: socketDir } : {};
-        return withAgentBrowserProcessEnvironment(env, async () => {
-            const lease = await resolveBrowserExecutionIdentity({
-                sessionName: identity.sessionName,
-                namespace: identity.namespace,
-                ownedManagedSession: identity.owned,
-            });
-            return withBrowserExecutionLock({ identity: lease, deadline: this.deadline, signal: this.controller.signal }, (signal) => this.runCell(signal, identity));
-        });
-    }
-    async dispatch(inner, innerSignal, identity) {
-        if (this.journalFailed) {
-            throw new Error("Browser-state persistence failed. Inspect the current page before continuing in another tool call.");
-        }
-        const bound = bindBrowserCodeCall(inner, {
-            sessionName: identity.sessionName,
-            namespace: identity.namespace,
-        });
-        const args = [...bound.args];
-        if (identity.usedImplicitSession &&
-            !this.runtime.managed.active &&
-            this.runtime.managed.name === identity.sessionName &&
-            extractExplicitSessionName(inner.args) === undefined) {
-            args.splice(args.indexOf("--session"), 2);
-        }
-        const { toolCallId, ctx, branch } = this.invocation;
-        const result = await withAgentBrowserProcessEnvironment({ AGENT_BROWSER_SESSION: this.nativeEnvironment.AGENT_BROWSER_SESSION }, () => executeBrowserInvocation(this.runtime, createBrowserInvocation({
-            toolCallId,
-            params: {
-                args,
-                stdin: inner.stdin,
-                timeoutMs: Math.min(inner.timeoutMs ?? this.deadline - Date.now(), Math.max(1, this.deadline - Date.now())),
-            },
-            signal: innerSignal,
-            ctx,
-            nativeToolCallId: toolCallId,
-            capturedCwd: this.operationCwd,
-            modelVisible: false,
-            commandIndex: this.commandIndex++,
-            selectedBranch: branch,
-        })));
-        if (isRecord(result.details) && result.details.browserStatePersistence !== undefined) {
-            this.journalFailed = true;
-            throw new Error("The browser effect may already have happened and its finish could not be persisted. Inspect before continuing; dependent commands were stopped.");
-        }
-        return this.output.observe(result);
-    }
-    async runCell(signal, identity) {
-        const run = await runAgentBrowserScript({
-            code: this.invocation.params.code,
-            signal,
-            timeoutMs: Math.max(1, this.deadline - Date.now()),
-            emitImage: (image) => this.output.emitImage(image),
-            dispatch: (inner, innerSignal) => this.dispatch(inner, innerSignal, identity),
-        });
-        const result = await this.finish(run, identity);
-        const path = this.invocation.params.outputPath;
-        if (path === undefined || path === "") {
-            return result;
-        }
-        return this.runtime.artifacts.queue.run(() => this.writeOutput(result, path));
-    }
-    async finish(run, identity) {
-        const result = await this.output.finish(run, identity.sessionName, identity.namespace);
-        if (this.journalFailed && isRecord(result.details)) {
-            result.isError = true;
-            result.details.resultCategory = "failure";
-            result.details.failureCategory = "upstream-error";
-            result.details.error =
-                "Browser-state persistence failed. Dependent calls were stopped; inspect before continuing because already-dispatched effects may have happened.";
-        }
-        if (isRecord(result.details)) {
-            result.details.browserEventVersion = 1;
-        }
-        return result;
-    }
-    async writeOutput(result, outputPath) {
-        const error = getArtifactPreflightValidationError({
-            args: [],
-            cwd: this.operationCwd,
-            outputPath,
-            activeRecordingReservations: [...this.runtime.recordings.active.values()],
-        });
-        if (error !== undefined && error !== "") {
-            const failure = browserExecutionFailure(new Error(error), undefined, "validation-error");
-            return {
-                ...result,
-                isError: true,
-                content: [...failure.content, ...result.content],
-                details: {
-                    ...(isRecord(result.details) ? result.details : {}),
-                    ...(isRecord(failure.details) ? failure.details : {}),
-                },
-            };
-        }
-        return applyAgentBrowserOutputPath({
-            cwd: this.operationCwd,
-            outputPath,
-            preserveTextContent: true,
-            result,
-        });
-    }
-    async run() {
-        this.start();
-        const timer = setTimeout(() => this.controller.abort(new DOMException("Browser code deadline exceeded.", "TimeoutError")), Math.max(0, this.deadline - Date.now()));
-        try {
-            const input = this.prepare();
-            if (input.status === "invalid") {
-                return buildValidationFailureResult(input);
-            }
-            const root = this.nativeRoot();
-            const session = this.invocation.params.session;
-            const implicit = (session === undefined || session === "") &&
-                this.nativeEnvironment.AGENT_BROWSER_CONFIG === undefined;
-            return await (implicit
-                ? this.runtime.managedSessionExecutionQueue.run(() => this.runAdmitted(root, input), this.controller.signal)
-                : this.runAdmitted(root, input));
-        }
-        catch (error) {
-            return browserExecutionFailure(error, this.controller.signal);
-        }
-        finally {
-            clearTimeout(timer);
-            this.runtime.code.controllers.delete(this.controller);
-            this.invocation.signal?.removeEventListener("abort", this.abort);
-        }
-    }
-}
-export function executeCode(runtime, invocation) {
-    const prepared = codePreflight(runtime.pi, runtime.branch.replayError, invocation);
-    if ("failure" in prepared) {
-        return Promise.resolve(prepared.failure);
-    }
-    return new BrowserCodeExecution(runtime, invocation, prepared.cwd).run();
-}