agl 1.0.17 → 21.0.2

package/dist_ts/classes.browserresourcehost.js

@@ -0,0 +1,912 @@
+import * as plugins from './plugins.js';
+import { flexIpcMaximumBrowserChannels, } from './interfaces.flexipc.js';
+const maximumPendingFlexCapabilityIssuances = 128;
+const maximumActiveHumanBrowserViews = 64;
+const maximumTrackedCapabilityRevocations = 512;
+const maximumCleanupOperationWaiters = 512;
+const browserCapabilityAuthorizationTimeoutMs = 10_000;
+const browserResourceCleanupTimeoutMs = 40_000;
+const waitForSignal = async (promiseArg, signalArg) => new Promise((resolve, reject) => {
+    const abort = () => {
+        signalArg.removeEventListener('abort', abort);
+        reject(signalArg.reason ?? new DOMException('The operation was aborted.', 'AbortError'));
+    };
+    signalArg.addEventListener('abort', abort, { once: true });
+    if (signalArg.aborted) {
+        abort();
+        return;
+    }
+    void promiseArg.then((value) => {
+        signalArg.removeEventListener('abort', abort);
+        resolve(value);
+    }, (errorArg) => {
+        signalArg.removeEventListener('abort', abort);
+        reject(errorArg);
+    });
+});
+const waitForCleanupDeadline = async (promiseArg, deadlineAtArg, messageArg, signalArg) => new Promise((resolve, reject) => {
+    let timeout;
+    let settled = false;
+    const finish = (operationArg) => {
+        if (settled)
+            return;
+        settled = true;
+        if (timeout)
+            clearTimeout(timeout);
+        signalArg?.removeEventListener('abort', abort);
+        operationArg();
+    };
+    const abort = () => finish(() => reject(signalArg?.reason ?? new DOMException('The operation was aborted.', 'AbortError')));
+    void promiseArg.then((value) => finish(() => resolve(value)), (errorArg) => finish(() => reject(errorArg)));
+    if (signalArg?.aborted) {
+        abort();
+        return;
+    }
+    signalArg?.addEventListener('abort', abort, { once: true });
+    const remainingMs = deadlineAtArg - Date.now();
+    if (remainingMs <= 0) {
+        finish(() => reject(new Error(messageArg)));
+        return;
+    }
+    timeout = setTimeout(() => finish(() => reject(new Error(messageArg))), remainingMs);
+});
+const observeCleanupOperation = (operationArg, onSettledArg) => {
+    const operation = { waiters: new Set() };
+    const settle = (outcomeArg) => {
+        if (operation.outcome)
+            return;
+        operation.outcome = outcomeArg;
+        onSettledArg?.(outcomeArg);
+        const waiters = [...operation.waiters];
+        operation.waiters.clear();
+        for (const waiter of waiters)
+            waiter(outcomeArg);
+    };
+    void Promise.resolve().then(operationArg).then(() => settle({ status: 'fulfilled' }), (reason) => settle({ status: 'rejected', reason }));
+    return operation;
+};
+const waitForObservedCleanup = async (operationArg, deadlineAtArg, messageArg, signalArg) => {
+    if (operationArg.outcome)
+        return operationArg.outcome;
+    signalArg?.throwIfAborted();
+    const remainingMs = deadlineAtArg - Date.now();
+    if (remainingMs <= 0)
+        throw new Error(messageArg);
+    if (operationArg.waiters.size >= maximumCleanupOperationWaiters) {
+        throw new Error('Browser cleanup waiter capacity was reached.');
+    }
+    return new Promise((resolve, reject) => {
+        let timeout;
+        let settled = false;
+        const finish = (finishArg) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeout)
+                clearTimeout(timeout);
+            operationArg.waiters.delete(complete);
+            signalArg?.removeEventListener('abort', abort);
+            finishArg();
+        };
+        const complete = (outcomeArg) => {
+            finish(() => resolve(outcomeArg));
+        };
+        const abort = () => finish(() => reject(signalArg?.reason ?? new DOMException('The operation was aborted.', 'AbortError')));
+        operationArg.waiters.add(complete);
+        signalArg?.addEventListener('abort', abort, { once: true });
+        if (operationArg.outcome) {
+            complete(operationArg.outcome);
+            return;
+        }
+        if (signalArg?.aborted) {
+            abort();
+            return;
+        }
+        timeout = setTimeout(() => finish(() => reject(new Error(messageArg))), remainingMs);
+    });
+};
+export class ControllerBrowserResourceHost {
+    options;
+    runtime;
+    started = false;
+    unavailable = false;
+    stopping = false;
+    cleanupTimeoutMs = browserResourceCleanupTimeoutMs;
+    startPromise;
+    stopPromise;
+    flexAuthorizationBindings = new Map();
+    flexChannels = new Map();
+    flexChannelAdmissions = new Map();
+    capabilityRevocationOperations = new Map();
+    lateCapabilityIssuanceTasks = new Map();
+    humanViews = new Set();
+    humanViewAdmissions = new Set();
+    admissionAbortController = new AbortController();
+    runtimeStopOperations = new WeakMap();
+    constructor(options) {
+        this.options = options;
+    }
+    async start(signalArg) {
+        if (this.started || this.unavailable)
+            return;
+        if (this.startPromise)
+            return await waitForSignal(this.startPromise, signalArg ?? new AbortController().signal);
+        if (this.stopping)
+            throw new Error('Browser resource host cleanup is incomplete.');
+        if (this.admissionAbortController.signal.aborted) {
+            this.admissionAbortController = new AbortController();
+        }
+        const startPromise = this.performStart(signalArg);
+        this.startPromise = startPromise;
+        try {
+            await startPromise;
+        }
+        finally {
+            if (this.startPromise === startPromise)
+                this.startPromise = undefined;
+        }
+    }
+    async performStart(signalArg) {
+        signalArg?.throwIfAborted();
+        const runtime = new plugins.browserRuntime.BrowserRuntime({
+            runtimeDirectory: this.options.runtimeDirectory,
+            authorizationTimeoutMs: browserCapabilityAuthorizationTimeoutMs,
+            authorizeCapability: this.options.authorizeCapability,
+            ...(this.options.beforeOperation === undefined ? {} : {
+                beforeOperation: this.options.beforeOperation,
+            }),
+            ...(this.options.audit === undefined ? {} : { audit: this.options.audit }),
+        });
+        this.runtime = runtime;
+        try {
+            await (signalArg ? waitForSignal(runtime.start(), signalArg) : runtime.start());
+            signalArg?.throwIfAborted();
+            if (this.stopping)
+                throw new Error('Browser resource host cleanup began during startup.');
+            this.started = true;
+        }
+        catch (errorArg) {
+            if (errorArg instanceof plugins.browserRuntime.BrowserRuntimeError
+                && (errorArg.code === 'CONFINEMENT_FAILED' || errorArg.code === 'INVALID_INPUT')) {
+                await runtime.stop().catch((cleanupErrorArg) => {
+                    throw new AggregateError([errorArg, cleanupErrorArg], 'BrowserRuntime startup and cleanup failed.');
+                });
+                if (this.runtime === runtime)
+                    this.runtime = undefined;
+                this.unavailable = true;
+                return;
+            }
+            await runtime.stop().catch((cleanupErrorArg) => {
+                throw new AggregateError([errorArg, cleanupErrorArg], 'BrowserRuntime startup and cleanup failed.');
+            });
+            if (this.runtime === runtime)
+                this.runtime = undefined;
+            throw errorArg;
+        }
+    }
+    async stop() {
+        if (this.stopPromise)
+            return this.stopPromise;
+        const stopPromise = this.performStop();
+        this.stopPromise = stopPromise;
+        try {
+            await stopPromise;
+        }
+        finally {
+            if (this.stopPromise === stopPromise)
+                this.stopPromise = undefined;
+        }
+    }
+    async performStop() {
+        const runtime = this.runtime;
+        if (!runtime) {
+            if (this.humanViews.size > 0
+                || this.flexChannels.size > 0
+                || this.flexChannelAdmissions.size > 0
+                || this.humanViewAdmissions.size > 0
+                || this.capabilityRevocationOperations.size > 0
+                || this.lateCapabilityIssuanceTasks.size > 0)
+                throw new Error('Browser resource host cleanup has no runtime owner.');
+            this.stopping = false;
+            return;
+        }
+        this.stopping = true;
+        if (!this.admissionAbortController.signal.aborted) {
+            this.admissionAbortController.abort(new Error('Browser resource host is stopping.'));
+        }
+        const deadlineAt = Date.now() + this.cleanupTimeoutMs;
+        const cleanupErrors = [];
+        for (const cleanup of [
+            () => this.cancelAndDrainFlexChannelAdmissions(deadlineAt),
+            () => this.drainHumanViewAdmissions(deadlineAt),
+            () => this.closeAllHumanViews(deadlineAt),
+            () => this.closeAllFlexChannels(undefined, deadlineAt),
+            () => this.drainLateCapabilityIssuanceTasks(deadlineAt),
+            () => this.retryPendingCapabilityRevocations(deadlineAt),
+        ]) {
+            await cleanup().catch((errorArg) => cleanupErrors.push(errorArg));
+        }
+        if (cleanupErrors.length > 0) {
+            throw new AggregateError(cleanupErrors, 'Browser resource host cleanup is incomplete.');
+        }
+        await this.stopRuntime(runtime, deadlineAt);
+        if (this.runtime === runtime)
+            this.runtime = undefined;
+        this.started = false;
+        this.stopping = false;
+    }
+    authorizeFlexCapability(requestArg) {
+        if (requestArg.role !== 'agent' || requestArg.source !== 'flex')
+            return false;
+        const expected = this.flexAuthorizationBindings.get(requestArg.channelId);
+        return expected !== undefined
+            && this.isFlexRunActive(expected.binding, expected.runId)
+            && expected.binding.projectId === requestArg.projectId
+            && expected.binding.browserResourceId === requestArg.browserResourceId
+            && expected.binding.attachmentAuthorityId === requestArg.attachmentAuthorityId
+            && expected.binding.attachmentRevision === requestArg.attachmentRevision
+            && expected.binding.actorId === requestArg.actorId
+            && expected.binding.peerId === requestArg.peerId
+            && expected.binding.scopeId === requestArg.scopeId
+            && expected.binding.channelId === requestArg.channelId
+            && expected.binding.runId === requestArg.runId
+            && expected.binding.sessionId.harnessId === requestArg.sessionId.harnessId
+            && expected.binding.sessionId.nativeId === requestArg.sessionId.nativeId;
+    }
+    async openFlexChannel(inputArg) {
+        const runtime = this.runtime;
+        const resource = inputArg.resource;
+        if (!runtime
+            || !this.started
+            || resource.kind !== 'browser'
+            || resource.lifecycle !== 'active'
+            || resource.pendingAttachment !== undefined
+            || resource.sessionId?.harnessId !== 'flex'
+            || resource.sessionId.nativeId !== inputArg.sessionId
+            || resource.projectId !== inputArg.scopeId
+            || this.flexChannels.has(inputArg.channelId)
+            || this.flexChannelAdmissions.has(inputArg.channelId)
+            || this.stopping)
+            throw new Error('The Flex browser channel is unavailable.');
+        if (this.flexChannels.size + this.flexChannelAdmissions.size
+            >= flexIpcMaximumBrowserChannels)
+            throw new Error('The Flex browser channel capacity was reached.');
+        inputArg.signal?.throwIfAborted();
+        this.admissionAbortController.signal.throwIfAborted();
+        let resolveAdmissionSettled;
+        const admission = {
+            projectId: resource.projectId,
+            sessionId: inputArg.sessionId,
+            runId: inputArg.runId,
+            peerId: inputArg.peerId,
+            abortController: new AbortController(),
+            settled: new Promise((resolve) => { resolveAdmissionSettled = resolve; }),
+            resolveSettled: () => resolveAdmissionSettled(),
+        };
+        const abortAdmission = (signalArg) => {
+            if (!admission.abortController.signal.aborted) {
+                admission.abortController.abort(signalArg.reason ?? new DOMException('The operation was aborted.', 'AbortError'));
+            }
+        };
+        const abortFromInput = () => abortAdmission(inputArg.signal);
+        const abortFromHost = () => abortAdmission(this.admissionAbortController.signal);
+        inputArg.signal?.addEventListener('abort', abortFromInput, { once: true });
+        this.admissionAbortController.signal.addEventListener('abort', abortFromHost, { once: true });
+        this.flexChannelAdmissions.set(inputArg.channelId, admission);
+        if (inputArg.signal?.aborted)
+            abortFromInput();
+        if (this.admissionAbortController.signal.aborted)
+            abortFromHost();
+        const binding = {
+            projectId: resource.projectId,
+            browserResourceId: resource.id,
+            attachmentAuthorityId: resource.attachmentAuthorityId,
+            attachmentRevision: resource.attachmentRevision,
+            actorId: `flex-run:${plugins.crypto.createHash('sha256')
+                .update(JSON.stringify([inputArg.scopeId, inputArg.sessionId, inputArg.runId]))
+                .digest('hex')}`,
+            peerId: inputArg.peerId,
+            role: 'agent',
+            source: 'flex',
+            scopeId: inputArg.scopeId,
+            channelId: inputArg.channelId,
+            runId: inputArg.runId,
+            sessionId: { harnessId: 'flex', nativeId: inputArg.sessionId },
+        };
+        const inbound = new plugins.stream.PassThrough();
+        const outbound = new plugins.stream.Writable({
+            write: (chunkArg, _encodingArg, callbackArg) => {
+                const bytes = Buffer.from(chunkArg);
+                void inputArg.sendFrame(inputArg.channelId, bytes).then(() => callbackArg(), (errorArg) => callbackArg(errorArg instanceof Error ? errorArg : new Error('Frame send failed.')));
+            },
+            destroy: (errorArg, callbackArg) => {
+                const channel = this.flexChannels.get(inputArg.channelId);
+                if (channel?.notifyClosed) {
+                    channel.notifyClosed = false;
+                    void inputArg.notifyClosed(inputArg.channelId).catch(() => undefined);
+                    void this.closeFlexChannel(inputArg.channelId, true).catch(() => undefined);
+                }
+                callbackArg(errorArg);
+            },
+        });
+        this.flexAuthorizationBindings.set(inputArg.channelId, {
+            binding,
+            runId: inputArg.runId,
+        });
+        let capabilityId = '';
+        let issuancePromise;
+        let channelRegistered = false;
+        try {
+            admission.abortController.signal.throwIfAborted();
+            if (!this.isFlexRunActive(binding, inputArg.runId)) {
+                throw new Error('The Flex browser run is no longer active.');
+            }
+            await this.retryPendingCapabilityRevocations(Date.now() + browserCapabilityAuthorizationTimeoutMs, admission.abortController.signal);
+            if (this.lateCapabilityIssuanceTasks.size >= maximumPendingFlexCapabilityIssuances) {
+                throw new Error('Browser capability issuance capacity was reached.');
+            }
+            issuancePromise = runtime.issueCapability({
+                ...binding,
+                expiresInMs: 24 * 60 * 60 * 1000,
+            });
+            const issued = await waitForSignal(issuancePromise, admission.abortController.signal);
+            issuancePromise = undefined;
+            capabilityId = issued.capabilityId;
+            const peer = runtime.attachTrustedFramedPeer({
+                ...binding,
+                readable: inbound,
+                writable: outbound,
+            });
+            this.flexChannels.set(inputArg.channelId, {
+                binding,
+                runId: inputArg.runId,
+                capabilityId,
+                inbound,
+                peer,
+                notifyClosed: true,
+                closing: false,
+                peerClosed: false,
+                capabilityRevoked: false,
+            });
+            channelRegistered = true;
+            admission.abortController.signal.throwIfAborted();
+            if (!this.isFlexRunActive(binding, inputArg.runId)) {
+                throw new Error('The Flex browser run is no longer active.');
+            }
+            return { binding, capabilityToken: issued.capabilityToken };
+        }
+        catch (errorArg) {
+            const cleanupErrors = [];
+            if (issuancePromise) {
+                this.trackLateCapabilityIssuance(runtime, issuancePromise, 'flex');
+                issuancePromise = undefined;
+            }
+            if (channelRegistered) {
+                const channel = this.flexChannels.get(inputArg.channelId);
+                if (channel)
+                    channel.notifyClosed = false;
+                await this.closeFlexChannel(inputArg.channelId, false, undefined, Date.now() + this.cleanupTimeoutMs).catch((cleanupErrorArg) => cleanupErrors.push(cleanupErrorArg));
+            }
+            else {
+                this.flexAuthorizationBindings.delete(inputArg.channelId);
+                inbound.destroy();
+                outbound.destroy();
+                if (capabilityId) {
+                    this.trackCapabilityRevocation(runtime, capabilityId, 'flex');
+                    await this.awaitCapabilityRevocation(capabilityId, Date.now() + this.cleanupTimeoutMs).catch((cleanupErrorArg) => cleanupErrors.push(cleanupErrorArg));
+                }
+            }
+            if (cleanupErrors.length > 0) {
+                throw new AggregateError([errorArg, ...cleanupErrors], 'Flex browser channel admission and cleanup failed.');
+            }
+            throw errorArg;
+        }
+        finally {
+            inputArg.signal?.removeEventListener('abort', abortFromInput);
+            this.admissionAbortController.signal.removeEventListener('abort', abortFromHost);
+            this.flexChannelAdmissions.delete(inputArg.channelId);
+            admission.resolveSettled();
+        }
+    }
+    async receiveFlexFrame(channelIdArg, bytesArg, peerIdArg) {
+        const channel = this.flexChannels.get(channelIdArg);
+        if (!channel
+            || channel.binding.peerId !== peerIdArg
+            || channel.closing
+            || !this.isFlexRunActive(channel.binding, channel.runId)) {
+            if (channel && !channel.closing && !this.isFlexRunActive(channel.binding, channel.runId)) {
+                void this.closeFlexChannel(channelIdArg, true).catch(() => undefined);
+            }
+            throw new Error('The Flex browser channel is unavailable.');
+        }
+        await new Promise((resolve, reject) => {
+            channel.inbound.write(bytesArg, (errorArg) => errorArg ? reject(errorArg) : resolve());
+        });
+    }
+    async closeFlexChannel(channelIdArg, notifyChildArg = false, peerIdArg, deadlineAtArg = Date.now() + this.cleanupTimeoutMs) {
+        const channel = this.flexChannels.get(channelIdArg);
+        if (!channel)
+            return;
+        if (peerIdArg !== undefined && channel.binding.peerId !== peerIdArg) {
+            throw new Error('The Flex browser channel is unavailable.');
+        }
+        if (notifyChildArg)
+            channel.notifyClosed = true;
+        else
+            channel.notifyClosed = false;
+        channel.closing = true;
+        this.flexAuthorizationBindings.delete(channelIdArg);
+        const peerCleanup = (async () => {
+            if (channel.peerClosed)
+                return;
+            channel.peerCloseOperation ??= observeCleanupOperation(() => channel.peer.close(), (outcomeArg) => {
+                if (outcomeArg.status === 'fulfilled')
+                    channel.peerClosed = true;
+            });
+            const outcome = await waitForObservedCleanup(channel.peerCloseOperation, deadlineAtArg, 'Flex browser peer cleanup timed out.');
+            if (outcome.status === 'rejected') {
+                channel.peerCloseOperation = undefined;
+                throw outcome.reason;
+            }
+        })();
+        const capabilityCleanup = (async () => {
+            if (channel.capabilityRevoked)
+                return;
+            const runtime = this.runtime;
+            if (!runtime)
+                throw new Error('BrowserRuntime is unavailable during channel cleanup.');
+            this.trackCapabilityRevocation(runtime, channel.capabilityId, 'flex', () => { channel.capabilityRevoked = true; });
+            await this.awaitCapabilityRevocation(channel.capabilityId, deadlineAtArg);
+            channel.capabilityRevoked = true;
+        })();
+        const results = await Promise.allSettled([peerCleanup, capabilityCleanup]);
+        if (channel.peerClosed && channel.capabilityRevoked) {
+            channel.inbound.destroy();
+            this.flexChannels.delete(channelIdArg);
+        }
+        const errors = results
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (errors.length > 0) {
+            throw new AggregateError(errors, 'Flex browser channel cleanup is incomplete.');
+        }
+    }
+    async closeAllFlexChannels(peerIdArg, deadlineAtArg = Date.now() + this.cleanupTimeoutMs) {
+        const admissions = [...this.flexChannelAdmissions.entries()].filter(([, admission]) => (peerIdArg === undefined || admission.peerId === peerIdArg));
+        for (const [channelId, admission] of admissions) {
+            this.flexAuthorizationBindings.delete(channelId);
+            if (!admission.abortController.signal.aborted) {
+                admission.abortController.abort(new Error('Flex browser channel admission was cancelled.'));
+            }
+        }
+        const admissionResults = await Promise.allSettled(admissions.map(([, admission]) => (waitForCleanupDeadline(admission.settled, deadlineAtArg, 'Flex browser channel admission cleanup timed out.'))));
+        const channels = [...this.flexChannels.values()].filter((channel) => (peerIdArg === undefined || channel.binding.peerId === peerIdArg));
+        const results = await Promise.allSettled(channels.map((channel) => this.closeFlexChannel(channel.binding.channelId, true, undefined, deadlineAtArg)));
+        const errors = [...admissionResults, ...results]
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (peerIdArg === undefined) {
+            await this.drainLateCapabilityIssuanceTasks(deadlineAtArg, 'flex')
+                .catch((errorArg) => errors.push(errorArg));
+            await this.retryPendingCapabilityRevocations(deadlineAtArg, undefined, 'flex')
+                .catch((errorArg) => errors.push(errorArg));
+        }
+        if (errors.length > 0)
+            throw new AggregateError(errors, 'Flex browser channel cleanup is incomplete.');
+    }
+    async closeFlexChannelsForRun(projectIdArg, sessionIdArg, runIdArg) {
+        const deadlineAt = Date.now() + this.cleanupTimeoutMs;
+        const admissions = [...this.flexChannelAdmissions.entries()].filter(([, admission]) => (admission.projectId === projectIdArg
+            && admission.sessionId === sessionIdArg
+            && admission.runId === runIdArg));
+        for (const [channelId, admission] of admissions) {
+            this.flexAuthorizationBindings.delete(channelId);
+            if (!admission.abortController.signal.aborted) {
+                admission.abortController.abort(new Error('Flex browser run ended.'));
+            }
+        }
+        const admissionResults = await Promise.allSettled(admissions.map(([, admission]) => (waitForCleanupDeadline(admission.settled, deadlineAt, 'Flex browser channel admission cleanup timed out.'))));
+        const channels = [...this.flexChannels.values()].filter((channel) => (channel.binding.projectId === projectIdArg
+            && channel.binding.sessionId.nativeId === sessionIdArg
+            && channel.runId === runIdArg));
+        const channelResults = await Promise.allSettled(channels.map((channel) => (this.closeFlexChannel(channel.binding.channelId, true, undefined, deadlineAt))));
+        const errors = [...admissionResults, ...channelResults]
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (errors.length > 0) {
+            throw new AggregateError(errors, 'Flex browser run channel cleanup is incomplete.');
+        }
+    }
+    async disconnectPeer(peerIdArg) {
+        await this.runtime?.disconnectPeer(peerIdArg);
+    }
+    async openHumanView(inputArg) {
+        const runtime = this.runtime;
+        if (!runtime || !this.started || inputArg.resource.kind !== 'browser' || this.stopping) {
+            throw new Error('BrowserRuntime is unavailable.');
+        }
+        if (this.humanViews.size + this.humanViewAdmissions.size >= maximumActiveHumanBrowserViews) {
+            throw new Error('Human browser view capacity was reached.');
+        }
+        inputArg.signal.throwIfAborted();
+        this.admissionAbortController.signal.throwIfAborted();
+        let resolveAdmissionSettled;
+        const admission = {
+            abortController: new AbortController(),
+            settled: new Promise((resolve) => { resolveAdmissionSettled = resolve; }),
+            resolveSettled: () => resolveAdmissionSettled(),
+        };
+        const abortAdmission = (signalArg) => {
+            if (!admission.abortController.signal.aborted) {
+                admission.abortController.abort(signalArg.reason ?? new DOMException('The operation was aborted.', 'AbortError'));
+            }
+        };
+        const abortFromInput = () => abortAdmission(inputArg.signal);
+        const abortFromHost = () => abortAdmission(this.admissionAbortController.signal);
+        inputArg.signal.addEventListener('abort', abortFromInput, { once: true });
+        this.admissionAbortController.signal.addEventListener('abort', abortFromHost, { once: true });
+        this.humanViewAdmissions.add(admission);
+        if (inputArg.signal.aborted)
+            abortFromInput();
+        if (this.admissionAbortController.signal.aborted)
+            abortFromHost();
+        const binding = {
+            projectId: inputArg.resource.projectId,
+            browserResourceId: inputArg.resource.id,
+            attachmentAuthorityId: inputArg.resource.attachmentAuthorityId,
+            attachmentRevision: inputArg.resource.attachmentRevision,
+            actorId: inputArg.actorId,
+            peerId: inputArg.peerId,
+            role: 'human',
+            source: 'human',
+        };
+        let humanView;
+        let subscription;
+        let activationPromise;
+        let subscriptionCloseOperation;
+        let subscriptionClosed = false;
+        let capabilityRevoked = false;
+        let closing = false;
+        let runtimeDisconnectActive = false;
+        let runtimeDisconnectComplete = false;
+        let capabilityId = '';
+        let issuancePromise;
+        const closeSubscription = async (deadlineAtArg) => {
+            if (subscriptionClosed || !subscription)
+                return;
+            subscriptionCloseOperation ??= observeCleanupOperation(() => subscription.close(), (outcomeArg) => {
+                if (outcomeArg.status === 'fulfilled')
+                    subscriptionClosed = true;
+            });
+            const outcome = await waitForObservedCleanup(subscriptionCloseOperation, deadlineAtArg, 'Browser view subscription cleanup timed out.');
+            if (outcome.status === 'rejected') {
+                subscriptionCloseOperation = undefined;
+                throw outcome.reason;
+            }
+        };
+        try {
+            await this.retryPendingCapabilityRevocations(Date.now() + browserCapabilityAuthorizationTimeoutMs, admission.abortController.signal);
+            if (this.lateCapabilityIssuanceTasks.size >= maximumPendingFlexCapabilityIssuances) {
+                throw new Error('Browser capability issuance capacity was reached.');
+            }
+            issuancePromise = runtime.issueCapability({
+                ...binding,
+                disconnect: async (signalArg) => {
+                    closing = true;
+                    runtimeDisconnectActive = true;
+                    try {
+                        await inputArg.onDisconnect(signalArg);
+                    }
+                    finally {
+                        runtimeDisconnectActive = false;
+                        runtimeDisconnectComplete = true;
+                        subscriptionClosed = true;
+                        capabilityRevoked = true;
+                        if (humanView)
+                            this.humanViews.delete(humanView);
+                    }
+                },
+            });
+            const issued = await waitForSignal(issuancePromise, admission.abortController.signal);
+            issuancePromise = undefined;
+            capabilityId = issued.capabilityId;
+            const lease = await runtime.acquireLease({
+                ...binding,
+                capabilityToken: issued.capabilityToken,
+                signal: admission.abortController.signal,
+            });
+            admission.abortController.signal.throwIfAborted();
+            humanView = {
+                lease,
+                activate: (listenerArg) => {
+                    if (closing)
+                        return Promise.reject(new Error('Browser view cleanup has begun.'));
+                    if (subscription && !subscriptionClosed)
+                        return Promise.resolve();
+                    if (subscriptionClosed) {
+                        subscription = undefined;
+                        subscriptionCloseOperation = undefined;
+                        subscriptionClosed = false;
+                    }
+                    activationPromise ??= (async () => {
+                        let initialStateReceived = false;
+                        const candidate = await lease.subscribeEvents((eventArg) => {
+                            if (!initialStateReceived) {
+                                if (eventArg.type !== 'state') {
+                                    throw new Error('BrowserRuntime did not publish an initial state event.');
+                                }
+                                initialStateReceived = true;
+                            }
+                            listenerArg(eventArg);
+                        });
+                        subscription = candidate;
+                        if (!initialStateReceived) {
+                            await closeSubscription(Date.now() + this.cleanupTimeoutMs);
+                            throw new Error('BrowserRuntime did not publish an initial state event.');
+                        }
+                        if (closing) {
+                            await closeSubscription(Date.now() + this.cleanupTimeoutMs);
+                            throw new Error('Browser view cleanup began during activation.');
+                        }
+                    })().finally(() => {
+                        if (!subscription || subscriptionClosed)
+                            activationPromise = undefined;
+                    });
+                    return activationPromise;
+                },
+                close: async () => {
+                    closing = true;
+                    const deadlineAt = Date.now() + this.cleanupTimeoutMs;
+                    if (runtimeDisconnectActive) {
+                        await closeSubscription(deadlineAt);
+                        return;
+                    }
+                    const errors = [];
+                    if (activationPromise) {
+                        await waitForCleanupDeadline(activationPromise.catch(() => undefined), deadlineAt, 'Browser view activation cleanup timed out.').catch((errorArg) => errors.push(errorArg));
+                    }
+                    if (!subscriptionClosed) {
+                        if (subscription) {
+                            await closeSubscription(deadlineAt).catch((errorArg) => errors.push(errorArg));
+                        }
+                        else {
+                            subscriptionClosed = true;
+                        }
+                    }
+                    if (!capabilityRevoked) {
+                        this.trackCapabilityRevocation(runtime, capabilityId, 'human', () => { capabilityRevoked = true; });
+                        await this.awaitCapabilityRevocation(capabilityId, deadlineAt).then(() => { capabilityRevoked = true; }, (errorArg) => errors.push(errorArg));
+                    }
+                    if (runtimeDisconnectComplete || capabilityRevoked)
+                        subscriptionClosed = true;
+                    if (errors.length > 0)
+                        throw new AggregateError(errors, 'Browser view cleanup is incomplete.');
+                    this.humanViews.delete(humanView);
+                },
+            };
+            this.humanViews.add(humanView);
+            return humanView;
+        }
+        catch (errorArg) {
+            const cleanupErrors = [];
+            if (issuancePromise) {
+                this.trackLateCapabilityIssuance(runtime, issuancePromise, 'human');
+            }
+            else if (capabilityId && !capabilityRevoked) {
+                this.trackCapabilityRevocation(runtime, capabilityId, 'human');
+                await this.awaitCapabilityRevocation(capabilityId, Date.now() + this.cleanupTimeoutMs).catch((cleanupErrorArg) => cleanupErrors.push(cleanupErrorArg));
+            }
+            if (humanView)
+                this.humanViews.delete(humanView);
+            if (cleanupErrors.length > 0) {
+                throw new AggregateError([errorArg, ...cleanupErrors], 'Browser view admission and cleanup failed.');
+            }
+            throw errorArg;
+        }
+        finally {
+            inputArg.signal.removeEventListener('abort', abortFromInput);
+            this.admissionAbortController.signal.removeEventListener('abort', abortFromHost);
+            this.humanViewAdmissions.delete(admission);
+            admission.resolveSettled();
+        }
+    }
+    async startResource(resourceArg, signalArg) {
+        signalArg.throwIfAborted();
+        await this.reconcileAttachment(resourceArg, signalArg);
+    }
+    async stopResource(resourceArg, signalArg) {
+        signalArg.throwIfAborted();
+        if (!this.runtime || this.stopping)
+            return;
+        await this.runtime.terminateResource(resourceArg.projectId, resourceArg.id);
+    }
+    isRunning(resourceArg) {
+        if (!this.runtime || this.stopping)
+            return false;
+        const registration = this.runtime.listResources().find((candidate) => (candidate.projectId === resourceArg.projectId
+            && candidate.browserResourceId === resourceArg.id));
+        return registration?.incarnationStatus === 'running';
+    }
+    isAvailable() {
+        return this.started && !this.stopping;
+    }
+    async reconcileAttachment(resourceArg, signalArg) {
+        signalArg.throwIfAborted();
+        if (resourceArg.kind !== 'browser')
+            return;
+        if (this.unavailable)
+            return;
+        if (!this.runtime || this.stopping)
+            throw new Error('BrowserRuntime is not started.');
+        const attachmentBinding = {
+            attachmentAuthorityId: resourceArg.attachmentAuthorityId,
+            attachmentRevision: resourceArg.attachmentRevision,
+            sessionId: resourceArg.sessionId,
+        };
+        const existing = this.runtime.listResources().find((candidate) => (candidate.projectId === resourceArg.projectId
+            && candidate.browserResourceId === resourceArg.id));
+        if (!existing) {
+            this.runtime.registerResource({
+                projectId: resourceArg.projectId,
+                browserResourceId: resourceArg.id,
+                attachmentBinding,
+            });
+            return;
+        }
+        await this.runtime.applyAttachmentBinding({
+            projectId: resourceArg.projectId,
+            browserResourceId: resourceArg.id,
+            attachmentBinding,
+        });
+    }
+    async retireResource(resourceArg, signalArg) {
+        signalArg.throwIfAborted();
+        if (!this.runtime || this.stopping || resourceArg.kind !== 'browser')
+            return;
+        const registered = this.runtime.listResources().some((candidate) => (candidate.projectId === resourceArg.projectId
+            && candidate.browserResourceId === resourceArg.id));
+        if (!registered) {
+            this.runtime.registerResource({
+                projectId: resourceArg.projectId,
+                browserResourceId: resourceArg.id,
+                attachmentBinding: {
+                    attachmentAuthorityId: resourceArg.attachmentAuthorityId,
+                    attachmentRevision: resourceArg.attachmentRevision,
+                    sessionId: resourceArg.sessionId,
+                },
+            });
+        }
+        await this.runtime.retireResource(resourceArg.projectId, resourceArg.id);
+    }
+    get availability() {
+        return this.started && !this.stopping ? 'available' : 'unavailable';
+    }
+    isFlexRunActive(bindingArg, runIdArg) {
+        if (bindingArg.runId !== runIdArg)
+            return false;
+        return this.options.isFlexRunActive?.(bindingArg, runIdArg) ?? true;
+    }
+    trackCapabilityRevocation(runtimeArg, capabilityIdArg, ownerArg, onFulfilledArg) {
+        const existing = this.capabilityRevocationOperations.get(capabilityIdArg);
+        if (existing && existing.owner !== ownerArg) {
+            throw new Error('Browser capability cleanup ownership changed unexpectedly.');
+        }
+        if (existing && existing.outcome?.status !== 'rejected') {
+            if (onFulfilledArg)
+                existing.onFulfilled.add(onFulfilledArg);
+            return;
+        }
+        const onFulfilled = new Set(existing?.onFulfilled ?? []);
+        if (onFulfilledArg)
+            onFulfilled.add(onFulfilledArg);
+        if (existing)
+            this.capabilityRevocationOperations.delete(capabilityIdArg);
+        if (this.capabilityRevocationOperations.size >= maximumTrackedCapabilityRevocations) {
+            throw new Error('Browser capability cleanup capacity was reached.');
+        }
+        const operation = observeCleanupOperation(() => runtimeArg.revokeCapability(capabilityIdArg), (outcomeArg) => {
+            if (outcomeArg.status === 'fulfilled') {
+                for (const callback of operation.onFulfilled)
+                    callback();
+                operation.onFulfilled.clear();
+                if (this.capabilityRevocationOperations.get(capabilityIdArg) === operation) {
+                    this.capabilityRevocationOperations.delete(capabilityIdArg);
+                }
+            }
+        });
+        operation.runtime = runtimeArg;
+        operation.owner = ownerArg;
+        operation.onFulfilled = onFulfilled;
+        this.capabilityRevocationOperations.set(capabilityIdArg, operation);
+    }
+    async awaitCapabilityRevocation(capabilityIdArg, deadlineAtArg, signalArg) {
+        const operation = this.capabilityRevocationOperations.get(capabilityIdArg);
+        if (!operation)
+            return;
+        const outcome = await waitForObservedCleanup(operation, deadlineAtArg, 'Browser capability cleanup timed out.', signalArg);
+        if (outcome.status === 'rejected')
+            throw outcome.reason;
+    }
+    trackLateCapabilityIssuance(runtimeArg, issuancePromiseArg, ownerArg) {
+        const task = (async () => {
+            const issued = await issuancePromiseArg;
+            this.trackCapabilityRevocation(runtimeArg, issued.capabilityId, ownerArg);
+            await this.awaitCapabilityRevocation(issued.capabilityId, Date.now() + this.cleanupTimeoutMs);
+        })();
+        this.lateCapabilityIssuanceTasks.set(task, ownerArg);
+        void task.catch(() => undefined).finally(() => this.lateCapabilityIssuanceTasks.delete(task));
+    }
+    async closeAllHumanViews(deadlineAtArg) {
+        const results = await Promise.allSettled([...this.humanViews].map((view) => waitForCleanupDeadline(view.close(), deadlineAtArg, 'Human browser view cleanup timed out.')));
+        const errors = results
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (errors.length > 0) {
+            throw new AggregateError(errors, 'Human browser view cleanup is incomplete.');
+        }
+    }
+    async retryPendingCapabilityRevocations(deadlineAtArg, signalArg, ownerArg) {
+        const entries = [...this.capabilityRevocationOperations.entries()].filter(([, operation]) => (ownerArg === undefined || operation.owner === ownerArg));
+        for (const [capabilityId, operation] of entries) {
+            if (operation.outcome?.status === 'rejected') {
+                this.trackCapabilityRevocation(operation.runtime, capabilityId, operation.owner);
+            }
+        }
+        const results = await Promise.allSettled([...this.capabilityRevocationOperations.entries()]
+            .filter(([, operation]) => ownerArg === undefined || operation.owner === ownerArg)
+            .map(([capabilityId]) => (this.awaitCapabilityRevocation(capabilityId, deadlineAtArg, signalArg))));
+        const errors = results
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (errors.length > 0) {
+            throw new AggregateError(errors, 'Pending browser capability cleanup is incomplete.');
+        }
+    }
+    async cancelAndDrainFlexChannelAdmissions(deadlineAtArg) {
+        const admissions = [...this.flexChannelAdmissions.entries()];
+        for (const [channelId, admission] of admissions) {
+            this.flexAuthorizationBindings.delete(channelId);
+            if (!admission.abortController.signal.aborted) {
+                admission.abortController.abort(new Error('Browser resource host is stopping.'));
+            }
+        }
+        await Promise.all(admissions.map(([, admission]) => waitForCleanupDeadline(admission.settled, deadlineAtArg, 'Flex browser channel admission cleanup timed out.')));
+    }
+    async drainHumanViewAdmissions(deadlineAtArg) {
+        const admissions = [...this.humanViewAdmissions];
+        for (const admission of admissions) {
+            if (!admission.abortController.signal.aborted) {
+                admission.abortController.abort(new Error('Browser resource host is stopping.'));
+            }
+        }
+        await Promise.all(admissions.map((admission) => waitForCleanupDeadline(admission.settled, deadlineAtArg, 'Human browser view admission cleanup timed out.')));
+    }
+    async drainLateCapabilityIssuanceTasks(deadlineAtArg, ownerArg) {
+        const tasks = [...this.lateCapabilityIssuanceTasks.entries()]
+            .filter(([, owner]) => ownerArg === undefined || owner === ownerArg)
+            .map(([task]) => task);
+        const results = await Promise.allSettled(tasks.map((task) => waitForCleanupDeadline(task, deadlineAtArg, 'Late browser capability issuance cleanup timed out.')));
+        const errors = results
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (errors.length > 0) {
+            throw new AggregateError(errors, 'Late browser capability issuance cleanup is incomplete.');
+        }
+    }
+    async stopRuntime(runtimeArg, deadlineAtArg) {
+        let operation = this.runtimeStopOperations.get(runtimeArg);
+        if (operation?.outcome?.status === 'rejected') {
+            this.runtimeStopOperations.delete(runtimeArg);
+            operation = undefined;
+        }
+        if (!operation) {
+            operation = observeCleanupOperation(() => runtimeArg.stop());
+            operation.runtime = runtimeArg;
+            this.runtimeStopOperations.set(runtimeArg, operation);
+        }
+        const outcome = await waitForObservedCleanup(operation, deadlineAtArg, 'BrowserRuntime shutdown timed out.');
+        if (outcome.status === 'rejected')
+            throw outcome.reason;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.browserresourcehost.js","sourceRoot":"","sources":["../../ts/classes.browserresourcehost.ts"],"names":[],"mappings":"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"}