@fungi.computer/knapsack 0.1.0 → 0.2.1

package/dist/ui/effect.d.ts

@@ -0,0 +1,106 @@
+import * as Effect from "effect/Effect";
+import * as Scope from "effect/Scope";
+import { type BrowserRequest, type BrowserRequestEnvelope, type BrowserClaimResult, type BrowserWireResult, type BrowserSettlementResult, type BrowserWireObject } from "./wire.js";
+declare const decodeResultEnvelope: (input: BrowserWireObject) => Effect.Effect<{
+    requestId: string;
+    claimId: string;
+    result: {
+        type: "discover";
+        commands: ({
+            action: {
+                inputSchema: Record<string, import("zod").JSONType>;
+                outputSchema: Record<string, import("zod").JSONType>;
+            } | {
+                inputSchema: Record<string, import("zod").JSONType>;
+            } | {
+                outputSchema: Record<string, import("zod").JSONType>;
+            };
+            commandId: string;
+            sourceId: string;
+            title: string;
+            category: string;
+            description: string | null;
+            order: number;
+            keybind: string | null;
+            availability: {
+                status: "available";
+            } | {
+                status: "unavailable";
+                reason: string;
+            };
+        } | {
+            commandId: string;
+            sourceId: string;
+            title: string;
+            category: string;
+            description: string | null;
+            order: number;
+            keybind: string | null;
+            availability: {
+                status: "available";
+            } | {
+                status: "unavailable";
+                reason: string;
+            };
+        })[];
+    } | {
+        type: "execute";
+        outcome: {
+            status: "handled";
+            result: import("zod").JSONType;
+        } | {
+            status: "handled";
+        } | {
+            status: "closed";
+        } | {
+            status: "missing";
+        } | {
+            status: "invalid";
+        } | {
+            status: "unavailable";
+            reason: string;
+        } | {
+            status: "failed";
+            error: {
+                code: string;
+                message: string;
+                details: import("zod").JSONType;
+            };
+        } | {
+            status: "failed";
+            error: {
+                code: string;
+                message: string;
+            };
+        };
+    };
+}, import("effect/Cause").UnknownError, never>;
+declare const decodeClaim: (input: BrowserWireObject) => Effect.Effect<{
+    requestId: string;
+    connectionId: string;
+    attemptId: string;
+}, import("effect/Cause").UnknownError, never>;
+export type UiHostErrorCode = "browser_busy" | "browser_disconnected" | "browser_execution_indeterminate" | "browser_not_connected" | "invalid_browser_wire";
+/** Closed failure vocabulary for the connected-browser request boundary. */
+export declare class UiHostError extends Error {
+    readonly code: UiHostErrorCode;
+    constructor(code: UiHostErrorCode, message: string);
+}
+/** One scope-owned live browser connection. */
+export type UiHostConnection = Readonly<{
+    id: string;
+    take: Effect.Effect<BrowserRequestEnvelope>;
+}>;
+export type UiHostOptions = Readonly<{
+    claimLeaseMs?: number;
+}>;
+/** Canonical Effect-owned browser host execution and connection lifecycle. */
+export type UiHost = Readonly<{
+    connect: () => Effect.Effect<UiHostConnection, never, Scope.Scope>;
+    request: (request: BrowserRequest) => Effect.Effect<BrowserWireResult, UiHostError>;
+    claim: (input: Parameters<typeof decodeClaim>[0]) => Effect.Effect<BrowserClaimResult, UiHostError>;
+    acceptResult: (input: Parameters<typeof decodeResultEnvelope>[0]) => Effect.Effect<BrowserSettlementResult, UiHostError>;
+}>;
+/** Construct the single Effect-owned connected-browser runtime. */
+export declare function make(options?: UiHostOptions): Effect.Effect<UiHost>;
+export {};

package/dist/ui/effect.js

