@rynx-ai/server 0.1.0 → 0.1.10-beta.2

package/dist/session-browser-surface-coordinator.d.ts

@@ -0,0 +1,24 @@
+import { type RuntimeBrowserSurfaceOpenFrame } from "@rynx-ai/protocol/runtime-browser-surface";
+import { type DirectRuntimeBrowserSurfaceAttachment, type DirectRuntimeBrowserSurfaceHost } from "./direct-runtime-browser-surface-server.js";
+import { SessionBrowserService } from "./session-browser-service.js";
+export interface SessionBrowserSurfaceCoordinatorOptions {
+    frameAcknowledgeTimeoutMs?: number;
+    maxPendingEvents?: number;
+    maxPendingEventBytes?: number;
+}
+/**
+ * Owns one physical capture stream per Page, fans it out to bounded logical
+ * subscribers, and arbitrates the single human-driver lease. It never exposes a
+ * Host Page ID or CDP.
+ */
+export declare class SessionBrowserSurfaceCoordinator implements DirectRuntimeBrowserSurfaceHost {
+    private readonly browsers;
+    private readonly pages;
+    private readonly pageQueues;
+    private readonly frameAcknowledgeTimeoutMs;
+    private readonly maxPendingEvents;
+    private readonly maxPendingEventBytes;
+    constructor(browsers: SessionBrowserService, options?: SessionBrowserSurfaceCoordinatorOptions);
+    open(frame: RuntimeBrowserSurfaceOpenFrame, context: Parameters<DirectRuntimeBrowserSurfaceHost["open"]>[1]): Promise<DirectRuntimeBrowserSurfaceAttachment>;
+    private exclusivePage;
+}

package/dist/session-browser-surface-coordinator.js

