@fungi.computer/knapsack 0.0.2 → 0.2.0

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,
+        });
+    }
+}

package/dist/ui/wire.d.ts

@@ -0,0 +1,290 @@
+import * as z from "zod";
+export declare const uiWireIds: Readonly<{
+    readonly request: import("@fungi.computer/cairn").IdCodec<"knapsack-ui", "request", 1>;
+    readonly connection: import("@fungi.computer/cairn").IdCodec<"knapsack-ui", "connection", 1>;
+    readonly claim: import("@fungi.computer/cairn").IdCodec<"knapsack-ui", "claim", 1>;
+    readonly attempt: import("@fungi.computer/cairn").IdCodec<"knapsack-ui", "attempt", 1>;
+}>;
+export declare const BrowserWireObjectSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type BrowserWireObject = z.output<typeof BrowserWireObjectSchema>;
+export declare const BrowserCommandRowSchema: z.ZodUnion<readonly [z.ZodObject<{
+    action: z.ZodUnion<readonly [z.ZodObject<{
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        outputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strict>, z.ZodObject<{
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strict>, z.ZodObject<{
+        outputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strict>]>;
+    commandId: z.ZodString;
+    sourceId: z.ZodString;
+    title: z.ZodString;
+    category: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    order: z.ZodNumber;
+    keybind: z.ZodNullable<z.ZodString>;
+    availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodString;
+    }, z.core.$strip>], "status">;
+}, z.core.$strict>, z.ZodObject<{
+    commandId: z.ZodString;
+    sourceId: z.ZodString;
+    title: z.ZodString;
+    category: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    order: z.ZodNumber;
+    keybind: z.ZodNullable<z.ZodString>;
+    availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodString;
+    }, z.core.$strip>], "status">;
+}, z.core.$strict>]>;
+export declare const BrowserExecuteInputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    commandId: z.ZodString;
+    arguments: z.ZodJSONSchema;
+}, z.core.$strict>, z.ZodObject<{
+    commandId: z.ZodString;
+}, z.core.$strict>]>;
+declare const BrowserRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"discover">;
+}, z.core.$strict>, z.ZodObject<{
+    commandId: z.ZodString;
+    arguments: z.ZodJSONSchema;
+    type: z.ZodLiteral<"execute">;
+}, z.core.$strict>, z.ZodObject<{
+    commandId: z.ZodString;
+    type: z.ZodLiteral<"execute">;
+}, z.core.$strict>]>;
+declare const BrowserRequestEnvelopeSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    request: z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"discover">;
+    }, z.core.$strict>, z.ZodObject<{
+        commandId: z.ZodString;
+        arguments: z.ZodJSONSchema;
+        type: z.ZodLiteral<"execute">;
+    }, z.core.$strict>, z.ZodObject<{
+        commandId: z.ZodString;
+        type: z.ZodLiteral<"execute">;
+    }, z.core.$strict>]>;
+}, z.core.$strip>;
+export declare const BrowserRequestDeliverySchema: z.ZodObject<{
+    requestId: z.ZodString;
+    request: z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"discover">;
+    }, z.core.$strict>, z.ZodObject<{
+        commandId: z.ZodString;
+        arguments: z.ZodJSONSchema;
+        type: z.ZodLiteral<"execute">;
+    }, z.core.$strict>, z.ZodObject<{
+        commandId: z.ZodString;
+        type: z.ZodLiteral<"execute">;
+    }, z.core.$strict>]>;
+    connectionId: z.ZodString;
+}, z.core.$strip>;
+export declare const BrowserClaimSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    connectionId: z.ZodString;
+    attemptId: z.ZodString;
+}, z.core.$strip>;
+export declare const BrowserClaimResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"claimed">;
+    claimId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"waiting">;
+    retryAfterMs: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"skipped">;
+}, z.core.$strip>], "status">;
+export declare const BrowserExecutionOutcomeSchema: z.ZodUnion<readonly [z.ZodObject<{
+    status: z.ZodLiteral<"handled">;
+    result: z.ZodJSONSchema;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"handled">;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"closed">;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"missing">;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"invalid">;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"unavailable">;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"failed">;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodJSONSchema;
+    }, z.core.$strip>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"failed">;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
+declare const BrowserWireResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"discover">;
+    commands: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        action: z.ZodUnion<readonly [z.ZodObject<{
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            outputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>, z.ZodObject<{
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>, z.ZodObject<{
+            outputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>]>;
+        commandId: z.ZodString;
+        sourceId: z.ZodString;
+        title: z.ZodString;
+        category: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        order: z.ZodNumber;
+        keybind: z.ZodNullable<z.ZodString>;
+        availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodString;
+        }, z.core.$strip>], "status">;
+    }, z.core.$strict>, z.ZodObject<{
+        commandId: z.ZodString;
+        sourceId: z.ZodString;
+        title: z.ZodString;
+        category: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        order: z.ZodNumber;
+        keybind: z.ZodNullable<z.ZodString>;
+        availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodString;
+        }, z.core.$strip>], "status">;
+    }, z.core.$strict>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"execute">;
+    outcome: z.ZodUnion<readonly [z.ZodObject<{
+        status: z.ZodLiteral<"handled">;
+        result: z.ZodJSONSchema;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"handled">;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"closed">;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"missing">;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"invalid">;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"failed">;
+        error: z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            details: z.ZodJSONSchema;
+        }, z.core.$strip>;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"failed">;
+        error: z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>]>;
+}, z.core.$strip>], "type">;
+export declare const BrowserResultEnvelopeSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    claimId: z.ZodString;
+    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"discover">;
+        commands: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            action: z.ZodUnion<readonly [z.ZodObject<{
+                inputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+                outputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strict>, z.ZodObject<{
+                inputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strict>, z.ZodObject<{
+                outputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strict>]>;
+            commandId: z.ZodString;
+            sourceId: z.ZodString;
+            title: z.ZodString;
+            category: z.ZodString;
+            description: z.ZodNullable<z.ZodString>;
+            order: z.ZodNumber;
+            keybind: z.ZodNullable<z.ZodString>;
+            availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<"unavailable">;
+                reason: z.ZodString;
+            }, z.core.$strip>], "status">;
+        }, z.core.$strict>, z.ZodObject<{
+            commandId: z.ZodString;
+            sourceId: z.ZodString;
+            title: z.ZodString;
+            category: z.ZodString;
+            description: z.ZodNullable<z.ZodString>;
+            order: z.ZodNumber;
+            keybind: z.ZodNullable<z.ZodString>;
+            availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<"unavailable">;
+                reason: z.ZodString;
+            }, z.core.$strip>], "status">;
+        }, z.core.$strict>]>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"execute">;
+        outcome: z.ZodUnion<readonly [z.ZodObject<{
+            status: z.ZodLiteral<"handled">;
+            result: z.ZodJSONSchema;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"handled">;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"closed">;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"missing">;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"invalid">;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"failed">;
+            error: z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                details: z.ZodJSONSchema;
+            }, z.core.$strip>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"failed">;
+            error: z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>;
+export declare const BrowserSettlementResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"accepted">;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"ignored">;
+}, z.core.$strip>], "status">;
+export type BrowserCommandRow = z.output<typeof BrowserCommandRowSchema>;
+export type BrowserRequest = z.output<typeof BrowserRequestSchema>;
+export type BrowserRequestEnvelope = z.output<typeof BrowserRequestEnvelopeSchema>;
+export type BrowserRequestDelivery = z.output<typeof BrowserRequestDeliverySchema>;
+export type BrowserClaim = z.output<typeof BrowserClaimSchema>;
+export type BrowserClaimResult = z.output<typeof BrowserClaimResultSchema>;
+export type BrowserWireResult = z.output<typeof BrowserWireResultSchema>;
+export type BrowserResultEnvelope = z.output<typeof BrowserResultEnvelopeSchema>;
+export type BrowserSettlementResult = z.output<typeof BrowserSettlementResultSchema>;
+export {};