@@ -0,0 +1,208 @@
+import * as Semaphore from "effect/Semaphore";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Queue from "effect/Queue";
+import * as Scope from "effect/Scope";
+import { claimThenSettle } from "@fungi.computer/mycelium/semaphore-transition";
+import { uiWireIds, BrowserClaimSchema, BrowserResultEnvelopeSchema, } from "./wire.js";
+const decodeResultEnvelope = (input) => Effect.try(() => BrowserResultEnvelopeSchema.parse(input));
+const decodeClaim = (input) => Effect.try(() => BrowserClaimSchema.parse(input));
+/** Closed failure vocabulary for the connected-browser request boundary. */
+export class UiHostError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "UiHostError";
+    }
+}
+function disconnected(request) {
+    return request.expected === "execute" && request.phase === "claimed"
+        ? new UiHostError("browser_execution_indeterminate", "The browser disconnected after execution dispatch")
+        : new UiHostError("browser_disconnected", "The connected browser disconnected before returning a result");
+}
+function activeClaimResult(lease, claimed, now, connected) {
+    if (lease === undefined ||
+        lease.expiresAt <= now ||
+        !connected.has(lease.connectionId))
+        return undefined;
+    if (lease.connectionId === claimed.connectionId &&
+        lease.attemptId === claimed.attemptId)
+        return { status: "claimed", claimId: lease.claimId };
+    return {
+        status: "waiting",
+        retryAfterMs: Math.max(10, Math.min(1_000, lease.expiresAt - now)),
+    };
+}
+function hasExpiredClaim(lease, now) {
+    return lease !== undefined && lease.expiresAt <= now;
+}
+function ownsLiveClaim(request, claimId, now) {
+    return (request.phase === "claimed" &&
+        request.claim?.claimId === claimId &&
+        !hasExpiredClaim(request.claim, now));
+}
+/** Construct the single Effect-owned connected-browser runtime. */
+export function make(options = {}) {
+    return Effect.gen(function* () {
+        const gate = yield* Semaphore.make(1);
+        const connections = new Map();
+        const requestedClaimLeaseMs = options.claimLeaseMs ?? 30_000;
+        const claimLeaseMs = Number.isFinite(requestedClaimLeaseMs)
+            ? Math.max(100, Math.min(60_000, requestedClaimLeaseMs))
+            : 30_000;
+        let pending;
+        const claimDisconnection = (connection) => {
+            connections.delete(connection.id);
+            let failed;
+            let reoffer;
+            if (pending?.phase === "claimed" &&
+                pending.claim?.connectionId === connection.id) {
+                if (connections.size > 0) {
+                    pending = { ...pending, phase: "queued", claim: undefined };
+                    reoffer = {
+                        requestId: pending.requestId,
+                        request: pending.request,
+                    };
+                }
+                else {
+                    failed = pending;
+                    pending = undefined;
+                }
+            }
+            else if (pending !== undefined && connections.size === 0) {
+                failed = pending;
+                pending = undefined;
+            }
+            return {
+                connection,
+                failed,
+                reoffer,
+                recipients: [...connections.values()],
+            };
+        };
+        const settleDisconnection = (disconnection) => {
+            const reoffer = disconnection.reoffer;
+            return (disconnection.failed === undefined
+                ? Effect.void
+                : Deferred.fail(disconnection.failed.result, disconnected(disconnection.failed)).pipe(Effect.asVoid)).pipe(Effect.andThen(reoffer === undefined
+                ? Effect.void
+                : Effect.forEach(disconnection.recipients, (recipient) => Queue.offer(recipient.requests, reoffer), { discard: true })), Effect.andThen(Queue.shutdown(disconnection.connection.requests)));
+        };
+        const disconnect = (connection) => claimThenSettle(gate, () => claimDisconnection(connection), settleDisconnection);
+        const connect = () => Effect.acquireRelease(Effect.gen(function* () {
+            const requests = yield* Queue.sliding(1);
+            const connection = {
+                id: uiWireIds.connection.generate(),
+                requests,
+            };
+            yield* gate.withPermits(1)(Effect.sync(() => {
+                connections.set(connection.id, connection);
+                if (pending !== undefined && !pending.cancelled)
+                    Queue.offerUnsafe(connection.requests, {
+                        requestId: pending.requestId,
+                        request: pending.request,
+                    });
+            }));
+            return connection;
+        }), disconnect).pipe(Effect.map((connection) => {
+            const take = () => Queue.take(connection.requests).pipe(Effect.flatMap((envelope) => gate
+                .withPermits(1)(Effect.sync(() => {
+                const owned = pending;
+                return (owned?.requestId === envelope.requestId &&
+                    connections.has(connection.id));
+            }))
+                .pipe(Effect.flatMap((live) => live ? Effect.succeed(envelope) : Effect.suspend(take)))));
+            return Object.freeze({
+                id: connection.id,
+                take: Effect.suspend(take),
+            });
+        }));
+        const markCancelled = (requestId) => claimThenSettle(gate, () => {
+            if (pending?.requestId === requestId)
+                pending = { ...pending, cancelled: true };
+        }, () => Effect.void);
+        const request = (browserRequest) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+            const result = yield* Deferred.make();
+            let requestId;
+            const run = claimThenSettle(gate, () => {
+                if (connections.size === 0)
+                    return { status: "offline" };
+                if (pending !== undefined)
+                    return { status: "busy" };
+                const id = uiWireIds.request.generate();
+                const envelope = {
+                    requestId: id,
+                    request: browserRequest,
+                };
+                pending = {
+                    requestId: id,
+                    request: browserRequest,
+                    cancelled: false,
+                    expected: browserRequest.type,
+                    phase: "queued",
+                    claim: undefined,
+                    result,
+                };
+                for (const connection of connections.values())
+                    Queue.offerUnsafe(connection.requests, envelope);
+                requestId = id;
+                return { status: "admitted" };
+            }, (admission) => {
+                if (admission.status === "offline")
+                    return Effect.fail(new UiHostError("browser_not_connected", "No browser is connected"));
+                if (admission.status === "busy")
+                    return Effect.fail(new UiHostError("browser_busy", "The connected browser already has pending work"));
+                return Effect.void;
+            }).pipe(Effect.andThen(Deferred.await(result)));
+            return yield* restore(run).pipe(Effect.onInterrupt(() => requestId === undefined ? Effect.void : markCancelled(requestId)));
+        }));
+        const claim = (input) => decodeClaim(input).pipe(Effect.mapError(() => new UiHostError("invalid_browser_wire", "Browser claim is invalid")), Effect.flatMap((claimed) => claimThenSettle(gate, () => {
+            const owned = pending;
+            if (owned?.requestId !== claimed.requestId)
+                return { status: "skipped" };
+            if (owned.cancelled) {
+                pending = undefined;
+                return { status: "skipped" };
+            }
+            const now = Date.now();
+            const active = activeClaimResult(owned.claim, claimed, now, new Set(connections.keys()));
+            if (active !== undefined)
+                return active;
+            if (!connections.has(claimed.connectionId))
+                return { status: "skipped" };
+            const lease = {
+                attemptId: claimed.attemptId,
+                claimId: uiWireIds.claim.generate(),
+                connectionId: claimed.connectionId,
+                expiresAt: now + claimLeaseMs,
+            };
+            pending = { ...owned, phase: "claimed", claim: lease };
+            return { status: "claimed", claimId: lease.claimId };
+        }, Effect.succeed)));
+        const acceptResult = (input) => decodeResultEnvelope(input).pipe(Effect.mapError(() => new UiHostError("invalid_browser_wire", "Browser result is invalid")), Effect.flatMap((envelope) => claimThenSettle(gate, () => {
+            const owned = pending;
+            if (owned?.requestId !== envelope.requestId)
+                return { status: "ignored" };
+            const now = Date.now();
+            if (!ownsLiveClaim(owned, envelope.claimId, now)) {
+                if (hasExpiredClaim(owned.claim, now))
+                    pending = { ...owned, phase: "queued", claim: undefined };
+                return { status: "ignored" };
+            }
+            pending = undefined;
+            if (owned.expected !== envelope.result.type) {
+                const failure = new UiHostError("invalid_browser_wire", "Browser result does not match its request");
+                return { status: "mismatch", owned, failure };
+            }
+            return { status: "accepted", owned };
+        }, (settlement) => {
+            if (settlement.status === "ignored")
+                return Effect.succeed({ status: "ignored" });
+            if (settlement.status === "mismatch")
+                return Deferred.fail(settlement.owned.result, settlement.failure).pipe(Effect.andThen(Effect.fail(settlement.failure)));
+            return Deferred.succeed(settlement.owned.result, envelope.result).pipe(Effect.as({ status: "accepted" }));
+        })));
+        return Object.freeze({ connect, request, claim, acceptResult });
+    });
+}