@@ -0,0 +1,669 @@
+import { RUNTIME_BROWSER_SURFACE_MAX_CONTROL_FRAME_BYTES, RUNTIME_BROWSER_SURFACE_MAX_ENCODED_FRAME_BYTES, RUNTIME_BROWSER_SURFACE_FRAME_ACK_TIMEOUT_MS, RUNTIME_BROWSER_SURFACE_MAX_RELIABLE_INPUT_QUEUE, RUNTIME_BROWSER_SURFACE_MAX_SUBSCRIBERS_PER_PAGE, } from "@rynx-ai/protocol/runtime-browser-surface";
+import { DirectRuntimeBrowserSurfaceHostError, } from "./direct-runtime-browser-surface-server.js";
+import { SessionBrowserHostError, SessionBrowserServiceError, SessionBrowserSurfaceUnsupportedError, } from "./session-browser-service.js";
+const DEFAULT_MAX_PENDING_EVENTS = 8;
+const DEFAULT_MAX_PENDING_EVENT_BYTES = RUNTIME_BROWSER_SURFACE_MAX_ENCODED_FRAME_BYTES +
+    RUNTIME_BROWSER_SURFACE_MAX_CONTROL_FRAME_BYTES * DEFAULT_MAX_PENDING_EVENTS;
+/**
+ * Owns one physical capture stream per Page, fans it out to bounded logical
+ * subscribers, and arbitrates the single human-driver lease. It never exposes a
+ * Host Page ID or CDP.
+ */
+export class SessionBrowserSurfaceCoordinator {
+    browsers;
+    pages = new Map();
+    pageQueues = new Map();
+    frameAcknowledgeTimeoutMs;
+    maxPendingEvents;
+    maxPendingEventBytes;
+    constructor(browsers, options = {}) {
+        this.browsers = browsers;
+        this.frameAcknowledgeTimeoutMs = options.frameAcknowledgeTimeoutMs
+            ?? RUNTIME_BROWSER_SURFACE_FRAME_ACK_TIMEOUT_MS;
+        if (!Number.isSafeInteger(this.frameAcknowledgeTimeoutMs) || this.frameAcknowledgeTimeoutMs < 1) {
+            throw new Error("Browser Surface frame acknowledgement timeout must be positive");
+        }
+        this.maxPendingEvents = positiveLimit(options.maxPendingEvents, DEFAULT_MAX_PENDING_EVENTS, "Browser Surface pending event limit");
+        this.maxPendingEventBytes = positiveLimit(options.maxPendingEventBytes, DEFAULT_MAX_PENDING_EVENT_BYTES, "Browser Surface pending event byte limit");
+    }
+    async open(frame, context) {
+        if (frame.requestedRole === "control" &&
+            !context.peer.subject.effectiveAuthorities.includes("daemon.full")) {
+            throw new DirectRuntimeBrowserSurfaceHostError("unauthorized", "Runtime grant does not allow Browser control");
+        }
+        const pageKey = `${frame.sessionId}\u0000${frame.pageId}`;
+        return this.exclusivePage(pageKey, async () => {
+            context.signal.throwIfAborted();
+            try {
+                await this.browsers.validateSurfaceTarget({
+                    sessionId: frame.sessionId,
+                    browserGeneration: frame.browserGeneration,
+                    pageId: frame.pageId,
+                });
+            }
+            catch (error) {
+                throw mapSurfaceOpenError(error);
+            }
+            context.signal.throwIfAborted();
+            let page = this.pages.get(pageKey);
+            if (page?.isClosing()) {
+                await page.closed();
+                page = undefined;
+            }
+            if (page && page.browserGeneration !== frame.browserGeneration) {
+                await page.finish("generation_changed", "Browser generation changed", true);
+                page = undefined;
+            }
+            if (!page) {
+                const sourceController = new AbortController();
+                let source;
+                try {
+                    source = await this.browsers.openSurface({
+                        sessionId: frame.sessionId,
+                        browserGeneration: frame.browserGeneration,
+                        pageId: frame.pageId,
+                        format: frame.format,
+                        quality: frame.quality,
+                        maximumFrameRate: frame.maximumFrameRate,
+                        signal: sourceController.signal,
+                    });
+                }
+                catch (error) {
+                    sourceController.abort();
+                    throw mapSurfaceOpenError(error);
+                }
+                if (context.signal.aborted) {
+                    sourceController.abort();
+                    await source.close().catch(() => undefined);
+                    throw new DirectRuntimeBrowserSurfaceHostError("cancelled", "Browser Surface open was cancelled");
+                }
+                page = new SharedPageSurface({
+                    source,
+                    sourceController,
+                    frameAcknowledgeTimeoutMs: this.frameAcknowledgeTimeoutMs,
+                    maxPendingEvents: this.maxPendingEvents,
+                    maxPendingEventBytes: this.maxPendingEventBytes,
+                    onClose: () => {
+                        if (this.pages.get(pageKey) === page)
+                            this.pages.delete(pageKey);
+                    },
+                });
+                this.pages.set(pageKey, page);
+            }
+            const attachment = page.attach(frame, context.signal);
+            page.start();
+            return attachment;
+        });
+    }
+    exclusivePage(pageKey, operation) {
+        const previous = this.pageQueues.get(pageKey) ?? Promise.resolve();
+        const result = previous.then(operation, operation);
+        const completion = result.then(() => undefined, () => undefined);
+        this.pageQueues.set(pageKey, completion);
+        void completion.finally(() => {
+            if (this.pageQueues.get(pageKey) === completion)
+                this.pageQueues.delete(pageKey);
+        });
+        return result;
+    }
+}
+class SharedPageSurface {
+    page;
+    browserGeneration;
+    subscribers = new Map();
+    restingDriver;
+    physicalDriver;
+    owner;
+    desiredOwner;
+    pendingInputCount = 0;
+    inputTail = Promise.resolve();
+    inputEpoch = 0;
+    acceptingInput = false;
+    inputResetRequired = false;
+    driverTransitionTail = Promise.resolve();
+    started = false;
+    closing = false;
+    closePromise;
+    constructor(page) {
+        this.page = page;
+        this.browserGeneration = page.source.browserGeneration;
+        this.restingDriver = page.source.setHumanDriver ? "desktop" : "none";
+        this.physicalDriver = this.restingDriver;
+    }
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        void this.pumpFrames();
+    }
+    isClosing() {
+        return this.closing;
+    }
+    closed() {
+        return this.closePromise ?? Promise.resolve();
+    }
+    attach(open, signal) {
+        if (this.closing) {
+            throw new DirectRuntimeBrowserSurfaceHostError("browser_closed", "Browser Surface is closing");
+        }
+        if (open.browserGeneration !== this.browserGeneration) {
+            throw new DirectRuntimeBrowserSurfaceHostError("generation_changed", "Browser generation changed");
+        }
+        if (open.format !== this.page.source.format) {
+            throw new DirectRuntimeBrowserSurfaceHostError("capacity", `Browser Surface Page is already streaming ${this.page.source.format}`);
+        }
+        if (this.subscribers.size >= RUNTIME_BROWSER_SURFACE_MAX_SUBSCRIBERS_PER_PAGE) {
+            throw new DirectRuntimeBrowserSurfaceHostError("capacity", "Browser Surface Page reached its Preview limit");
+        }
+        if (this.subscribers.has(open.subscriptionId)) {
+            throw new DirectRuntimeBrowserSurfaceHostError("protocol_error", "Browser Surface subscription already exists");
+        }
+        const attachment = new CoordinatedSurfaceAttachment({
+            open,
+            page: this,
+            signal,
+            frameAcknowledgeTimeoutMs: this.page.frameAcknowledgeTimeoutMs,
+            maxPendingEvents: this.page.maxPendingEvents,
+            maxPendingEventBytes: this.page.maxPendingEventBytes,
+        });
+        this.subscribers.set(open.subscriptionId, attachment);
+        attachment.start();
+        return attachment;
+    }
+    getViewport() {
+        return this.page.source.getViewport();
+    }
+    driverState() {
+        return this.owner
+            ? { driver: "stream", driverSubscriptionId: this.owner.subscriptionId }
+            : { driver: this.restingDriver };
+    }
+    async pumpFrames() {
+        try {
+            for await (const frame of this.page.source.frames) {
+                if (this.closing) {
+                    await frame.acknowledge();
+                    return;
+                }
+                if (frame.browserGeneration !== this.browserGeneration) {
+                    await frame.acknowledge();
+                    await this.finish("generation_changed", "Browser generation changed", true);
+                    return;
+                }
+                if (frame.format !== this.page.source.format) {
+                    await frame.acknowledge();
+                    throw new Error("Browser Host changed the Surface image format");
+                }
+                for (const subscriber of [...this.subscribers.values()]) {
+                    subscriber.offerFrame(frame);
+                }
+                await frame.acknowledge();
+                if (this.closing)
+                    return;
+            }
+            if (!this.closing) {
+                await this.finish("browser_closed", "Browser Surface source ended", true);
+            }
+        }
+        catch (error) {
+            if (!this.closing) {
+                const mapped = mapSurfaceHostError(error, "Browser Surface source failed");
+                await this.finish(mapped.reason, mapped.message, true);
+            }
+        }
+    }
+    takeDriver(attachment) {
+        if (this.closing || !this.subscribers.has(attachment.subscriptionId))
+            return Promise.resolve();
+        if (this.desiredOwner === attachment && this.owner === attachment && this.acceptingInput) {
+            return Promise.resolve();
+        }
+        if (this.owner !== attachment) {
+            this.fenceInput();
+            if (this.owner)
+                this.inputResetRequired = true;
+        }
+        this.desiredOwner = attachment;
+        return this.enqueueDriverTransition(() => this.reconcileDriver()).catch((error) => {
+            throw mapSurfaceHostError(error, "Browser Surface driver handoff failed");
+        });
+    }
+    releaseDriver(attachment) {
+        if (this.desiredOwner !== attachment && this.owner !== attachment)
+            return Promise.resolve();
+        this.fenceInput();
+        this.inputResetRequired = true;
+        if (this.desiredOwner === attachment)
+            this.desiredOwner = undefined;
+        return this.enqueueDriverTransition(() => this.reconcileDriver()).catch((error) => {
+            throw mapSurfaceHostError(error, "Browser Surface driver release failed");
+        });
+    }
+    async dispatchInput(attachment, frame) {
+        if (this.owner !== attachment ||
+            !this.acceptingInput ||
+            !this.subscribers.has(attachment.subscriptionId)) {
+            throw new DirectRuntimeBrowserSurfaceHostError("unauthorized", "Browser Surface does not own the human driver");
+        }
+        if (this.pendingInputCount >= RUNTIME_BROWSER_SURFACE_MAX_RELIABLE_INPUT_QUEUE) {
+            throw new DirectRuntimeBrowserSurfaceHostError("capacity", "Browser Surface input queue is full");
+        }
+        this.pendingInputCount += 1;
+        const inputEpoch = this.inputEpoch;
+        try {
+            const operation = this.inputTail.then(async () => {
+                if (this.closing ||
+                    !this.acceptingInput ||
+                    this.owner !== attachment ||
+                    inputEpoch !== this.inputEpoch)
+                    return;
+                await this.page.source.dispatchTrustedInput({
+                    browserGeneration: frame.browserGeneration,
+                    viewportRevision: frame.viewportRevision,
+                    event: frame.event,
+                });
+            });
+            this.inputTail = operation.then(() => undefined, () => undefined);
+            await operation;
+        }
+        catch (error) {
+            throw mapSurfaceHostError(error, "Browser Surface input failed");
+        }
+        finally {
+            this.pendingInputCount -= 1;
+        }
+    }
+    detach(attachment) {
+        if (this.subscribers.get(attachment.subscriptionId) !== attachment) {
+            return Promise.resolve();
+        }
+        this.subscribers.delete(attachment.subscriptionId);
+        if (this.owner === attachment || this.desiredOwner === attachment) {
+            this.fenceInput();
+            this.inputResetRequired = true;
+            if (this.desiredOwner === attachment)
+                this.desiredOwner = undefined;
+        }
+        if (this.subscribers.size === 0) {
+            return this.finish("cancelled", undefined, false);
+        }
+        return this.enqueueDriverTransition(() => this.reconcileDriver()).catch(() => undefined);
+    }
+    async reconcileDriver() {
+        await this.inputTail;
+        if (this.inputResetRequired) {
+            await this.page.source.resetTrustedInput?.();
+            this.inputResetRequired = false;
+        }
+        const desired = this.desiredOwner &&
+            this.subscribers.get(this.desiredOwner.subscriptionId) === this.desiredOwner
+            ? this.desiredOwner
+            : undefined;
+        const targetDriver = desired ? "stream" : this.restingDriver;
+        if (this.physicalDriver !== targetDriver) {
+            await this.page.source.setHumanDriver?.(targetDriver === "stream" ? "stream" : "desktop");
+            this.physicalDriver = targetDriver;
+        }
+        const currentDesired = this.desiredOwner &&
+            this.subscribers.get(this.desiredOwner.subscriptionId) === this.desiredOwner
+            ? this.desiredOwner
+            : undefined;
+        if (currentDesired !== desired || this.closing)
+            return;
+        const changed = this.owner !== desired;
+        this.owner = desired;
+        this.inputEpoch += 1;
+        this.acceptingInput = desired !== undefined;
+        if (changed)
+            this.broadcastDriverChanged();
+    }
+    enqueueDriverTransition(operation) {
+        const result = this.driverTransitionTail.then(operation, operation);
+        this.driverTransitionTail = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    fenceInput() {
+        this.acceptingInput = false;
+        this.inputEpoch += 1;
+    }
+    broadcastDriverChanged() {
+        const state = this.driverState();
+        for (const subscriber of [...this.subscribers.values()]) {
+            subscriber.emitDriverChanged(state);
+        }
+    }
+    finish(reason, message, notify) {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closing = true;
+        this.fenceInput();
+        if (this.owner || this.desiredOwner || this.physicalDriver === "stream") {
+            this.inputResetRequired = true;
+        }
+        this.desiredOwner = undefined;
+        for (const subscriber of [...this.subscribers.values()]) {
+            subscriber.finishFromPage(reason, message, notify);
+        }
+        this.subscribers.clear();
+        this.page.sourceController.abort();
+        const releaseDriver = this.enqueueDriverTransition(async () => {
+            await this.inputTail;
+            try {
+                if (this.inputResetRequired)
+                    await this.page.source.resetTrustedInput?.();
+                this.inputResetRequired = false;
+            }
+            catch {
+                // Closing remains fail-safe: capture must still be released if the
+                // renderer no longer accepts synthesized key/button releases.
+            }
+            if (this.physicalDriver !== this.restingDriver) {
+                try {
+                    await this.page.source.setHumanDriver?.("desktop");
+                    this.physicalDriver = this.restingDriver;
+                }
+                catch {
+                    // Closing remains fail-safe: capture is released even if Host handoff fails.
+                }
+            }
+            this.owner = undefined;
+        });
+        this.closePromise = releaseDriver.then(() => this.page.source.close())
+            .catch(() => undefined)
+            .finally(this.page.onClose);
+        return this.closePromise;
+    }
+}
+class CoordinatedSurfaceAttachment {
+    attachment;
+    ready;
+    events;
+    subscriptionId;
+    eventQueue;
+    abortHandler;
+    frameSequence = 0;
+    lastInputSequence = -1;
+    pendingFrame;
+    closing = false;
+    closePromise;
+    constructor(attachment) {
+        this.attachment = attachment;
+        this.subscriptionId = attachment.open.subscriptionId;
+        this.eventQueue = new SurfaceEventQueue({
+            maxPendingEvents: attachment.maxPendingEvents,
+            maxPendingBytes: attachment.maxPendingEventBytes,
+        });
+        const viewport = attachment.page.getViewport();
+        this.ready = {
+            type: "browser.surface.ready",
+            subscriptionId: this.subscriptionId,
+            browserGeneration: attachment.open.browserGeneration,
+            viewportRevision: viewport.revision,
+            sourceWidth: viewport.width,
+            sourceHeight: viewport.height,
+            deviceScaleFactor: viewport.deviceScaleFactor,
+            format: attachment.open.format,
+            grantedRole: attachment.open.requestedRole,
+        };
+        this.events = this.eventQueue;
+        this.abortHandler = () => {
+            void this.finish("cancelled", "Browser Surface connection was cancelled", true);
+        };
+        attachment.signal.addEventListener("abort", this.abortHandler, { once: true });
+    }
+    start() {
+        this.emitDriverChanged(this.attachment.page.driverState());
+    }
+    async handle(frame) {
+        if (this.closing)
+            return;
+        if (frame.subscriptionId !== this.subscriptionId) {
+            throw new DirectRuntimeBrowserSurfaceHostError("protocol_error", "Browser Surface subscription does not match");
+        }
+        switch (frame.type) {
+            case "browser.surface.frame.ack":
+                this.acknowledgeFrame(frame.frameSequence);
+                return;
+            case "browser.surface.driver.take":
+                this.requireGeneration(frame.browserGeneration);
+                this.requireControlRole();
+                if (!this.matchesViewport(frame.viewportRevision))
+                    return;
+                await this.attachment.page.takeDriver(this);
+                return;
+            case "browser.surface.driver.release":
+                this.requireGeneration(frame.browserGeneration);
+                await this.attachment.page.releaseDriver(this);
+                return;
+            case "browser.surface.input":
+                this.requireGeneration(frame.browserGeneration);
+                this.requireControlRole();
+                if (!this.matchesViewport(frame.viewportRevision))
+                    return;
+                if (frame.inputSequence <= this.lastInputSequence) {
+                    throw new DirectRuntimeBrowserSurfaceHostError("protocol_error", "Browser Surface input sequence must increase");
+                }
+                this.lastInputSequence = frame.inputSequence;
+                await this.attachment.page.dispatchInput(this, frame);
+        }
+    }
+    close(_reason) {
+        return this.finish("cancelled", undefined, false);
+    }
+    offerFrame(frame) {
+        if (this.closing || this.pendingFrame)
+            return;
+        const sequence = ++this.frameSequence;
+        const timer = setTimeout(() => {
+            void this.finish("idle_timeout", "Browser Surface frame was not acknowledged", true);
+        }, this.attachment.frameAcknowledgeTimeoutMs);
+        timer.unref?.();
+        this.pendingFrame = { sequence, timer };
+        const image = {
+            subscriptionId: this.subscriptionId,
+            frameSequence: sequence,
+            viewportRevision: frame.viewportRevision,
+            timestampMilliseconds: frame.timestampMilliseconds,
+            width: frame.width,
+            height: frame.height,
+            format: frame.format,
+            encodedBytes: frame.encodedBytes,
+        };
+        if (!this.eventQueue.push(image)) {
+            clearTimeout(timer);
+            this.pendingFrame = undefined;
+            void this.finish("capacity", "Browser Surface event queue is full", true);
+        }
+    }
+    emitDriverChanged(state) {
+        if (this.closing)
+            return;
+        const event = {
+            type: "browser.surface.driver.changed",
+            subscriptionId: this.subscriptionId,
+            browserGeneration: this.ready.browserGeneration,
+            driver: state.driver,
+            ...(state.driverSubscriptionId === undefined
+                ? {}
+                : { driverSubscriptionId: state.driverSubscriptionId }),
+        };
+        if (!this.eventQueue.push(event)) {
+            void this.finish("capacity", "Browser Surface event queue is full", true);
+        }
+    }
+    finishFromPage(reason, message, notify) {
+        void this.finish(reason, message, notify, false);
+    }
+    acknowledgeFrame(sequence) {
+        const pending = this.pendingFrame;
+        if (!pending || pending.sequence !== sequence) {
+            throw new DirectRuntimeBrowserSurfaceHostError("protocol_error", "Browser Surface frame acknowledgement is stale or unknown");
+        }
+        clearTimeout(pending.timer);
+        this.pendingFrame = undefined;
+    }
+    requireGeneration(generation) {
+        if (generation !== this.ready.browserGeneration) {
+            throw new DirectRuntimeBrowserSurfaceHostError("generation_changed", "Browser generation changed");
+        }
+    }
+    matchesViewport(revision) {
+        return revision === this.attachment.page.getViewport().revision;
+    }
+    requireControlRole() {
+        if (this.ready.grantedRole !== "control") {
+            throw new DirectRuntimeBrowserSurfaceHostError("unauthorized", "Browser Surface is view-only");
+        }
+    }
+    finish(reason, message, notify, detach = true) {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closing = true;
+        this.attachment.signal.removeEventListener("abort", this.abortHandler);
+        const pending = this.pendingFrame;
+        this.pendingFrame = undefined;
+        if (pending)
+            clearTimeout(pending.timer);
+        this.eventQueue.close(notify
+            ? {
+                type: "browser.surface.closed",
+                subscriptionId: this.subscriptionId,
+                reason,
+                ...(message === undefined ? {} : { message: message.slice(0, 1_024) }),
+            }
+            : undefined);
+        this.closePromise = detach
+            ? this.attachment.page.detach(this)
+            : Promise.resolve();
+        return this.closePromise;
+    }
+}
+class SurfaceEventQueue {
+    options;
+    items = [];
+    queuedBytes = 0;
+    waiter;
+    ended = false;
+    constructor(options) {
+        this.options = options;
+    }
+    push(event) {
+        if (this.ended)
+            return false;
+        if (this.waiter) {
+            const waiter = this.waiter;
+            this.waiter = undefined;
+            waiter({ done: false, value: event });
+            return true;
+        }
+        const bytes = surfaceEventBytes(event);
+        const tail = this.items.at(-1);
+        if (tail &&
+            isDriverChanged(tail.event) &&
+            isDriverChanged(event)) {
+            const nextBytes = this.queuedBytes - tail.bytes + bytes;
+            if (nextBytes > this.options.maxPendingBytes)
+                return false;
+            tail.event = event;
+            tail.bytes = bytes;
+            this.queuedBytes = nextBytes;
+            return true;
+        }
+        if (this.items.length >= this.options.maxPendingEvents ||
+            this.queuedBytes + bytes > this.options.maxPendingBytes)
+            return false;
+        this.items.push({ event, bytes });
+        this.queuedBytes += bytes;
+        return true;
+    }
+    close(finalEvent) {
+        if (this.ended)
+            return;
+        this.ended = true;
+        this.items.length = 0;
+        this.queuedBytes = 0;
+        if (finalEvent) {
+            if (this.waiter)
+                this.waiter({ done: false, value: finalEvent });
+            else {
+                const bytes = surfaceEventBytes(finalEvent);
+                this.items.push({ event: finalEvent, bytes });
+                this.queuedBytes = bytes;
+            }
+        }
+        else {
+            this.waiter?.({ done: true, value: undefined });
+        }
+        this.waiter = undefined;
+    }
+    [Symbol.asyncIterator]() {
+        return { next: () => this.next() };
+    }
+    next() {
+        const pending = this.items.shift();
+        if (pending) {
+            this.queuedBytes -= pending.bytes;
+            return Promise.resolve({ done: false, value: pending.event });
+        }
+        if (this.ended)
+            return Promise.resolve({ done: true, value: undefined });
+        if (this.waiter)
+            return Promise.reject(new Error("Browser Surface event read is already pending"));
+        return new Promise((resolve) => {
+            this.waiter = resolve;
+        });
+    }
+}
+function isDriverChanged(event) {
+    return "type" in event && event.type === "browser.surface.driver.changed";
+}
+function surfaceEventBytes(event) {
+    return "encodedBytes" in event
+        ? event.encodedBytes.byteLength + 128
+        : Buffer.byteLength(JSON.stringify(event), "utf8");
+}
+function positiveLimit(value, fallback, field) {
+    const resolved = value ?? fallback;
+    if (!Number.isSafeInteger(resolved) || resolved < 1) {
+        throw new Error(`${field} must be a positive safe integer`);
+    }
+    return resolved;
+}
+function mapSurfaceOpenError(error) {
+    if (error instanceof SessionBrowserSurfaceUnsupportedError) {
+        return new DirectRuntimeBrowserSurfaceHostError("unsupported", error.message, { cause: error });
+    }
+    if (error instanceof SessionBrowserServiceError) {
+        switch (error.code) {
+            case "invalid_request":
+                return new DirectRuntimeBrowserSurfaceHostError("protocol_error", error.message, { cause: error });
+            case "not_found":
+                return new DirectRuntimeBrowserSurfaceHostError("page_closed", error.message, { cause: error });
+            case "generation_mismatch":
+                return new DirectRuntimeBrowserSurfaceHostError("generation_changed", error.message, { cause: error });
+            case "capacity":
+                return new DirectRuntimeBrowserSurfaceHostError("capacity", error.message, { cause: error });
+            case "unavailable":
+            case "shutting_down":
+                return new DirectRuntimeBrowserSurfaceHostError("browser_closed", error.message, { cause: error });
+            case "host_failure":
+            case "outcome_unknown":
+                return new DirectRuntimeBrowserSurfaceHostError("internal_error", error.message, { cause: error });
+        }
+    }
+    return mapSurfaceHostError(error, "Browser Surface could not open");
+}
+function mapSurfaceHostError(error, fallbackMessage) {
+    if (error instanceof DirectRuntimeBrowserSurfaceHostError)
+        return error;
+    if (error instanceof SessionBrowserHostError) {
+        const reason = error.code === "page_not_found"
+            ? "page_closed"
+            : error.code === "capacity"
+                ? "capacity"
+                : "browser_closed";
+        return new DirectRuntimeBrowserSurfaceHostError(reason, error.message, { cause: error });
+    }
+    const message = error instanceof Error ? error.message : fallbackMessage;
+    return new DirectRuntimeBrowserSurfaceHostError("internal_error", message, { cause: error });
+}