@modelprofile.com/browser-runtime 1.0.0

package/dist_ts/classes.runtime.js

@@ -0,0 +1,1667 @@
+import * as plugins from './plugins.js';
+import { validateAgentAction } from './actions.js';
+import { BrowserArtifactStore } from './classes.artifactstore.js';
+import { BrowserEgressProxy } from './classes.egressproxy.js';
+import { runProductionConfinementProbe } from './confinement.js';
+import { BrowserRuntimeError } from './errors.js';
+import { browserRuntimeTesting, } from './internal.testing.js';
+import { TransitionMutex, digestToken, digestsEqual, randomId, truncateString, validateBoundedString, validateInteger, validateOptionalInteger, waitBounded, } from './utils.js';
+import { BrowserRuntimeFramedServerPeer } from './classes.framed.js';
+const projectIdMaximum = 128;
+const actorIdMaximum = 128;
+const peerIdMaximum = 128;
+export class BrowserRuntime {
+    options;
+    profileRoot;
+    artifactRoot;
+    lockPath;
+    artifactStore;
+    slots = new Map();
+    capabilitiesByDigest = new Map();
+    capabilitiesById = new Map();
+    failedRevocations = new Set();
+    capabilityMutex = new TransitionMutex();
+    cleanupOperations = new Set();
+    framedPeers = new Set();
+    lockHandle;
+    lockHandleClosed = false;
+    startPromise;
+    stopPromise;
+    lifecycleState = 'stopped';
+    lifecycleEpoch = 0;
+    lifecycleController = new AbortController();
+    pendingCapabilities = 0;
+    pendingCapabilitiesByProject = new Map();
+    constructor(options) {
+        if (!options || typeof options !== 'object') {
+            throw new BrowserRuntimeError('INVALID_INPUT');
+        }
+        if (!plugins.path.isAbsolute(options.runtimeDirectory)) {
+            throw new BrowserRuntimeError('INVALID_INPUT', 'runtimeDirectory must be absolute');
+        }
+        if (typeof options.authorizeCapability !== 'function') {
+            throw new BrowserRuntimeError('INVALID_INPUT', 'authorizeCapability is required');
+        }
+        if (options.audit !== undefined && typeof options.audit !== 'function') {
+            throw new BrowserRuntimeError('INVALID_INPUT', 'audit must be a function');
+        }
+        const testingOptions = browserRuntimeTesting in options
+            && options[browserRuntimeTesting] === true
+            ? options
+            : undefined;
+        const capabilityMaximumTtlMs = validateOptionalInteger(options.capabilityMaximumTtlMs, 'capabilityMaximumTtlMs', 60_000, 24 * 60 * 60 * 1000, 24 * 60 * 60 * 1000);
+        const capabilityDefaultTtlMs = validateOptionalInteger(options.capabilityDefaultTtlMs, 'capabilityDefaultTtlMs', 1000, capabilityMaximumTtlMs, 5 * 60_000);
+        const environment = testingOptions?.environment ?? {
+            platform: process.platform,
+            uid: process.getuid?.(),
+        };
+        if (!environment
+            || typeof environment.platform !== 'string'
+            || (environment.uid !== undefined && !Number.isInteger(environment.uid))) {
+            throw new BrowserRuntimeError('INVALID_INPUT', 'environment is invalid');
+        }
+        this.options = {
+            runtimeDirectory: options.runtimeDirectory,
+            authorizeCapability: options.authorizeCapability,
+            audit: options.audit,
+            sessionFactory: testingOptions?.sessionFactory ?? ((sessionOptions) => (new plugins.smartpuppeteer.LiveBrowserSession(sessionOptions))),
+            confinementProbe: testingOptions?.confinementProbe ?? runProductionConfinementProbe,
+            environment,
+            maxProjectSlots: validateOptionalInteger(options.maxProjectSlots, 'maxProjectSlots', 1, 256, 32),
+            maxCapabilities: validateOptionalInteger(options.maxCapabilities, 'maxCapabilities', 1, 4096, 512),
+            maxCapabilitiesPerProject: validateOptionalInteger(options.maxCapabilitiesPerProject, 'maxCapabilitiesPerProject', 1, 512, 64),
+            capabilityDefaultTtlMs,
+            capabilityMaximumTtlMs,
+            authorizationTimeoutMs: validateOptionalInteger(options.authorizationTimeoutMs, 'authorizationTimeoutMs', 100, 120_000, 10_000),
+            maxTabsPerProject: validateOptionalInteger(options.maxTabsPerProject, 'maxTabsPerProject', 1, 256, 32),
+            operationTimeoutMs: validateOptionalInteger(options.operationTimeoutMs, 'operationTimeoutMs', 100, 120_000, 30_000),
+            quiescenceTimeoutMs: validateOptionalInteger(options.quiescenceTimeoutMs, 'quiescenceTimeoutMs', 100, 60_000, 5000),
+            terminationGraceMs: validateOptionalInteger(options.terminationGraceMs, 'terminationGraceMs', 100, 60_000, 5000),
+            terminationForceMs: validateOptionalInteger(options.terminationForceMs, 'terminationForceMs', 100, 60_000, 5000),
+            auditTimeoutMs: validateOptionalInteger(options.auditTimeoutMs, 'auditTimeoutMs', 100, 30_000, 2000),
+            confinementProbeTimeoutMs: validateOptionalInteger(options.confinementProbeTimeoutMs, 'confinementProbeTimeoutMs', 1000, 60_000, 10_000),
+            idleRetirementMs: validateOptionalInteger(options.idleRetirementMs, 'idleRetirementMs', 1000, 24 * 60 * 60 * 1000, 15 * 60_000),
+            maxFrameBytes: validateOptionalInteger(options.maxFrameBytes, 'maxFrameBytes', 64 * 1024, 16 * 1024 * 1024, 4 * 1024 * 1024),
+            frameAcknowledgementTimeoutMs: validateOptionalInteger(options.frameAcknowledgementTimeoutMs, 'frameAcknowledgementTimeoutMs', 100, 60_000, 10_000),
+            egress: options.egress ?? {},
+        };
+        this.profileRoot = plugins.path.join(options.runtimeDirectory, 'profiles');
+        this.artifactRoot = plugins.path.join(options.runtimeDirectory, 'artifacts');
+        this.lockPath = plugins.path.join(options.runtimeDirectory, 'runtime.lock');
+        this.artifactStore = new BrowserArtifactStore({
+            rootDirectory: this.artifactRoot,
+            ...(options.artifacts ?? {}),
+        });
+    }
+    start() {
+        if (this.lifecycleState === 'running')
+            return Promise.resolve();
+        if (this.startPromise)
+            return this.startPromise;
+        if (this.stopPromise)
+            return this.stopPromise.then(() => this.start());
+        this.lifecycleState = 'starting';
+        const epoch = ++this.lifecycleEpoch;
+        this.lifecycleController = new AbortController();
+        this.startPromise = this.startInternal().then(() => {
+            if (this.lifecycleState !== 'starting'
+                || this.lifecycleEpoch !== epoch
+                || this.lifecycleController.signal.aborted)
+                throw new BrowserRuntimeError('ABORTED');
+            this.lifecycleState = 'running';
+        }).catch((error) => {
+            if (this.lifecycleState === 'starting')
+                this.lifecycleState = 'stopped';
+            throw error;
+        }).finally(() => {
+            this.startPromise = undefined;
+        });
+        return this.startPromise;
+    }
+    stop() {
+        if (this.stopPromise)
+            return this.stopPromise;
+        if (this.lifecycleState === 'stopped' && !this.lockHandle && !this.startPromise) {
+            return Promise.resolve();
+        }
+        this.lifecycleState = 'stopping';
+        this.lifecycleEpoch += 1;
+        this.lifecycleController.abort(new BrowserRuntimeError('ABORTED'));
+        const startup = this.startPromise;
+        this.stopPromise = (async () => {
+            await startup?.catch(() => undefined);
+            await this.stopInternal();
+            this.lifecycleState = 'stopped';
+        })().finally(() => {
+            this.stopPromise = undefined;
+        });
+        return this.stopPromise;
+    }
+    async issueCapability(requestArg) {
+        this.requireRunning();
+        if (!requestArg || typeof requestArg !== 'object') {
+            throw new BrowserRuntimeError('INVALID_INPUT');
+        }
+        const projectId = validateBoundedString(requestArg.projectId, 'projectId', 1, projectIdMaximum);
+        const actorId = validateBoundedString(requestArg.actorId, 'actorId', 1, actorIdMaximum);
+        const peerId = validateBoundedString(requestArg.peerId, 'peerId', 1, peerIdMaximum);
+        const role = this.validateRole(requestArg.role);
+        const source = this.validateSource(requestArg.source);
+        if ((role === 'human' && source !== 'human')
+            || (role === 'agent' && source === 'human')) {
+            throw new BrowserRuntimeError('INVALID_INPUT');
+        }
+        if (requestArg.disconnect !== undefined && typeof requestArg.disconnect !== 'function') {
+            throw new BrowserRuntimeError('INVALID_INPUT');
+        }
+        const disconnect = requestArg.disconnect;
+        const scopeId = requestArg.scopeId === undefined
+            ? undefined
+            : validateBoundedString(requestArg.scopeId, 'scopeId', 1, 128);
+        const sessionId = requestArg.sessionId === undefined
+            ? undefined
+            : validateBoundedString(requestArg.sessionId, 'sessionId', 1, 128);
+        if ((source === 'flex' && (!scopeId || !sessionId))
+            || (source !== 'flex' && (scopeId !== undefined || sessionId !== undefined)))
+            throw new BrowserRuntimeError('INVALID_INPUT');
+        const expiresInMs = requestArg.expiresInMs === undefined
+            ? this.options.capabilityDefaultTtlMs
+            : validateInteger(requestArg.expiresInMs, 'expiresInMs', 1000, this.options.capabilityMaximumTtlMs);
+        const lifecycleEpoch = this.lifecycleEpoch;
+        const pendingForProject = this.pendingCapabilitiesByProject.get(projectId) ?? 0;
+        const activeForProject = [...this.capabilitiesById.values()].filter((record) => (record.projectId === projectId && record.state === 'active')).length;
+        if (this.pendingCapabilities + this.capabilitiesById.size >= this.options.maxCapabilities
+            || pendingForProject + activeForProject >= this.options.maxCapabilitiesPerProject)
+            throw new BrowserRuntimeError('QUOTA_EXCEEDED');
+        this.pendingCapabilities += 1;
+        this.pendingCapabilitiesByProject.set(projectId, pendingForProject + 1);
+        let authorized = false;
+        const authorizationController = new AbortController();
+        const authorizationSignal = AbortSignal.any([
+            authorizationController.signal,
+            this.lifecycleController.signal,
+        ]);
+        try {
+            const authorization = Promise.resolve(this.options.authorizeCapability({
+                projectId,
+                actorId,
+                role,
+                peerId,
+                source,
+                ...(scopeId ? { scopeId } : {}),
+                ...(sessionId ? { sessionId } : {}),
+            }, authorizationSignal));
+            const result = await waitBounded(authorization, this.options.authorizationTimeoutMs);
+            if (!result.settled) {
+                authorizationController.abort(new BrowserRuntimeError('TIMEOUT'));
+                throw new BrowserRuntimeError('TIMEOUT');
+            }
+            authorized = result.value;
+        }
+        catch {
+            throw new BrowserRuntimeError('AUTHORIZATION_DENIED');
+        }
+        finally {
+            authorizationController.abort(new BrowserRuntimeError('ABORTED'));
+            this.pendingCapabilities -= 1;
+            const remaining = (this.pendingCapabilitiesByProject.get(projectId) ?? 1) - 1;
+            if (remaining > 0)
+                this.pendingCapabilitiesByProject.set(projectId, remaining);
+            else
+                this.pendingCapabilitiesByProject.delete(projectId);
+        }
+        if (authorized !== true)
+            throw new BrowserRuntimeError('AUTHORIZATION_DENIED');
+        this.requireRunning();
+        if (this.lifecycleEpoch !== lifecycleEpoch)
+            throw new BrowserRuntimeError('ABORTED');
+        const release = await this.capabilityMutex.acquire();
+        try {
+            this.requireRunning();
+            if (this.lifecycleEpoch !== lifecycleEpoch)
+                throw new BrowserRuntimeError('ABORTED');
+            const activeProjectCapabilities = [...this.capabilitiesById.values()].filter((record) => (record.projectId === projectId && record.state === 'active')).length;
+            if (this.capabilitiesById.size >= this.options.maxCapabilities
+                || activeProjectCapabilities >= this.options.maxCapabilitiesPerProject) {
+                throw new BrowserRuntimeError('QUOTA_EXCEEDED');
+            }
+            this.getOrCreateSlot(projectId);
+            let capabilityToken;
+            let digest;
+            let digestKey;
+            do {
+                capabilityToken = randomId(32);
+                digest = digestToken(capabilityToken);
+                digestKey = digest.toString('hex');
+            } while (this.capabilitiesByDigest.has(digestKey));
+            const capabilityId = randomId(18);
+            const expiresAt = Date.now() + expiresInMs;
+            let record;
+            const expiryTimer = setTimeout(() => {
+                if (record.state === 'active')
+                    record.state = 'expired';
+                this.trackCleanup(this.revokeCapabilityRecord(record));
+            }, expiresInMs);
+            record = {
+                capabilityId,
+                projectId,
+                actorId,
+                role,
+                peerId,
+                source,
+                ...(scopeId ? { scopeId } : {}),
+                ...(sessionId ? { sessionId } : {}),
+                expiresAt,
+                digest,
+                state: 'active',
+                disconnect,
+                expiryTimer,
+            };
+            record.expiryTimer.unref();
+            this.capabilitiesByDigest.set(digestKey, record);
+            this.capabilitiesById.set(capabilityId, record);
+            return {
+                capabilityId,
+                projectId,
+                actorId,
+                role,
+                peerId,
+                source,
+                ...(scopeId ? { scopeId } : {}),
+                ...(sessionId ? { sessionId } : {}),
+                expiresAt,
+                capabilityToken,
+            };
+        }
+        finally {
+            release();
+        }
+    }
+    async acquireLease(optionsArg) {
+        this.requireRunning();
+        if (!optionsArg || typeof optionsArg !== 'object') {
+            throw new BrowserRuntimeError('INVALID_INPUT');
+        }
+        const peerId = validateBoundedString(optionsArg.peerId, 'peerId', 1, peerIdMaximum);
+        const expectedRole = optionsArg.expectedRole === undefined
+            ? undefined
+            : this.validateRole(optionsArg.expectedRole);
+        const expectedSource = optionsArg.expectedSource === undefined
+            ? undefined
+            : this.validateSource(optionsArg.expectedSource);
+        const scopeId = optionsArg.scopeId === undefined
+            ? undefined
+            : validateBoundedString(optionsArg.scopeId, 'scopeId', 1, 128);
+        const sessionId = optionsArg.sessionId === undefined
+            ? undefined
+            : validateBoundedString(optionsArg.sessionId, 'sessionId', 1, 128);
+        this.throwIfAcquisitionAborted(optionsArg.signal);
+        const capabilityToken = validateBoundedString(optionsArg.capabilityToken, 'capabilityToken', 16, 512);
+        const digest = digestToken(capabilityToken);
+        const capability = this.resolveCapability(digest, peerId, expectedRole, expectedSource, scopeId, sessionId);
+        const slot = this.getOrCreateSlot(capability.projectId);
+        return capability.role === 'agent'
+            ? this.acquireAgentLease(slot, capability, digest, optionsArg)
+            : this.acquireHumanLease(slot, capability, digest, optionsArg);
+    }
+    authorizeCapability(capabilityTokenArg, peerIdArg, role, source) {
+        this.requireRunning();
+        const token = validateBoundedString(capabilityTokenArg, 'capabilityToken', 16, 512);
+        const peerId = validateBoundedString(peerIdArg, 'peerId', 1, peerIdMaximum);
+        const record = this.resolveCapability(digestToken(token), peerId, role, source);
+        return this.describeCapability(record);
+    }
+    async revokeCapability(capabilityIdArg) {
+        const capabilityId = validateBoundedString(capabilityIdArg, 'capabilityId', 1, 128);
+        const capability = this.capabilitiesById.get(capabilityId);
+        if (!capability)
+            return;
+        await this.revokeCapabilityRecord(capability);
+    }
+    async disconnectPeer(peerIdArg) {
+        const peerId = validateBoundedString(peerIdArg, 'peerId', 1, peerIdMaximum);
+        const matching = [...this.capabilitiesById.values()].filter((record) => (record.peerId === peerId && record.state === 'active'));
+        const results = await Promise.allSettled(matching.map((record) => this.revokeCapabilityRecord(record, false)));
+        const errors = results
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (errors.length > 0)
+            throw new AggregateError(errors, 'Peer cleanup is incomplete');
+    }
+    async retireProject(projectIdArg) {
+        const projectId = validateBoundedString(projectIdArg, 'projectId', 1, projectIdMaximum);
+        const capabilities = [...this.capabilitiesById.values()].filter((record) => (record.projectId === projectId));
+        const results = await Promise.allSettled(capabilities.map((record) => this.revokeCapabilityRecord(record)));
+        const errors = results
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (errors.length > 0)
+            throw new AggregateError(errors, 'Project capability cleanup is incomplete');
+        await this.retireSlot(projectId, true);
+    }
+    attachTrustedFramedPeer(options) {
+        this.requireRunning();
+        const peerId = validateBoundedString(options.peerId, 'peerId', 1, peerIdMaximum);
+        if ([...this.framedPeers].some((peer) => peer.peerId === peerId)) {
+            throw new BrowserRuntimeError('BUSY');
+        }
+        const peer = new BrowserRuntimeFramedServerPeer(this, options, () => {
+            this.framedPeers.delete(peer);
+        });
+        this.framedPeers.add(peer);
+        peer.start();
+        return peer;
+    }
+    getArtifactStore() {
+        return this.artifactStore;
+    }
+    /** @internal */
+    getLeaseState(lease) {
+        this.requireValidLease(lease);
+        const session = lease.slot.session;
+        return this.projectState(session.getState());
+    }
+    /** @internal */
+    async executeLeaseAgentAction(lease, actionArg, operationOptions = {}) {
+        if (lease.role !== 'agent')
+            throw new BrowserRuntimeError('CAPABILITY_INVALID');
+        const action = validateAgentAction(actionArg);
+        return this.runOperation(lease, action.action, operationOptions, async (signal, session) => (this.executeAgentActionInternal(lease, session, action, signal)));
+    }
+    /** @internal */
+    async leaseCreateTab(lease, options = {}, operationOptions = {}) {
+        this.requireHuman(lease);
+        return this.runOperation(lease, 'createTab', operationOptions, async (signal, session) => {
+            if (session.getState().tabs.length >= this.options.maxTabsPerProject) {
+                throw new BrowserRuntimeError('QUOTA_EXCEEDED');
+            }
+            await session.createTab(options, { signal });
+            return this.projectState(session.getState());
+        });
+    }
+    /** @internal */
+    async leaseActivateTab(lease, tabIdArg, operationOptions = {}) {
+        this.requireHuman(lease);
+        const tabId = validateBoundedString(tabIdArg, 'tabId', 1, 128);
+        return this.runOperation(lease, 'activateTab', operationOptions, async (signal, session) => {
+            await session.activateTab(tabId, { signal });
+            return this.projectState(session.getState());
+        });
+    }
+    /** @internal */
+    async leaseCloseTab(lease, tabIdArg, operationOptions = {}) {
+        this.requireHuman(lease);
+        const tabId = validateBoundedString(tabIdArg, 'tabId', 1, 128);
+        return this.runOperation(lease, 'closeTab', operationOptions, async (signal, session) => {
+            await session.closeTab(tabId, { signal });
+            return this.projectState(session.getState());
+        });
+    }
+    /** @internal */
+    async leaseHistory(lease, action, options = {}, operationOptions = {}) {
+        this.requireHuman(lease);
+        return this.runOperation(lease, action, operationOptions, async (signal, session) => {
+            await session[action](options, { signal });
+            return this.projectState(session.getState());
+        });
+    }
+    /** @internal */
+    async leaseHumanAgentAction(lease, actionArg, operationOptions = {}) {
+        this.requireHuman(lease);
+        const action = validateAgentAction(actionArg);
+        return this.runOperation(lease, action.action, operationOptions, async (signal, session) => (this.executeAgentActionInternal(lease, session, action, signal)));
+    }
+    /** @internal */
+    async leaseSetViewport(lease, viewport, operationOptions = {}) {
+        this.requireHuman(lease);
+        await this.runOperation(lease, 'setViewport', operationOptions, async (signal, session) => {
+            await session.setViewport(viewport, { signal });
+        });
+    }
+    /** @internal */
+    async leaseDispatchRawInput(lease, action, input, operationOptions = {}) {
+        this.requireHuman(lease);
+        await this.runOperation(lease, action, operationOptions, async (_signal, session) => {
+            if (action === 'dispatchMouse') {
+                await session.dispatchMouse(input);
+            }
+            else if (action === 'dispatchWheel') {
+                await session.dispatchWheel(input);
+            }
+            else if (action === 'dispatchKey') {
+                await session.dispatchKey(input);
+            }
+            else {
+                await session.insertText(input);
+            }
+        });
+    }
+    /** @internal */
+    async subscribeLeaseEvents(lease, listener) {
+        this.requireHuman(lease);
+        if (typeof listener !== 'function')
+            throw new BrowserRuntimeError('INVALID_INPUT');
+        const slot = lease.slot;
+        const release = await slot.mutex.acquire();
+        let subscription;
+        try {
+            this.requireValidLease(lease);
+            if (slot.frameSubscription)
+                throw new BrowserRuntimeError('BUSY');
+            subscription = { lease, listener, closed: false };
+            slot.frameSubscription = subscription;
+            this.pushToSubscription(subscription, {
+                type: 'state',
+                state: this.projectState(slot.session.getState()),
+            });
+        }
+        finally {
+            release();
+        }
+        return {
+            close: async () => this.closeFrameSubscription(subscription),
+        };
+    }
+    /** @internal */
+    async acknowledgeLeaseFrame(lease, acknowledgement) {
+        this.requireHuman(lease);
+        if (!acknowledgement || typeof acknowledgement !== 'object') {
+            throw new BrowserRuntimeError('INVALID_INPUT');
+        }
+        validateBoundedString(acknowledgement.tabId, 'tabId', 1, 128);
+        validateInteger(acknowledgement.sequence, 'sequence', 0, Number.MAX_SAFE_INTEGER);
+        validateInteger(acknowledgement.generation, 'generation', 0, Number.MAX_SAFE_INTEGER);
+        validateInteger(acknowledgement.viewportRevision, 'viewportRevision', 0, Number.MAX_SAFE_INTEGER);
+        const slot = lease.slot;
+        const subscription = slot.frameSubscription;
+        this.requireValidLease(lease);
+        if (!subscription || subscription.lease !== lease || !subscription.outstanding)
+            return false;
+        const expected = subscription.outstanding.acknowledgement;
+        if (expected.tabId !== acknowledgement.tabId
+            || expected.sequence !== acknowledgement.sequence
+            || expected.generation !== acknowledgement.generation
+            || expected.viewportRevision !== acknowledgement.viewportRevision)
+            return false;
+        clearTimeout(subscription.outstanding.timer);
+        subscription.outstanding = undefined;
+        const session = slot.session;
+        const operation = session.acknowledgeFrame(acknowledgement);
+        const result = await waitBounded(operation, this.options.frameAcknowledgementTimeoutMs)
+            .catch(() => ({ settled: true, value: { accepted: false } }));
+        if (!result.settled || !result.value.accepted) {
+            operation.catch(() => undefined);
+            const errors = [];
+            await this.revokeCapabilityRecord(lease.capability).catch((error) => errors.push(error));
+            if (slot.session === session) {
+                await this.terminateSlotSession(slot).catch((error) => errors.push(error));
+            }
+            if (errors.length === 1)
+                throw errors[0];
+            if (errors.length > 1) {
+                throw new AggregateError(errors, 'Frame acknowledgement cleanup is incomplete');
+            }
+            return false;
+        }
+        return true;
+    }
+    /** @internal */
+    async readLeaseArtifact(lease, artifactId) {
+        this.requireHuman(lease);
+        this.requireValidLease(lease);
+        return this.artifactStore.read(lease.capability.projectId, artifactId);
+    }
+    /** @internal */
+    async deleteLeaseArtifact(lease, artifactId) {
+        this.requireHuman(lease);
+        this.requireValidLease(lease);
+        await this.artifactStore.delete(lease.capability.projectId, artifactId);
+    }
+    /** @internal */
+    cancelLeaseOperation(lease) {
+        this.requireValidLease(lease);
+        const operation = lease.slot.operation;
+        if (!operation || operation.lease !== lease)
+            return false;
+        operation.controller.abort(new BrowserRuntimeError('ABORTED'));
+        return true;
+    }
+    /** @internal */
+    async releaseLease(lease) {
+        await this.releaseLeaseRecord(lease);
+    }
+    async startInternal() {
+        if (this.options.environment.platform !== 'linux') {
+            throw new BrowserRuntimeError('FENCED', 'browser runtime requires Linux');
+        }
+        if (this.options.environment.uid === undefined || this.options.environment.uid === 0) {
+            throw new BrowserRuntimeError('FENCED', 'browser runtime requires a non-root uid');
+        }
+        await plugins.fsPromises.mkdir(this.options.runtimeDirectory, { recursive: true, mode: 0o700 });
+        await plugins.fsPromises.chmod(this.options.runtimeDirectory, 0o700);
+        if (!this.lockHandle) {
+            try {
+                this.lockHandle = await plugins.fsPromises.open(this.lockPath, 'wx', 0o600);
+                this.lockHandleClosed = false;
+                await this.lockHandle.chmod(0o600);
+            }
+            catch (error) {
+                if (error.code === 'EEXIST') {
+                    throw new BrowserRuntimeError('LOCKED');
+                }
+                throw error;
+            }
+        }
+        await plugins.fsPromises.mkdir(this.profileRoot, { recursive: true, mode: 0o700 });
+        await plugins.fsPromises.chmod(this.profileRoot, 0o700);
+        const profileEntries = await plugins.fsPromises.readdir(this.profileRoot);
+        if (profileEntries.length > 0) {
+            throw new BrowserRuntimeError('FENCED', 'profile root is not empty');
+        }
+        await this.artifactStore.start();
+    }
+    async stopInternal() {
+        const peerResults = await Promise.allSettled([...this.framedPeers].map((peer) => peer.close()));
+        const revocationRecords = new Set([
+            ...this.capabilitiesById.values(),
+            ...this.failedRevocations,
+        ]);
+        const revokeResults = await Promise.allSettled([...revocationRecords].map((record) => this.revokeCapabilityRecord(record)));
+        const retirementResults = await Promise.allSettled([...this.slots.keys()].map((projectId) => this.retireSlot(projectId, true)));
+        while (this.cleanupOperations.size > 0) {
+            await Promise.allSettled([...this.cleanupOperations]);
+        }
+        const errors = [...peerResults, ...revokeResults, ...retirementResults]
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (errors.length > 0) {
+            throw new AggregateError(errors, 'Browser runtime cleanup is incomplete');
+        }
+        await this.artifactStore.stop();
+        if (this.lockHandle) {
+            if (!this.lockHandleClosed) {
+                await this.lockHandle.close();
+                this.lockHandleClosed = true;
+            }
+            await plugins.fsPromises.rm(this.lockPath, { force: true });
+            this.lockHandle = undefined;
+            this.lockHandleClosed = false;
+        }
+        this.startPromise = undefined;
+    }
+    requireRunning() {
+        if (this.lifecycleState !== 'running')
+            throw new BrowserRuntimeError('NOT_RUNNING');
+    }
+    getOrCreateSlot(projectId) {
+        let slot = this.slots.get(projectId);
+        if (slot)
+            return slot;
+        if (this.slots.size >= this.options.maxProjectSlots) {
+            throw new BrowserRuntimeError('QUOTA_EXCEEDED');
+        }
+        slot = {
+            projectId,
+            mutex: new TransitionMutex(),
+            generation: 0,
+            permanentlyFenced: false,
+        };
+        this.slots.set(projectId, slot);
+        return slot;
+    }
+    async acquireAgentLease(slot, capability, digest, acquisition) {
+        const release = slot.mutex.tryAcquire();
+        if (!release)
+            throw new BrowserRuntimeError('BUSY');
+        try {
+            this.assertSlotAvailable(slot);
+            this.resolveCapability(digest, capability.peerId, acquisition.expectedRole ?? 'agent', acquisition.expectedSource, acquisition.scopeId, acquisition.sessionId);
+            if (slot.lease || slot.operation)
+                throw new BrowserRuntimeError('BUSY');
+            await this.ensureSession(slot, acquisition.signal);
+            this.throwIfAcquisitionAborted(acquisition.signal);
+            this.resolveCapability(digest, capability.peerId, acquisition.expectedRole ?? 'agent', acquisition.expectedSource, acquisition.scopeId, acquisition.sessionId);
+            const lease = this.createLeaseRecord(slot, capability, digest);
+            return new BrowserRuntimeLease(this, lease);
+        }
+        catch (error) {
+            if (slot.session && !slot.lease)
+                this.scheduleIdleRetirement(slot);
+            throw error;
+        }
+        finally {
+            release();
+        }
+    }
+    async acquireHumanLease(slot, capability, digest, acquisition) {
+        const release = await slot.mutex.acquire();
+        let generation = 0;
+        let preemptedLease;
+        try {
+            this.assertSlotAvailable(slot);
+            this.resolveCapability(digest, capability.peerId, 'human', 'human');
+            this.throwIfAcquisitionAborted(acquisition.signal);
+            if (slot.fencingGeneration !== undefined)
+                throw new BrowserRuntimeError('BUSY');
+            if (slot.lease?.role === 'human')
+                throw new BrowserRuntimeError('BUSY');
+            generation = ++slot.generation;
+            slot.fencingGeneration = generation;
+            preemptedLease = slot.lease;
+            if (preemptedLease) {
+                preemptedLease.released = true;
+                preemptedLease.controller.abort(new BrowserRuntimeError('ABORTED'));
+                slot.operation?.controller.abort(new BrowserRuntimeError('ABORTED'));
+            }
+        }
+        finally {
+            release();
+        }
+        try {
+            if (preemptedLease)
+                await this.quiesceSlot(slot);
+            this.throwIfAcquisitionAborted(acquisition.signal);
+            const finalRelease = await slot.mutex.acquire();
+            try {
+                if (slot.generation !== generation || slot.fencingGeneration !== generation) {
+                    throw new BrowserRuntimeError('BUSY');
+                }
+                if (preemptedLease) {
+                    if (preemptedLease.capability.lease === preemptedLease) {
+                        preemptedLease.capability.lease = undefined;
+                    }
+                    if (slot.lease === preemptedLease)
+                        slot.lease = undefined;
+                }
+                if (slot.permanentlyFenced)
+                    throw new BrowserRuntimeError('FENCED');
+                slot.fencingGeneration = undefined;
+                await this.ensureSession(slot, acquisition.signal);
+                this.throwIfAcquisitionAborted(acquisition.signal);
+                this.resolveCapability(digest, capability.peerId, 'human', 'human');
+                const lease = this.createLeaseRecord(slot, capability, digest);
+                return new BrowserRuntimeLease(this, lease);
+            }
+            finally {
+                finalRelease();
+            }
+        }
+        catch (error) {
+            const cleanupRelease = await slot.mutex.acquire();
+            try {
+                if (preemptedLease) {
+                    if (preemptedLease.capability.lease === preemptedLease) {
+                        preemptedLease.capability.lease = undefined;
+                    }
+                    if (slot.lease === preemptedLease)
+                        slot.lease = undefined;
+                }
+                if (slot.fencingGeneration === generation)
+                    slot.fencingGeneration = undefined;
+                if (slot.session && !slot.lease)
+                    this.scheduleIdleRetirement(slot);
+            }
+            finally {
+                cleanupRelease();
+            }
+            throw error;
+        }
+    }
+    createLeaseRecord(slot, capability, digest) {
+        if (capability.lease || slot.lease)
+            throw new BrowserRuntimeError('BUSY');
+        if (slot.idleTimer) {
+            clearTimeout(slot.idleTimer);
+            slot.idleTimer = undefined;
+        }
+        const lease = {
+            leaseId: randomId(18),
+            capability,
+            digest,
+            peerId: capability.peerId,
+            role: capability.role,
+            slot,
+            controller: new AbortController(),
+            released: false,
+        };
+        slot.lease = lease;
+        capability.lease = lease;
+        return lease;
+    }
+    async ensureSession(slot, signalArg) {
+        if (slot.session)
+            return;
+        this.assertSlotAvailable(slot);
+        const profileDirectory = plugins.path.join(this.profileRoot, randomId(24));
+        let profileCreated = false;
+        let proxy;
+        let session;
+        let unsubscribe;
+        try {
+            await plugins.fsPromises.mkdir(profileDirectory, { mode: 0o700 });
+            profileCreated = true;
+            await plugins.fsPromises.chmod(profileDirectory, 0o700);
+            proxy = new BrowserEgressProxy({
+                projectId: slot.projectId,
+                ...this.options.egress,
+            });
+            await proxy.start();
+            const credentials = proxy.credentials;
+            session = this.options.sessionFactory({
+                requireSandbox: true,
+                forceNoSandbox: false,
+                usePipe: true,
+                allowEvaluation: true,
+                launchOptions: {
+                    headless: true,
+                    userDataDir: profileDirectory,
+                    args: [
+                        `--proxy-server=http://127.0.0.1:${proxy.port}`,
+                        '--proxy-bypass-list=<-loopback>',
+                        '--disable-quic',
+                        '--disable-dns-prefetch',
+                        '--disable-background-networking',
+                        '--disable-extensions',
+                        '--webrtc-ip-handling-policy=disable_non_proxied_udp',
+                        '--host-resolver-rules=MAP * ~NOTFOUND, EXCLUDE 127.0.0.1',
+                    ],
+                },
+                security: {
+                    denyDownloads: true,
+                    denyFileChoosers: true,
+                    denyPermissions: true,
+                    httpNavigationOnly: true,
+                    proxyCredentials: credentials,
+                },
+            });
+            unsubscribe = session.onEvent((event) => {
+                this.handleSessionEvent(slot, session, event);
+            });
+            const timeoutController = new AbortController();
+            const timeout = setTimeout(() => {
+                timeoutController.abort(new BrowserRuntimeError('CONFINEMENT_FAILED'));
+            }, this.options.confinementProbeTimeoutMs);
+            timeout.unref();
+            const probeSignal = AbortSignal.any([
+                this.lifecycleController.signal,
+                signalArg ?? new AbortController().signal,
+                timeoutController.signal,
+            ]);
+            const runBounded = async (operation) => {
+                if (probeSignal.aborted)
+                    throw probeSignal.reason;
+                let onAbort;
+                const aborted = new Promise((_resolve, reject) => {
+                    onAbort = () => reject(probeSignal.reason);
+                    probeSignal.addEventListener('abort', onAbort, { once: true });
+                });
+                try {
+                    await Promise.race([operation, aborted]);
+                }
+                finally {
+                    probeSignal.removeEventListener('abort', onAbort);
+                }
+            };
+            try {
+                await runBounded(session.start({ signal: probeSignal }));
+                await runBounded(this.options.confinementProbe({ session, proxy, signal: probeSignal }));
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+            if (probeSignal.aborted)
+                throw probeSignal.reason;
+            slot.session = session;
+            slot.proxy = proxy;
+            slot.profileDirectory = profileDirectory;
+            slot.unsubscribeSession = unsubscribe;
+        }
+        catch (error) {
+            unsubscribe?.();
+            let confirmed = true;
+            if (session) {
+                try {
+                    const termination = await waitBounded(session.terminate({
+                        gracefulTimeoutMs: this.options.terminationGraceMs,
+                        forceTimeoutMs: this.options.terminationForceMs,
+                    }), this.options.terminationGraceMs + this.options.terminationForceMs + 1000);
+                    confirmed = termination.settled && termination.value.confirmedDead;
+                }
+                catch {
+                    confirmed = false;
+                }
+            }
+            if (!confirmed) {
+                slot.permanentlyFenced = true;
+                slot.session = session;
+                slot.proxy = proxy;
+                slot.profileDirectory = profileDirectory;
+                slot.unsubscribeSession = unsubscribe;
+                throw new BrowserRuntimeError('FENCED');
+            }
+            let proxyStopped = true;
+            let profileRemoved = !profileCreated;
+            if (proxy) {
+                await this.stopProxyBounded(proxy).catch(() => { proxyStopped = false; });
+            }
+            if (profileCreated) {
+                await plugins.fsPromises.rm(profileDirectory, { recursive: true, force: true })
+                    .then(() => { profileRemoved = true; })
+                    .catch(() => undefined);
+            }
+            if (!proxyStopped || !profileRemoved) {
+                slot.permanentlyFenced = true;
+                if (!proxyStopped)
+                    slot.proxy = proxy;
+                if (!profileRemoved)
+                    slot.profileDirectory = profileDirectory;
+                throw new BrowserRuntimeError('FENCED');
+            }
+            if (signalArg?.aborted)
+                throw new BrowserRuntimeError('ABORTED');
+            throw error instanceof BrowserRuntimeError
+                ? error
+                : new BrowserRuntimeError('CONFINEMENT_FAILED');
+        }
+    }
+    async runOperation(lease, action, operationOptions, execute) {
+        if (!operationOptions || typeof operationOptions !== 'object') {
+            throw new BrowserRuntimeError('INVALID_INPUT');
+        }
+        if (operationOptions.signal !== undefined
+            && !(operationOptions.signal instanceof AbortSignal))
+            throw new BrowserRuntimeError('INVALID_INPUT');
+        if (operationOptions.onOperationStarted !== undefined
+            && typeof operationOptions.onOperationStarted !== 'function')
+            throw new BrowserRuntimeError('INVALID_INPUT');
+        operationOptions.signal?.throwIfAborted();
+        const slot = lease.slot;
+        const release = slot.mutex.tryAcquire();
+        if (!release)
+            throw new BrowserRuntimeError('BUSY');
+        let operation;
+        let executionPromise;
+        let combinedSignal;
+        let timeout;
+        let session;
+        let generation;
+        const startedAt = Date.now();
+        try {
+            this.requireValidLease(lease);
+            this.assertSlotAvailable(slot);
+            if (slot.operation)
+                throw new BrowserRuntimeError('BUSY');
+            session = slot.session;
+            generation = slot.generation;
+            const timeoutMs = operationOptions.timeoutMs === undefined
+                ? this.options.operationTimeoutMs
+                : validateInteger(operationOptions.timeoutMs, 'timeoutMs', 100, 120_000);
+            const controller = new AbortController();
+            const timeoutController = new AbortController();
+            timeout = setTimeout(() => {
+                timeoutController.abort(new BrowserRuntimeError('TIMEOUT'));
+            }, timeoutMs);
+            timeout.unref();
+            combinedSignal = AbortSignal.any([
+                controller.signal,
+                lease.controller.signal,
+                operationOptions.signal ?? new AbortController().signal,
+                timeoutController.signal,
+            ]);
+            executionPromise = Promise.resolve().then(() => execute(combinedSignal, session));
+            operation = {
+                operationId: randomId(18),
+                lease,
+                controller,
+                action,
+                startedAt,
+                promise: executionPromise.then(() => undefined, () => undefined),
+            };
+            slot.operation = operation;
+            try {
+                operationOptions.onOperationStarted?.(operation.operationId);
+            }
+            catch {
+                controller.abort(new BrowserRuntimeError('ABORTED'));
+            }
+        }
+        finally {
+            release();
+        }
+        let phase = 'completed';
+        let errorCode;
+        try {
+            let onAbort;
+            const aborted = new Promise((_resolve, reject) => {
+                onAbort = () => reject(combinedSignal.reason ?? new BrowserRuntimeError('ABORTED'));
+                combinedSignal.addEventListener('abort', onAbort, { once: true });
+            });
+            let result;
+            try {
+                result = await Promise.race([executionPromise, aborted]);
+            }
+            finally {
+                combinedSignal.removeEventListener('abort', onAbort);
+            }
+            if (combinedSignal.aborted)
+                throw combinedSignal.reason;
+            this.requireValidLease(lease);
+            if (slot.session !== session || slot.generation !== generation) {
+                throw new BrowserRuntimeError('ABORTED');
+            }
+            return result;
+        }
+        catch (error) {
+            phase = 'failed';
+            errorCode = error instanceof BrowserRuntimeError
+                ? error.code
+                : error instanceof Error
+                    ? truncateString(error.name, 64)
+                    : 'Error';
+            if (combinedSignal.aborted) {
+                this.trackCleanup(this.enforceOperationQuiescence(operation));
+                const reason = combinedSignal.reason;
+                throw reason instanceof BrowserRuntimeError
+                    ? reason
+                    : new BrowserRuntimeError(reason instanceof Error && reason.name === 'TimeoutError' ? 'TIMEOUT' : 'ABORTED');
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+            executionPromise.finally(async () => {
+                const cleanupRelease = await slot.mutex.acquire();
+                try {
+                    if (slot.operation === operation)
+                        slot.operation = undefined;
+                }
+                finally {
+                    cleanupRelease();
+                }
+            }).catch(() => undefined);
+            await this.emitAudit({
+                operationId: operation.operationId,
+                capabilityId: lease.capability.capabilityId,
+                projectId: lease.capability.projectId,
+                actorId: lease.capability.actorId,
+                role: lease.role,
+                source: lease.capability.source,
+                action,
+                phase,
+                startedAt,
+                finishedAt: Date.now(),
+                ...(errorCode ? { errorCode } : {}),
+            });
+        }
+    }
+    async executeAgentActionInternal(lease, session, action, signal) {
+        if (action.action === 'navigate') {
+            await session.navigate({
+                url: action.url,
+                ...(action.tabId ? { tabId: action.tabId } : {}),
+                ...(action.timeoutMs ? { timeoutMs: action.timeoutMs } : {}),
+            }, { signal });
+            return {
+                action: 'navigate',
+                state: this.projectState(session.getState()),
+            };
+        }
+        if (action.action === 'snapshot') {
+            const observation = await session.observe({
+                ...(action.tabId ? { tabId: action.tabId } : {}),
+                ...(action.maxCharacters ? { maxCharacters: action.maxCharacters } : {}),
+            }, { signal });
+            return {
+                action: 'snapshot',
+                tabId: truncateString(observation.tabId, 128),
+                url: truncateString(observation.url, 8192),
+                title: truncateString(observation.title, 2048),
+                text: truncateString(observation.text, 50_000),
+                truncated: observation.truncated,
+                state: this.projectState(observation.state),
+            };
+        }
+        if (action.action === 'screenshot') {
+            const snapshot = await session.captureSnapshot({
+                ...(action.tabId ? { tabId: action.tabId } : {}),
+                ...(action.format ? { format: action.format } : {}),
+                ...(action.quality !== undefined ? { quality: action.quality } : {}),
+            }, { signal });
+            try {
+                signal.throwIfAborted();
+                this.requireValidLease(lease);
+                if (lease.slot.session !== session)
+                    throw new BrowserRuntimeError('ABORTED');
+                const artifact = await this.artifactStore.store(lease.capability.projectId, snapshot.mimeType, snapshot.data);
+                return { action: 'screenshot', artifact };
+            }
+            finally {
+                snapshot.data.fill(0);
+            }
+        }
+        const target = this.resolveSemanticTarget(session.getState(), action.tabId);
+        if (action.action === 'click') {
+            await session.click({
+                ...target,
+                selector: action.selector,
+                ...(action.timeoutMs ? { timeoutMs: action.timeoutMs } : {}),
+            }, { signal });
+        }
+        else if (action.action === 'fill') {
+            await session.fill({
+                ...target,
+                selector: action.selector,
+                text: action.text,
+                ...(action.timeoutMs ? { timeoutMs: action.timeoutMs } : {}),
+            }, { signal });
+        }
+        else {
+            await session.press({
+                ...target,
+                selector: action.selector,
+                key: action.key,
+                ...(action.timeoutMs ? { timeoutMs: action.timeoutMs } : {}),
+            }, { signal });
+        }
+        return {
+            action: action.action,
+            state: this.projectState(session.getState()),
+        };
+    }
+    resolveSemanticTarget(state, tabIdArg) {
+        const tabId = tabIdArg ?? state.activeTabId;
+        const tab = state.tabs.find((candidate) => candidate.id === tabId);
+        if (!tab)
+            throw new BrowserRuntimeError('INVALID_INPUT');
+        return {
+            tabId: tab.id,
+            generation: tab.generation,
+            viewportRevision: state.viewportRevision,
+        };
+    }
+    projectState(state) {
+        return {
+            status: state.status,
+            activeTabId: state.activeTabId ? truncateString(state.activeTabId, 128) : null,
+            viewportRevision: state.viewportRevision,
+            viewport: {
+                width: state.viewport.width,
+                height: state.viewport.height,
+                deviceScaleFactor: state.viewport.deviceScaleFactor,
+            },
+            tabs: state.tabs.slice(0, 256).map((tab) => ({
+                id: truncateString(tab.id, 128),
+                url: truncateString(tab.url, 8192),
+                title: truncateString(tab.title, 2048),
+                active: tab.active,
+                status: tab.status,
+                generation: tab.generation,
+                appliedViewportRevision: tab.appliedViewportRevision,
+                streaming: tab.streaming,
+            })),
+            ...(state.lastError
+                ? {
+                    lastError: {
+                        code: truncateString(state.lastError.code, 128),
+                        fatal: state.lastError.fatal,
+                        ...(state.lastError.tabId
+                            ? { tabId: truncateString(state.lastError.tabId, 128) }
+                            : {}),
+                    },
+                }
+                : {}),
+        };
+    }
+    handleSessionEvent(slot, session, event) {
+        if (slot.session && slot.session !== session) {
+            if (event.type === 'frame') {
+                this.trackCleanup(this.acknowledgeFrameInBackground(slot, session, {
+                    tabId: event.frame.tabId,
+                    sequence: event.frame.sequence,
+                    generation: event.frame.generation,
+                    viewportRevision: event.frame.viewportRevision,
+                }));
+            }
+            return;
+        }
+        const subscription = slot.frameSubscription;
+        if (event.type === 'frame') {
+            const acknowledgement = {
+                tabId: event.frame.tabId,
+                sequence: event.frame.sequence,
+                generation: event.frame.generation,
+                viewportRevision: event.frame.viewportRevision,
+            };
+            if (!subscription || subscription.closed) {
+                this.trackCleanup(this.acknowledgeFrameInBackground(slot, session, acknowledgement));
+                return;
+            }
+            try {
+                this.requireValidLease(subscription.lease);
+            }
+            catch {
+                this.trackCleanup(this.acknowledgeFrameInBackground(slot, session, acknowledgement));
+                this.trackCleanup(this.revokeCapabilityRecord(subscription.lease.capability));
+                return;
+            }
+            if (subscription.outstanding) {
+                this.trackCleanup(this.acknowledgeFrameInBackground(slot, session, acknowledgement));
+                return;
+            }
+            if (event.frame.data.byteLength > this.options.maxFrameBytes) {
+                this.trackCleanup(this.acknowledgeFrameInBackground(slot, session, acknowledgement));
+                this.pushToSubscription(subscription, {
+                    type: 'error',
+                    error: { code: 'FRAME_TOO_LARGE', fatal: true, tabId: event.frame.tabId },
+                });
+                this.trackCleanup(this.revokeCapabilityRecord(subscription.lease.capability));
+                return;
+            }
+            const timer = setTimeout(() => {
+                if (subscription.outstanding?.acknowledgement.sequence !== acknowledgement.sequence)
+                    return;
+                subscription.outstanding = undefined;
+                this.trackCleanup(this.acknowledgeFrameInBackground(slot, session, acknowledgement));
+                this.trackCleanup(this.revokeCapabilityRecord(subscription.lease.capability));
+            }, this.options.frameAcknowledgementTimeoutMs);
+            timer.unref();
+            subscription.outstanding = { acknowledgement, timer };
+            this.pushToSubscription(subscription, { type: 'frame', frame: event.frame });
+            return;
+        }
+        if (event.type === 'error' && event.error.fatal && slot.lease) {
+            this.trackCleanup(this.revokeCapabilityRecord(slot.lease.capability));
+        }
+        if (!subscription || subscription.closed)
+            return;
+        if (event.type === 'state') {
+            this.pushToSubscription(subscription, { type: 'state', state: this.projectState(event.state) });
+        }
+        else {
+            this.pushToSubscription(subscription, {
+                type: 'error',
+                error: {
+                    code: truncateString(event.error.code, 128),
+                    fatal: event.error.fatal,
+                    ...(event.error.tabId ? { tabId: truncateString(event.error.tabId, 128) } : {}),
+                },
+            });
+        }
+    }
+    pushToSubscription(subscription, event) {
+        try {
+            this.requireValidLease(subscription.lease);
+            subscription.listener(event);
+        }
+        catch {
+            if (event.type === 'frame' && subscription.outstanding) {
+                const outstanding = subscription.outstanding;
+                clearTimeout(outstanding.timer);
+                subscription.outstanding = undefined;
+                this.trackCleanup(this.acknowledgeFrameInBackground(subscription.lease.slot, subscription.lease.slot.session, outstanding.acknowledgement));
+            }
+            this.trackCleanup(this.revokeCapabilityRecord(subscription.lease.capability));
+        }
+    }
+    async closeFrameSubscription(subscription) {
+        if (subscription.closed)
+            return;
+        subscription.closed = true;
+        const slot = subscription.lease.slot;
+        if (slot.frameSubscription === subscription)
+            slot.frameSubscription = undefined;
+        if (subscription.outstanding) {
+            clearTimeout(subscription.outstanding.timer);
+            const acknowledgement = subscription.outstanding.acknowledgement;
+            subscription.outstanding = undefined;
+            const session = slot.session;
+            if (session) {
+                const operation = session.acknowledgeFrame(acknowledgement);
+                const result = await waitBounded(operation, this.options.frameAcknowledgementTimeoutMs)
+                    .catch(() => ({ settled: true, value: { accepted: false } }));
+                if ((!result.settled || !result.value.accepted) && slot.session === session) {
+                    operation.catch(() => undefined);
+                    await this.terminateSlotSession(slot);
+                }
+            }
+        }
+    }
+    async acknowledgeFrameInBackground(slot, session, acknowledgement) {
+        const operation = session.acknowledgeFrame(acknowledgement);
+        const result = await waitBounded(operation, this.options.frameAcknowledgementTimeoutMs)
+            .catch(() => ({ settled: true, value: { accepted: false } }));
+        if (result.settled && result.value.accepted)
+            return;
+        operation.catch(() => undefined);
+        if (slot.session !== session)
+            return;
+        if (slot.lease)
+            await this.revokeCapabilityRecord(slot.lease.capability);
+        else
+            await this.retireSlot(slot.projectId, true);
+    }
+    requireValidLease(lease) {
+        if (lease.released || lease.controller.signal.aborted) {
+            throw new BrowserRuntimeError('CAPABILITY_REVOKED');
+        }
+        const capability = this.resolveCapability(lease.digest, lease.peerId, lease.role, lease.capability.source);
+        if (capability !== lease.capability
+            || capability.lease !== lease
+            || lease.slot.lease !== lease
+            || !lease.slot.session) {
+            throw new BrowserRuntimeError('CAPABILITY_REVOKED');
+        }
+    }
+    resolveCapability(digest, peerId, expectedRole, expectedSource, expectedScopeId, expectedSessionId) {
+        const record = this.capabilitiesByDigest.get(digest.toString('hex'));
+        if (!record || !digestsEqual(record.digest, digest) || record.peerId !== peerId) {
+            throw new BrowserRuntimeError('CAPABILITY_INVALID');
+        }
+        if (record.expiresAt <= Date.now()) {
+            record.state = 'expired';
+            this.trackCleanup(this.revokeCapabilityRecord(record));
+            throw new BrowserRuntimeError('CAPABILITY_EXPIRED');
+        }
+        if (record.state !== 'active')
+            throw new BrowserRuntimeError('CAPABILITY_REVOKED');
+        if ((expectedRole && record.role !== expectedRole)
+            || (expectedSource && record.source !== expectedSource)
+            || (expectedScopeId && record.scopeId !== expectedScopeId)
+            || (expectedSessionId && record.sessionId !== expectedSessionId)) {
+            throw new BrowserRuntimeError('CAPABILITY_INVALID');
+        }
+        return record;
+    }
+    describeCapability(record) {
+        return {
+            capabilityId: record.capabilityId,
+            projectId: record.projectId,
+            actorId: record.actorId,
+            role: record.role,
+            peerId: record.peerId,
+            source: record.source,
+            ...(record.scopeId ? { scopeId: record.scopeId } : {}),
+            ...(record.sessionId ? { sessionId: record.sessionId } : {}),
+            expiresAt: record.expiresAt,
+        };
+    }
+    async revokeCapabilityRecord(capability, invokeDisconnect = true) {
+        if (capability.revocationComplete)
+            return;
+        if (capability.revocationPromise)
+            return capability.revocationPromise;
+        capability.revocationInvokeDisconnect ??= invokeDisconnect;
+        if (capability.state === 'active')
+            capability.state = 'revoked';
+        clearTimeout(capability.expiryTimer);
+        this.capabilitiesByDigest.delete(capability.digest.toString('hex'));
+        const operation = (async () => {
+            const errors = [];
+            const lease = capability.lease;
+            if (!capability.leaseCleanupComplete) {
+                if (lease) {
+                    await this.releaseLeaseRecord(lease).then(() => { capability.leaseCleanupComplete = true; }, (error) => errors.push(error));
+                }
+                else {
+                    capability.leaseCleanupComplete = true;
+                }
+            }
+            if (!capability.revocationInvokeDisconnect)
+                capability.disconnectComplete = true;
+            if (capability.revocationInvokeDisconnect && !capability.disconnectComplete) {
+                if (capability.disconnect) {
+                    const disconnectController = new AbortController();
+                    let disconnectFailed = false;
+                    const result = await waitBounded(Promise.resolve().then(() => capability.disconnect(disconnectController.signal)), this.options.quiescenceTimeoutMs).catch((error) => {
+                        disconnectFailed = true;
+                        errors.push(error);
+                        return { settled: true, value: undefined };
+                    });
+                    if (!result.settled) {
+                        disconnectController.abort(new BrowserRuntimeError('TIMEOUT'));
+                        errors.push(new BrowserRuntimeError('TIMEOUT'));
+                    }
+                    else if (!disconnectFailed) {
+                        capability.disconnectComplete = true;
+                    }
+                }
+                else {
+                    const framedPeer = [...this.framedPeers].find((peer) => peer.peerId === capability.peerId);
+                    if (framedPeer) {
+                        await framedPeer.close().then(() => { capability.disconnectComplete = true; }, (error) => errors.push(error));
+                    }
+                    else {
+                        capability.disconnectComplete = true;
+                    }
+                }
+            }
+            if (errors.length > 0)
+                throw new AggregateError(errors, 'Capability cleanup is incomplete');
+            capability.revocationComplete = true;
+            this.capabilitiesById.delete(capability.capabilityId);
+            const slot = this.slots.get(capability.projectId);
+            if (slot
+                && !slot.mutex.busy
+                && !slot.session
+                && !slot.lease
+                && !slot.operation
+                && ![...this.capabilitiesById.values()].some((record) => (record.projectId === capability.projectId)))
+                this.slots.delete(capability.projectId);
+        })();
+        capability.revocationPromise = operation;
+        try {
+            await operation;
+            this.failedRevocations.delete(capability);
+        }
+        catch (error) {
+            this.failedRevocations.add(capability);
+            throw error;
+        }
+        finally {
+            if (capability.revocationPromise === operation)
+                capability.revocationPromise = undefined;
+        }
+    }
+    async releaseLeaseRecord(lease) {
+        if (lease.releasePromise)
+            return lease.releasePromise;
+        const operation = this.releaseLeaseRecordInternal(lease);
+        lease.releasePromise = operation;
+        try {
+            await operation;
+        }
+        finally {
+            if (lease.releasePromise === operation)
+                lease.releasePromise = undefined;
+        }
+    }
+    async releaseLeaseRecordInternal(lease) {
+        if (lease.released && lease.slot.lease !== lease)
+            return;
+        const slot = lease.slot;
+        const release = await slot.mutex.acquire();
+        const generation = lease.releaseGeneration ?? ++slot.generation;
+        lease.releaseGeneration = generation;
+        try {
+            if (slot.fencingGeneration !== undefined && slot.fencingGeneration !== generation) {
+                lease.controller.abort(new BrowserRuntimeError('ABORTED'));
+            }
+            else {
+                slot.fencingGeneration = generation;
+            }
+            lease.released = true;
+            lease.controller.abort(new BrowserRuntimeError('ABORTED'));
+            if (slot.operation?.lease === lease) {
+                slot.operation.controller.abort(new BrowserRuntimeError('ABORTED'));
+            }
+        }
+        finally {
+            release();
+        }
+        await this.closeFrameSubscriptionIfLease(lease);
+        await this.quiesceSlot(slot);
+        if (slot.permanentlyFenced
+            && (slot.session || slot.proxy || slot.profileDirectory))
+            await this.terminateSlotSession(slot);
+        const finalRelease = await slot.mutex.acquire();
+        try {
+            if (slot.lease === lease)
+                slot.lease = undefined;
+            if (lease.capability.lease === lease)
+                lease.capability.lease = undefined;
+            if (slot.fencingGeneration === generation)
+                slot.fencingGeneration = undefined;
+            lease.releaseGeneration = undefined;
+            this.scheduleIdleRetirement(slot);
+        }
+        finally {
+            finalRelease();
+        }
+    }
+    async closeFrameSubscriptionIfLease(lease) {
+        const subscription = lease.slot.frameSubscription;
+        if (subscription?.lease === lease)
+            await this.closeFrameSubscription(subscription);
+    }
+    async quiesceSlot(slot) {
+        const operation = slot.operation;
+        if (!operation)
+            return;
+        operation.controller.abort(new BrowserRuntimeError('ABORTED'));
+        const settled = await waitBounded(operation.promise, this.options.quiescenceTimeoutMs);
+        if (settled.settled)
+            return;
+        await this.terminateSlotSession(slot);
+        if (slot.operation === operation)
+            slot.operation = undefined;
+    }
+    async enforceOperationQuiescence(operation) {
+        const settled = await waitBounded(operation.promise, this.options.quiescenceTimeoutMs);
+        if (settled.settled || operation.lease.released)
+            return;
+        await this.revokeCapabilityRecord(operation.lease.capability);
+    }
+    async terminateSlotSession(slot) {
+        const session = slot.session;
+        if (session) {
+            let termination;
+            try {
+                const result = await waitBounded(session.terminate({
+                    gracefulTimeoutMs: this.options.terminationGraceMs,
+                    forceTimeoutMs: this.options.terminationForceMs,
+                }), this.options.terminationGraceMs + this.options.terminationForceMs + 1000);
+                if (!result.settled)
+                    throw new BrowserRuntimeError('TIMEOUT');
+                termination = result.value;
+            }
+            catch {
+                slot.permanentlyFenced = true;
+                throw new BrowserRuntimeError('FENCED');
+            }
+            if (!termination.confirmedDead) {
+                slot.permanentlyFenced = true;
+                throw new BrowserRuntimeError('FENCED');
+            }
+            slot.unsubscribeSession?.();
+            slot.unsubscribeSession = undefined;
+            slot.session = undefined;
+        }
+        if (slot.proxy) {
+            await this.stopProxyBounded(slot.proxy).then(() => { slot.proxy = undefined; }, () => { slot.permanentlyFenced = true; });
+        }
+        if (slot.profileDirectory) {
+            await plugins.fsPromises.rm(slot.profileDirectory, { recursive: true, force: true }).then(() => { slot.profileDirectory = undefined; }, () => { slot.permanentlyFenced = true; });
+        }
+        if (slot.proxy || slot.profileDirectory)
+            throw new BrowserRuntimeError('FENCED');
+    }
+    scheduleIdleRetirement(slot) {
+        if (slot.idleTimer)
+            clearTimeout(slot.idleTimer);
+        const generation = slot.generation;
+        slot.idleTimer = setTimeout(() => {
+            if (slot.generation !== generation || slot.lease)
+                return;
+            this.trackCleanup(this.retireSlot(slot.projectId, false));
+        }, this.options.idleRetirementMs);
+        slot.idleTimer.unref();
+    }
+    async stopProxyBounded(proxy) {
+        const operation = proxy.stop();
+        const result = await waitBounded(operation, this.options.terminationGraceMs + this.options.terminationForceMs + 1000);
+        if (!result.settled) {
+            operation.catch(() => undefined);
+            throw new BrowserRuntimeError('TIMEOUT');
+        }
+    }
+    async retireSlot(projectId, force) {
+        const slot = this.slots.get(projectId);
+        if (!slot)
+            return;
+        const release = await slot.mutex.acquire();
+        const generation = ++slot.generation;
+        try {
+            if (!force && (slot.lease || slot.operation))
+                return;
+            slot.fencingGeneration = generation;
+            if (slot.idleTimer) {
+                clearTimeout(slot.idleTimer);
+                slot.idleTimer = undefined;
+            }
+            if (slot.lease) {
+                slot.lease.released = true;
+                slot.lease.controller.abort(new BrowserRuntimeError('ABORTED'));
+            }
+            slot.operation?.controller.abort(new BrowserRuntimeError('ABORTED'));
+        }
+        finally {
+            release();
+        }
+        await this.quiesceSlot(slot);
+        if (slot.lease)
+            await this.closeFrameSubscriptionIfLease(slot.lease);
+        await this.terminateSlotSession(slot);
+        await this.artifactStore.purgeProject(projectId);
+        const finalRelease = await slot.mutex.acquire();
+        try {
+            if (slot.generation !== generation || slot.fencingGeneration !== generation) {
+                throw new BrowserRuntimeError('BUSY');
+            }
+            const lease = slot.lease;
+            if (lease && lease.capability.lease === lease) {
+                lease.capability.lease = undefined;
+            }
+            slot.lease = undefined;
+            slot.operation = undefined;
+            slot.fencingGeneration = undefined;
+            this.slots.delete(projectId);
+        }
+        finally {
+            finalRelease();
+        }
+    }
+    assertSlotAvailable(slot) {
+        if (slot.permanentlyFenced)
+            throw new BrowserRuntimeError('FENCED');
+        if (slot.fencingGeneration !== undefined)
+            throw new BrowserRuntimeError('BUSY');
+    }
+    throwIfAcquisitionAborted(signal) {
+        if (signal?.aborted)
+            throw new BrowserRuntimeError('ABORTED');
+    }
+    requireHuman(lease) {
+        if (lease.role !== 'human')
+            throw new BrowserRuntimeError('CAPABILITY_INVALID');
+    }
+    validateRole(value) {
+        if (value !== 'human' && value !== 'agent')
+            throw new BrowserRuntimeError('INVALID_INPUT');
+        return value;
+    }
+    validateSource(value) {
+        if (value !== 'human' && value !== 'flex' && value !== 'mcp') {
+            throw new BrowserRuntimeError('INVALID_INPUT');
+        }
+        return value;
+    }
+    trackCleanup(operation) {
+        const observed = operation.catch(() => undefined).finally(() => {
+            this.cleanupOperations.delete(observed);
+        });
+        this.cleanupOperations.add(observed);
+    }
+    async emitAudit(event) {
+        if (!this.options.audit)
+            return;
+        const controller = new AbortController();
+        const operation = Promise.resolve().then(() => this.options.audit(event, controller.signal));
+        const observed = waitBounded(operation, this.options.auditTimeoutMs)
+            .then((result) => {
+            if (!result.settled)
+                controller.abort(new BrowserRuntimeError('TIMEOUT'));
+        })
+            .catch(() => undefined);
+        this.trackCleanup(observed);
+        await observed;
+    }
+}
+export class BrowserRuntimeLease {
+    runtime;
+    record;
+    /** @internal */
+    constructor(runtime, record) {
+        this.runtime = runtime;
+        this.record = record;
+    }
+    get leaseId() {
+        return this.record.leaseId;
+    }
+    get role() {
+        return this.record.role;
+    }
+    get projectId() {
+        return this.record.capability.projectId;
+    }
+    getState() {
+        return this.runtime.getLeaseState(this.record);
+    }
+    executeAgentAction(action, options) {
+        return this.runtime.executeLeaseAgentAction(this.record, action, options);
+    }
+    executeHumanAction(action, options) {
+        return this.runtime.leaseHumanAgentAction(this.record, action, options);
+    }
+    createTab(options, operationOptions) {
+        return this.runtime.leaseCreateTab(this.record, options, operationOptions);
+    }
+    activateTab(tabId, operationOptions) {
+        return this.runtime.leaseActivateTab(this.record, tabId, operationOptions);
+    }
+    closeTab(tabId, operationOptions) {
+        return this.runtime.leaseCloseTab(this.record, tabId, operationOptions);
+    }
+    back(options, operationOptions) {
+        return this.runtime.leaseHistory(this.record, 'back', options, operationOptions);
+    }
+    forward(options, operationOptions) {
+        return this.runtime.leaseHistory(this.record, 'forward', options, operationOptions);
+    }
+    reload(options, operationOptions) {
+        return this.runtime.leaseHistory(this.record, 'reload', options, operationOptions);
+    }
+    setViewport(viewport, operationOptions) {
+        return this.runtime.leaseSetViewport(this.record, viewport, operationOptions);
+    }
+    dispatchMouse(input, operationOptions) {
+        return this.runtime.leaseDispatchRawInput(this.record, 'dispatchMouse', input, operationOptions);
+    }
+    dispatchWheel(input, operationOptions) {
+        return this.runtime.leaseDispatchRawInput(this.record, 'dispatchWheel', input, operationOptions);
+    }
+    dispatchKey(input, operationOptions) {
+        return this.runtime.leaseDispatchRawInput(this.record, 'dispatchKey', input, operationOptions);
+    }
+    insertText(input, operationOptions) {
+        return this.runtime.leaseDispatchRawInput(this.record, 'insertText', input, operationOptions);
+    }
+    subscribeEvents(listener) {
+        return this.runtime.subscribeLeaseEvents(this.record, listener);
+    }
+    acknowledgeFrame(acknowledgement) {
+        return this.runtime.acknowledgeLeaseFrame(this.record, acknowledgement);
+    }
+    readArtifact(artifactId) {
+        return this.runtime.readLeaseArtifact(this.record, artifactId);
+    }
+    deleteArtifact(artifactId) {
+        return this.runtime.deleteLeaseArtifact(this.record, artifactId);
+    }
+    cancelActiveOperation() {
+        return this.runtime.cancelLeaseOperation(this.record);
+    }
+    release() {
+        return this.runtime.releaseLease(this.record);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.runtime.js","sourceRoot":"","sources":["../ts/classes.runtime.ts"],"names":[],"mappings":"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"}