package/dist/ui/host.d.ts

@@ -0,0 +1,9 @@
+import { type ModuleRegistration } from "@fungi.computer/mycelium";
+import { type UiHost as EffectUiHost } from "./effect.js";
+/** Promise/HTTP facade over one Session's Effect-owned browser host. */
+export type UiHostFacade = Readonly<{
+    modules: readonly [ModuleRegistration];
+    fetch: (request: Request) => Promise<Response>;
+}>;
+/** Build one Session browser host: its Mycelium `ui` module and HTTP transport. */
+export declare function createUiHost(runtime?: EffectUiHost): UiHostFacade;

package/dist/ui/host.js

@@ -0,0 +1,158 @@
+import { Mycelium } from "@fungi.computer/mycelium";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import { z } from "zod";
+import { UiHostError, make as makeEffect, } from "./effect.js";
+import { BrowserCommandRowSchema, BrowserExecutionOutcomeSchema, BrowserExecuteInputSchema, BrowserWireObjectSchema, } from "./wire.js";
+const browserUnavailableSchema = z.object({
+    status: z.literal("unavailable"),
+    reason: z.enum([
+        "browser_busy",
+        "browser_not_connected",
+        "browser_disconnected",
+    ]),
+});
+const browserExecutionIndeterminateSchema = z.object({
+    status: z.literal("indeterminate"),
+    reason: z.literal("browser_disconnected_after_dispatch"),
+});
+const browserCommandDiscoverySchema = z.discriminatedUnion("status", [
+    z.object({
+        status: z.literal("available"),
+        commands: z.array(BrowserCommandRowSchema),
+    }),
+    browserUnavailableSchema,
+]);
+const browserCommandExecutionSchema = z.union([
+    BrowserExecutionOutcomeSchema,
+    browserUnavailableSchema,
+    browserExecutionIndeterminateSchema,
+]);
+async function runPromiseAtBoundary(effect, signal) {
+    signal?.throwIfAborted();
+    const exit = await Effect.runPromiseExit(effect, signal === undefined ? undefined : { signal });
+    if (Exit.isSuccess(exit))
+        return exit.value;
+    const failure = Cause.findErrorOption(exit.cause);
+    if (Option.isSome(failure))
+        throw failure.value;
+    if (Cause.hasInterruptsOnly(exit.cause)) {
+        signal?.throwIfAborted();
+        throw new DOMException("The operation was aborted", "AbortError");
+    }
+    const squashed = Cause.squash(exit.cause);
+    if (squashed instanceof Error)
+        throw squashed;
+    throw new Error("Live App command host failed without an Error cause");
+}
+function unavailable(reason) {
+    return { status: "unavailable", reason };
+}
+function recoverUnavailable(error) {
+    switch (error.code) {
+        case "browser_busy":
+        case "browser_not_connected":
+        case "browser_disconnected":
+            return Effect.succeed(unavailable(error.code));
+        default:
+            return Effect.fail(error);
+    }
+}
+function discoveryRequest(runtime, request) {
+    return runtime.request(request).pipe(Effect.catch(recoverUnavailable));
+}
+function executionRequest(runtime, request) {
+    return runtime.request(request).pipe(Effect.catch((error) => {
+        if (error.code === "browser_execution_indeterminate")
+            return Effect.succeed({
+                status: "indeterminate",
+                reason: "browser_disconnected_after_dispatch",
+            });
+        return recoverUnavailable(error);
+    }));
+}
+function discoveryResult(result) {
+    if ("status" in result)
+        return result;
+    if (result.type !== "discover")
+        throw new UiHostError("invalid_browser_wire", "Browser returned an execution result for discovery");
+    return { status: "available", commands: [...result.commands] };
+}
+function executionResult(result) {
+    if ("status" in result)
+        return result;
+    if (result.type !== "execute")
+        throw new UiHostError("invalid_browser_wire", "Browser returned a discovery result for execution");
+    return result.outcome;
+}
+function eventResponse(runtime) {
+    const body = Stream.unwrap(runtime.connect().pipe(Effect.map((connection) => Stream.make(": connected\n\n").pipe(Stream.concat(Stream.fromEffectRepeat(connection.take).pipe(Stream.map((envelope) => `event: browser-request\ndata: ${JSON.stringify({
+        ...envelope,
+        connectionId: connection.id,
+    })}\n\n`))))))).pipe(Stream.encodeText, (stream) => Stream.toReadableStream(stream, {
+        strategy: { highWaterMark: 1 },
+    }));
+    return new Response(body, {
+        headers: {
+            "Cache-Control": "no-cache",
+            "Content-Encoding": "Identity",
+            "Content-Type": "text/event-stream",
+        },
+    });
+}
+function errorResponse(cause) {
+    if (!(cause instanceof UiHostError))
+        return Response.json({ error: "Live App commands are unavailable" }, { status: 503 });
+    const status = cause.code === "invalid_browser_wire" ? 400 : 503;
+    return Response.json({ error: cause.message }, { status });
+}
+async function browserIngressResponse(request, invalidMessage, ingress) {
+    const parsed = Effect.tryPromise({
+        try: () => request.json(),
+        catch: () => new UiHostError("invalid_browser_wire", invalidMessage),
+    }).pipe(Effect.flatMap((input) => Effect.try(() => BrowserWireObjectSchema.parse(input))), Effect.flatMap(ingress));
+    try {
+        return Response.json(await runPromiseAtBoundary(parsed, request.signal));
+    }
+    catch (error) {
+        return errorResponse(error);
+    }
+}
+/** Build one Session browser host: its Mycelium `ui` module and HTTP transport. */
+export function createUiHost(runtime = Effect.runSync(makeEffect())) {
+    const module = Mycelium.module({
+        id: "knapsack-ui",
+        name: "ui",
+        description: "Live semantic commands from the connected browser",
+        operations: {
+            discover: Mycelium.operation({
+                replay: "safe",
+                description: "Discover commands in the connected browser",
+                input: z.object({}),
+                output: browserCommandDiscoverySchema,
+                execute: (_input, context) => runPromiseAtBoundary(discoveryRequest(runtime, { type: "discover" }).pipe(Effect.map(discoveryResult)), context.signal),
+            }),
+            execute: Mycelium.operation({
+                replay: "unsafe",
+                description: "Execute one discovered command in the connected browser",
+                input: BrowserExecuteInputSchema,
+                output: browserCommandExecutionSchema,
+                execute: (input, context) => runPromiseAtBoundary(executionRequest(runtime, { type: "execute", ...input }).pipe(Effect.map(executionResult)), context.signal),
+            }),
+        },
+    });
+    const fetch = async (request) => {
+        const url = new URL(request.url);
+        if (request.method === "GET" && url.pathname === "/browser/events")
+            return eventResponse(runtime);
+        if (request.method === "POST" && url.pathname === "/browser/claims")
+            return browserIngressResponse(request, "Browser claim is invalid", runtime.claim);
+        if (request.method === "POST" && url.pathname === "/browser/results")
+            return browserIngressResponse(request, "Browser result is invalid", runtime.acceptResult);
+        return Response.json({ error: "Not found" }, { status: 404 });
+    };
+    return Object.freeze({ modules: [module], fetch });
+}

