@fungi.computer/knapsack 0.0.2 → 0.2.0

package/dist/index.js

@@ -4,26 +4,27 @@ import * as Result from "effect/Result";
 import { z } from "zod";
 import { files } from "./files.js";
 import { mcpServers } from "./mcp.js";
+import { ui } from "./ui.js";
 const maximumCapabilities = 256;
 const describeConcurrency = 8;
 const defaultDescribeTimeoutMillis = 10_000;
 const utf8 = new TextEncoder();
 const jsonValueSchema = z.json();
-const jsonSchemaDocument = z.custom((value) => jsonValueSchema.safeParse(value).success);
-const capabilityNameSchema = z
+const jsonSchemaDocument = z.lazy(() => z.custom((value) => jsonValueSchema.safeParse(value).success));
+const capabilityNameSchema = z.lazy(() => z
     .string()
     .min(1)
     .max(128)
-    .regex(/^[A-Za-z][A-Za-z0-9_]*$/);
-const capabilitySchema = z.strictObject({
+    .regex(/^[A-Za-z][A-Za-z0-9_]*$/));
+const capabilitySchema = z.lazy(() => z.strictObject({
     id: capabilityNameSchema,
     name: capabilityNameSchema,
     kind: z.string().min(1).max(128),
     description: z.string().min(1).max(2_048),
     parameters: jsonSchemaDocument,
     output: jsonSchemaDocument.optional(),
-});
-const capabilitiesSchema = z.array(capabilitySchema).max(maximumCapabilities);
+}));
+const capabilitiesSchema = z.lazy(() => z.array(capabilitySchema).max(maximumCapabilities));
 function operationSchema(document) {
     return z.fromJSONSchema(document).pipe(jsonValueSchema);
 }
@@ -173,6 +174,8 @@ export const Knapsack = Object.freeze({
     files,
     /** Connect a changing list of remote MCP servers, reporting unavailable ones independently. */
     mcpServers,
+    /** Connect the open App's live Whistle commands to each Agent Session. */
+    ui,
 });
 export { McpServerUnavailableError, } from "./mcp.js";
-export { FilesEditError, filesEditFailureSchema, edit, readInputSchema, readOutputSchema, listInputSchema, listOutputSchema, globInputSchema, globOutputSchema, grepInputSchema, grepOutputSchema, editInputSchema, editOutputSchema, patchInputSchema, patchOutputSchema, } from "./files.js";
+export { FilesEditError, filesEditFailureSchema, edit, readInputSchema, readOutputSchema, listInputSchema, globInputSchema, grepInputSchema, searchOutputSchema, readGuestOutputSchema, presentReadForGuest, editInputSchema, editOutputSchema, patchInputSchema, patchOutputSchema, } from "./files.js";

package/dist/ui/browser.d.ts

@@ -0,0 +1,44 @@
+import type { WhistleRuntime } from "@fungi.computer/whistle";
+import * as Effect from "effect/Effect";
+import * as Scope from "effect/Scope";
+import { type BrowserRequestEnvelope, type BrowserResultEnvelope } from "./wire.js";
+/** Browser-side platform failure before a correlated result is accepted. */
+export declare class UiBrowserError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+/** One Agent Session's browser transport and the App's command runtime. */
+export type BrowserConnectionOptions = Readonly<{
+    /** Session route that serves `/browser/{events,claims,results}`. */
+    baseUrl: string;
+    /** The App shell's Whistle runtime; its agent projection is what the Agent sees. */
+    whistle: Pick<WhistleRuntime, "snapshot" | "execute">;
+    /** Host-authorized I/O; omitted for ordinary browser Fetch and EventSource. */
+    transport?: Readonly<{
+        /** Send claims and results with the host's existing admission. */
+        fetch: typeof globalThis.fetch;
+        /** Open the event stream with that same admission and a maintained SSE client. */
+        openEvents: (url: string) => EventTarget & {
+            /** Stop this connection's event stream when its owning scope closes. */
+            close(): void;
+        };
+    }>;
+}>;
+/** A live browser connection; close it when the selected Session changes. */
+export type BrowserConnection = Readonly<{
+    /** Settles when the connection ends; rejects with {@link UiBrowserError} on failure. */
+    closed: Promise<void>;
+    /** Stop serving the Agent's requests. */
+    close: () => void;
+}>;
+/**
+ * Execute one claimed browser request through Whistle's single door.
+ *
+ * Claim is the dispatch point: the browser request carries no cancellation, so
+ * Whistle supplies its own never-aborted signal, and cancellation after this
+ * function starts cannot promise to undo a side effect.
+ */
+export declare function handleBrowserRequest(options: BrowserConnectionOptions, envelope: BrowserRequestEnvelope): Effect.Effect<Omit<BrowserResultEnvelope, "claimId">, UiBrowserError>;
+/** Run one scope-owned EventSource connection and its Whistle request loop. */
+export declare function runBrowserConnection(options: BrowserConnectionOptions): Effect.Effect<void, UiBrowserError, Scope.Scope>;
+/** Start the named browser Promise facade over the Effect connection program. */
+export declare function connectBrowser(options: BrowserConnectionOptions): BrowserConnection;