package/dist/ui/sessions.d.ts

@@ -0,0 +1,32 @@
+import type { ModuleRegistration } from "@fungi.computer/mycelium";
+/** The maintained browser transport and its Session-bound tool descriptors. */
+export type BrowserHost = Readonly<{
+    /** Mycelium tools bound to this host's Session and call-time gates. */
+    modules: readonly ModuleRegistration[];
+    /** Forward one browser events, claims or results request to the maintained host. */
+    fetch: (request: Request) => Promise<Response>;
+}>;
+/** One run's borrow of its Session's browser tools; release ends the borrow. */
+export type BrowserLease = Readonly<{
+    modules: BrowserHost["modules"];
+    release: () => void;
+}>;
+/** One ephemeral browser host per Session, borrowed by run and SSE scopes. */
+export declare class BrowserSessions {
+    private readonly open;
+    private readonly hasSession;
+    private generation;
+    private closed;
+    private readonly hosts;
+    constructor(open: (sessionId: string) => BrowserHost, hasSession: (sessionId: string) => Promise<boolean>);
+    /** End every browser stream and refuse later requests and run leases. */
+    close(): Promise<void>;
+    fetch(request: Request): Promise<Response>;
+    /** Own the async transport opening until its stream joins the connection scope. */
+    private openEvents;
+    private createHost;
+    acquire(sessionId: string): BrowserLease;
+    private releaseBrowserConnection;
+    private releaseIdleHost;
+    private trackBrowserConnection;
+}

package/dist/ui/sessions.js

@@ -0,0 +1,172 @@
+/** One ephemeral browser host per Session, borrowed by run and SSE scopes. */
+export class BrowserSessions {
+    open;
+    hasSession;
+    generation = 0;
+    closed = false;
+    hosts = new Map();
+    constructor(open, hasSession) {
+        this.open = open;
+        this.hasSession = hasSession;
+    }
+    /** End every browser stream and refuse later requests and run leases. */
+    async close() {
+        this.closed = true;
+        // A pending opening or Session lookup from before close never escapes.
+        this.generation += 1;
+        const old = [...this.hosts.values()];
+        this.hosts.clear();
+        await Promise.all(old.flatMap((entry) => [...entry.connections].map((close) => close())));
+    }
+    async fetch(request) {
+        if (this.closed)
+            return new Response(null, { status: 410 });
+        const generation = this.generation;
+        const path = new URL(request.url).pathname;
+        const browserRoute = /^\/browser\/sessions\/([^/]+)\/browser\/(events|claims|results)$/u.exec(path);
+        if (browserRoute === null)
+            return new Response("Not found", { status: 404 });
+        let sessionId;
+        try {
+            sessionId = decodeURIComponent(browserRoute[1] ?? "");
+        }
+        catch {
+            return new Response("Not found", { status: 404 });
+        }
+        const route = browserRoute[2];
+        if (!sessionId || !route)
+            return new Response("Not found", { status: 404 });
+        let entry = this.hosts.get(sessionId);
+        if (entry === undefined) {
+            if (route !== "events")
+                return new Response("Not found", { status: 404 });
+            if (!(await this.hasSession(sessionId)))
+                return new Response("Not found", { status: 404 });
+            if (generation !== this.generation)
+                return new Response(null, { status: 404 });
+            entry = this.hosts.get(sessionId) ?? this.createHost(sessionId);
+        }
+        const target = new URL(request.url);
+        target.pathname = `/browser/${route}`;
+        if (route !== "events")
+            return entry.host.fetch(new Request(target, request));
+        return this.openEvents(new Request(target, request), sessionId, entry, generation);
+    }
+    /** Own the async transport opening until its stream joins the connection scope. */
+    async openEvents(request, sessionId, entry, generation) {
+        entry.browserConnections += 1;
+        try {
+            const response = await entry.host.fetch(request);
+            if (generation !== this.generation) {
+                // The maintained transport may finish opening after teardown. Its
+                // late scope belongs to the old generation and must never escape.
+                await response.body?.cancel();
+                this.releaseBrowserConnection(sessionId, entry);
+                return new Response(null, { status: 404 });
+            }
+            if (!response.ok || response.body === null) {
+                this.releaseBrowserConnection(sessionId, entry);
+                return response;
+            }
+            return this.trackBrowserConnection(response, sessionId, entry);
+        }
+        catch (error) {
+            this.releaseBrowserConnection(sessionId, entry);
+            throw error;
+        }
+    }
+    createHost(sessionId) {
+        const entry = {
+            host: this.open(sessionId),
+            activeRuns: 0,
+            browserConnections: 0,
+            connections: new Set(),
+        };
+        this.hosts.set(sessionId, entry);
+        return entry;
+    }
+    acquire(sessionId) {
+        if (this.closed)
+            throw new Error("Browser host is closed");
+        const entry = this.hosts.get(sessionId) ?? this.createHost(sessionId);
+        entry.activeRuns += 1;
+        let released = false;
+        return {
+            modules: entry.host.modules,
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                entry.activeRuns -= 1;
+                this.releaseIdleHost(sessionId, entry);
+            },
+        };
+    }
+    releaseBrowserConnection(sessionId, entry) {
+        entry.browserConnections -= 1;
+        this.releaseIdleHost(sessionId, entry);
+    }
+    releaseIdleHost(sessionId, entry) {
+        if (entry.activeRuns === 0 &&
+            entry.browserConnections === 0 &&
+            this.hosts.get(sessionId) === entry)
+            this.hosts.delete(sessionId);
+    }
+    trackBrowserConnection(response, sessionId, entry) {
+        const reader = response.body?.getReader();
+        if (reader === undefined) {
+            this.releaseBrowserConnection(sessionId, entry);
+            return response;
+        }
+        let released = false;
+        let controller;
+        const close = async () => {
+            if (released)
+                return;
+            release();
+            controller.close();
+            await reader.cancel();
+        };
+        const release = () => {
+            if (released)
+                return;
+            released = true;
+            entry.connections.delete(close);
+            this.releaseBrowserConnection(sessionId, entry);
+        };
+        entry.connections.add(close);
+        const body = new ReadableStream({
+            start: (streamController) => {
+                controller = streamController;
+            },
+            pull: async (controller) => {
+                try {
+                    const next = await reader.read();
+                    if (released)
+                        return;
+                    if (next.done) {
+                        controller.close();
+                        release();
+                    }
+                    else
+                        controller.enqueue(next.value);
+                }
+                catch (error) {
+                    if (released)
+                        return;
+                    controller.error(error);
+                    release();
+                }
+            },
+            cancel: async (reason) => {
+                release();
+                await reader.cancel(reason);
+            },
+        });
+        return new Response(body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+        });
+    }
+}