package/dist/ui/browser.js

@@ -0,0 +1,171 @@
+import * as Effect from "effect/Effect";
+import * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+import * as z from "zod";
+import { BrowserClaimResultSchema, BrowserCommandRowSchema, BrowserRequestDeliverySchema, BrowserSettlementResultSchema, } from "./wire.js";
+import { uiWireIds, BrowserExecutionOutcomeSchema } from "./wire.js";
+/** Browser-side platform failure before a correlated result is accepted. */
+export class UiBrowserError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "UiBrowserError";
+    }
+}
+const decodeRequestEvent = (input) => Effect.try(() => BrowserRequestDeliverySchema.parse(JSON.parse(z.string().parse(input))));
+const decodeClaimResult = (input) => Effect.try(() => BrowserClaimResultSchema.parse(input));
+const decodeSettlementResult = (input) => Effect.try(() => BrowserSettlementResultSchema.parse(input));
+function requestEventData(event) {
+    return event instanceof MessageEvent
+        ? Effect.try(() => z.string().parse(event.data)).pipe(Effect.mapError(() => new UiBrowserError("Browser request event is invalid")))
+        : Effect.fail(new UiBrowserError("Browser request event is invalid"));
+}
+function projectCommands(whistle) {
+    return Effect.sync(() => BrowserCommandRowSchema.array().parse(whistle.snapshot().agent.map((row) => {
+        const sourceAction = row.action;
+        // Focus scope belongs to the local command graph, not the browser wire.
+        const projected = {
+            commandId: row.commandId,
+            sourceId: row.sourceId,
+            title: row.title,
+            category: row.category,
+            description: row.description ?? null,
+            order: row.order,
+            keybind: row.keybind ?? null,
+            availability: row.availability,
+        };
+        if (sourceAction === undefined)
+            return projected;
+        const action = {};
+        if (sourceAction.inputSchema !== undefined)
+            action.inputSchema = sourceAction.inputSchema;
+        if (sourceAction.outputSchema !== undefined)
+            action.outputSchema = sourceAction.outputSchema;
+        if (action.inputSchema === undefined &&
+            action.outputSchema === undefined)
+            return projected;
+        return { ...projected, action };
+    })));
+}
+function projectOutcome(outcome) {
+    const parsed = BrowserExecutionOutcomeSchema.safeParse(outcome);
+    return {
+        type: "execute",
+        outcome: parsed.success
+            ? parsed.data
+            : {
+                status: "failed",
+                error: {
+                    code: "invalid_command_result",
+                    message: "Command result is not valid JSON data",
+                },
+            },
+    };
+}
+/**
+ * Execute one claimed browser request through Whistle's single door.
+ *
+ * Claim is the dispatch point: the browser request carries no cancellation, so
+ * Whistle supplies its own never-aborted signal, and cancellation after this
+ * function starts cannot promise to undo a side effect.
+ */
+export function handleBrowserRequest(options, envelope) {
+    if (envelope.request.type === "discover")
+        return projectCommands(options.whistle).pipe(Effect.map((commands) => ({
+            requestId: envelope.requestId,
+            result: { type: "discover", commands },
+        })));
+    const commandId = envelope.request.commandId;
+    const argumentsValue = "arguments" in envelope.request ? envelope.request.arguments : undefined;
+    return Effect.tryPromise({
+        try: () => options.whistle.execute(commandId, argumentsValue === undefined
+            ? { origin: "agent" }
+            : { origin: "agent", arguments: argumentsValue }),
+        catch: () => new UiBrowserError("Whistle execution rejected"),
+    }).pipe(Effect.map((outcome) => ({
+        requestId: envelope.requestId,
+        result: projectOutcome(outcome),
+    })));
+}
+function claimRequest(options, delivery) {
+    const attemptId = uiWireIds.attempt.generate();
+    const claimOnce = () => Effect.tryPromise({
+        try: (signal) => (options.transport?.fetch ?? globalThis.fetch)(`${options.baseUrl}/browser/claims`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                attemptId,
+                connectionId: delivery.connectionId,
+                requestId: delivery.requestId,
+            }),
+            signal,
+        }),
+        catch: () => new UiBrowserError("Browser claim request failed"),
+    }).pipe(Effect.flatMap((response) => response.ok
+        ? Effect.tryPromise({
+            try: () => response.json(),
+            catch: () => new UiBrowserError("Browser claim response is invalid"),
+        })
+        : Effect.fail(new UiBrowserError(`Browser claim was rejected with status ${String(response.status)}`))), Effect.flatMap((input) => Effect.try(() => z.record(z.string(), z.unknown()).parse(input)).pipe(Effect.flatMap(decodeClaimResult))), Effect.mapError(() => new UiBrowserError("Browser claim response is invalid")));
+    const waitForClaim = () => claimOnce().pipe(Effect.flatMap((claim) => claim.status === "waiting"
+        ? Effect.sleep(claim.retryAfterMs).pipe(Effect.andThen(Effect.suspend(waitForClaim)))
+        : Effect.succeed(claim)));
+    return Effect.suspend(waitForClaim);
+}
+function postResult(options, result) {
+    return Effect.tryPromise({
+        try: (signal) => (options.transport?.fetch ?? globalThis.fetch)(`${options.baseUrl}/browser/results`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(result),
+            signal,
+        }),
+        catch: () => new UiBrowserError("Browser result request failed"),
+    }).pipe(Effect.flatMap((response) => response.ok
+        ? Effect.tryPromise({
+            try: () => response.json(),
+            catch: () => new UiBrowserError("Browser settlement response is invalid"),
+        }).pipe(Effect.flatMap((input) => Effect.try(() => z.record(z.string(), z.unknown()).parse(input)).pipe(Effect.flatMap(decodeSettlementResult))), Effect.mapError(() => new UiBrowserError("Browser settlement response is invalid")), Effect.asVoid)
+        : Effect.fail(new UiBrowserError(`Browser result was rejected with status ${String(response.status)}`))));
+}
+function handleRequestEvent(options, event) {
+    return requestEventData(event).pipe(Effect.flatMap(decodeRequestEvent), Effect.mapError(() => new UiBrowserError("Browser request payload is invalid")), Effect.flatMap((delivery) => claimRequest(options, delivery).pipe(Effect.flatMap((claim) => claim.status !== "claimed"
+        ? Effect.void
+        : handleBrowserRequest(options, delivery).pipe(Effect.flatMap((result) => postResult(options, {
+            ...result,
+            claimId: claim.claimId,
+        })))))));
+}
+/** Run one scope-owned EventSource connection and its Whistle request loop. */
+export function runBrowserConnection(options) {
+    return Effect.acquireRelease(Effect.try({
+        try: () => {
+            const url = `${options.baseUrl}/browser/events`;
+            return options.transport === undefined
+                ? new EventSource(url)
+                : options.transport.openEvents(url);
+        },
+        catch: () => new UiBrowserError("Browser event stream could not open"),
+    }), (source) => Effect.sync(() => {
+        source.close();
+    })).pipe(Effect.flatMap((source) => Stream.fromEventListener(source, "browser-request", {
+        bufferSize: 1,
+    }).pipe(Stream.mapEffect((event) => handleRequestEvent(options, event)), Stream.runDrain)));
+}
+/** Start the named browser Promise facade over the Effect connection program. */
+export function connectBrowser(options) {
+    const cancellation = new AbortController();
+    const closed = Effect.runPromise(Effect.scoped(runBrowserConnection(options)), {
+        signal: cancellation.signal,
+    }).catch((cause) => {
+        if (!cancellation.signal.aborted)
+            throw new UiBrowserError("Browser connection failed", {
+                cause,
+            });
+    });
+    return Object.freeze({
+        closed,
+        close: () => {
+            cancellation.abort();
+        },
+    });
+}

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;