@useragent-kit/sdk 0.0.0 → 0.0.1

package/dist/host-runtime-frame.js

@@ -0,0 +1,881 @@
+import { HostRuntime } from "./host-runtime.js";
+import { defaultHostRuntimeRegistry, } from "./host-runtime-registry.js";
+import { installScopedFrame, mountScopedFrame, } from "./scoped-frame.js";
+import { isHostRuntimePortMethodName, } from "./host-runtime-contract.js";
+const HOST_RUNTIME_FRAME_INIT = "host-runtime-frame:init";
+const HOST_RUNTIME_FRAME_READY = "host-runtime-frame:ready";
+const HOST_RUNTIME_FRAME_SOURCE = "host-sdk-frame";
+const HOST_RUNTIME_FRAME_SERVICE_IDS = ["runtime"];
+function startPort(port) {
+    port.start?.();
+}
+function closePort(port) {
+    port.close?.();
+}
+function toErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+class PortRemoteHostRuntime {
+    constructor(port, hasChainService = false) {
+        this.port = port;
+        this.nextId = 1;
+        this.pending = new Map();
+        this.sessions = new Map();
+        this.chainSubscriptions = new Map();
+        this.pendingChainEvents = new Map();
+        this.destroyed = false;
+        this.chainService = hasChainService ? new PortRemoteRuntimeChainService(this) : null;
+        startPort(port);
+        port.onmessage = (event) => {
+            const message = event.data;
+            if (typeof message !== "object" || message == null) {
+                return;
+            }
+            if ("id" in message) {
+                const pending = this.pending.get(message.id);
+                if (pending == null) {
+                    return;
+                }
+                this.pending.delete(message.id);
+                if (message.ok) {
+                    pending.resolve(message.result);
+                }
+                else {
+                    pending.reject(new Error(message.error));
+                }
+                return;
+            }
+            if (message.type === "chain.subscriptionMessage") {
+                const callbacks = this.chainSubscriptions.get(message.subscriptionId);
+                if (callbacks != null) {
+                    callbacks.onMessage(message.jsonRpcMessage);
+                }
+                else {
+                    const pending = this.pendingChainEvents.get(message.subscriptionId) ?? [];
+                    pending.push(message);
+                    this.pendingChainEvents.set(message.subscriptionId, pending);
+                }
+            }
+            else if (message.type === "chain.subscriptionAbort") {
+                const callbacks = this.chainSubscriptions.get(message.subscriptionId);
+                if (callbacks) {
+                    callbacks.onAbort(message.reason);
+                    this.chainSubscriptions.delete(message.subscriptionId);
+                }
+                else {
+                    const pending = this.pendingChainEvents.get(message.subscriptionId) ?? [];
+                    pending.push(message);
+                    this.pendingChainEvents.set(message.subscriptionId, pending);
+                }
+            }
+        };
+    }
+    async setAccounts(accounts) {
+        await this.call({ method: "setAccounts", accounts });
+    }
+    async clearAccounts() {
+        await this.call({ method: "clearAccounts" });
+    }
+    async setSupportedChains(chains) {
+        await this.call({ method: "setSupportedChains", chains });
+    }
+    session(productId) {
+        let session = this.sessions.get(productId);
+        if (session == null) {
+            session = new PortRemoteHostRuntimeSession(this, productId);
+            this.sessions.set(productId, session);
+        }
+        return session;
+    }
+    async destroySession(productId) {
+        this.sessions.delete(productId);
+        await this.call({ method: "destroySession", productId });
+    }
+    async reset() {
+        this.sessions.clear();
+        await this.call({ method: "resetRuntime" });
+    }
+    destroy() {
+        if (this.destroyed) {
+            return;
+        }
+        this.destroyed = true;
+        for (const pending of this.pending.values()) {
+            pending.reject(new Error("Host runtime port closed"));
+        }
+        this.pending.clear();
+        this.sessions.clear();
+        for (const [subscriptionId, callbacks] of this.chainSubscriptions) {
+            callbacks.onAbort("Host runtime port closed");
+            this.chainSubscriptions.delete(subscriptionId);
+        }
+        this.port.onmessage = null;
+        closePort(this.port);
+    }
+    call(request) {
+        if (this.destroyed) {
+            return Promise.reject(new Error("Host runtime port closed"));
+        }
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.port.postMessage({ id, ...request });
+        });
+    }
+    setChainSubscription(subscriptionId, callbacks) {
+        this.chainSubscriptions.set(subscriptionId, callbacks);
+        const pending = this.pendingChainEvents.get(subscriptionId);
+        if (pending == null) {
+            return;
+        }
+        this.pendingChainEvents.delete(subscriptionId);
+        for (const event of pending) {
+            if (event.type === "chain.subscriptionMessage") {
+                callbacks.onMessage(event.jsonRpcMessage);
+            }
+            else {
+                callbacks.onAbort(event.reason);
+                this.chainSubscriptions.delete(subscriptionId);
+                break;
+            }
+        }
+    }
+    clearChainSubscription(subscriptionId) {
+        this.chainSubscriptions.delete(subscriptionId);
+        this.pendingChainEvents.delete(subscriptionId);
+    }
+}
+class PortRemoteRuntimeChainService {
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    async statuses() {
+        return this.runtime.call({ method: "chain.statuses" });
+    }
+    async connect(chainName) {
+        await this.runtime.call({ method: "chain.connect", chainName });
+    }
+    async disconnect(chainName) {
+        await this.runtime.call({ method: "chain.disconnect", chainName });
+    }
+    async refreshRouting(chainNames) {
+        const entries = (await this.runtime.call({
+            method: "chain.refreshRouting",
+            chainNames,
+        }));
+        return new Map(entries);
+    }
+    async routingTable() {
+        const entries = (await this.runtime.call({ method: "chain.routingTable" }));
+        return new Map(entries);
+    }
+    async supportedGenesisHashes() {
+        return this.runtime.call({ method: "chain.supportedGenesisHashes" });
+    }
+    async routeChainByGenesisHash(genesisHash) {
+        return this.runtime.call({
+            method: "chain.routeChainByGenesisHash",
+            genesisHash,
+        });
+    }
+    async sendRpc(chainName, method, paramsJson) {
+        return this.runtime.call({
+            method: "chain.sendRpc",
+            chainName,
+            jsonRpcMethod: method,
+            paramsJson,
+        });
+    }
+    async startSubscription(chainName, method, paramsJson, onMessage, onAbort) {
+        const { subscriptionId } = (await this.runtime.call({
+            method: "chain.startSubscription",
+            chainName,
+            jsonRpcMethod: method,
+            paramsJson,
+        }));
+        this.runtime.setChainSubscription(subscriptionId, { onMessage, onAbort });
+        return async () => {
+            this.runtime.clearChainSubscription(subscriptionId);
+            await this.runtime.call({ method: "chain.stopSubscription", subscriptionId });
+        };
+    }
+    async destroy() {
+        await this.runtime.call({ method: "chain.stopAllSubscriptions" });
+    }
+}
+class PortRemoteHostRuntimeSession {
+    constructor(runtime, productId) {
+        this.runtime = runtime;
+        this.productId = productId;
+    }
+    async handleMessage(raw) {
+        return this.runtime.call({
+            method: "session.handleMessage",
+            productId: this.productId,
+            raw,
+        });
+    }
+    async reset() {
+        await this.runtime.call({ method: "session.reset", productId: this.productId });
+    }
+    async forgetRequest(requestId) {
+        await this.runtime.call({
+            method: "session.forgetRequest",
+            productId: this.productId,
+            requestId,
+        });
+    }
+    async isFollowRequest(requestId) {
+        return this.runtime.call({
+            method: "session.isFollowRequest",
+            productId: this.productId,
+            requestId,
+        });
+    }
+    async encodeSignResponse(requestId, requestTag, signature) {
+        return this.runtime.call({
+            method: "session.encodeSignResponse",
+            productId: this.productId,
+            requestId,
+            requestTag,
+            signature,
+        });
+    }
+    async encodeSignError(requestId, requestTag) {
+        return this.runtime.call({
+            method: "session.encodeSignError",
+            productId: this.productId,
+            requestId,
+            requestTag,
+        });
+    }
+    async encodeAccountGetResponse(requestId, publicKey, name) {
+        return this.runtime.call({
+            method: "session.encodeAccountGetResponse",
+            productId: this.productId,
+            requestId,
+            publicKey,
+            name,
+        });
+    }
+    async encodeAccountGetError(requestId, errorKind, reason) {
+        return this.runtime.call({
+            method: "session.encodeAccountGetError",
+            productId: this.productId,
+            requestId,
+            errorKind,
+            reason,
+        });
+    }
+    async encodeAccountGetAliasResponse(requestId, context, alias) {
+        return this.runtime.call({
+            method: "session.encodeAccountGetAliasResponse",
+            productId: this.productId,
+            requestId,
+            context,
+            alias,
+        });
+    }
+    async encodeAccountGetAliasError(requestId, errorKind, reason) {
+        return this.runtime.call({
+            method: "session.encodeAccountGetAliasError",
+            productId: this.productId,
+            requestId,
+            errorKind,
+            reason,
+        });
+    }
+    async encodeAccountCreateProofResponse(requestId, proof) {
+        return this.runtime.call({
+            method: "session.encodeAccountCreateProofResponse",
+            productId: this.productId,
+            requestId,
+            proof,
+        });
+    }
+    async encodeAccountCreateProofError(requestId, errorKind, reason) {
+        return this.runtime.call({
+            method: "session.encodeAccountCreateProofError",
+            productId: this.productId,
+            requestId,
+            errorKind,
+            reason,
+        });
+    }
+    async encodeDevicePermissionResponse(requestId, granted) {
+        return this.runtime.call({
+            method: "session.encodeDevicePermissionResponse",
+            productId: this.productId,
+            requestId,
+            granted,
+        });
+    }
+    async encodeDevicePermissionError(requestId) {
+        return this.runtime.call({
+            method: "session.encodeDevicePermissionError",
+            productId: this.productId,
+            requestId,
+        });
+    }
+    async encodeRemotePermissionResponse(requestId, granted) {
+        return this.runtime.call({
+            method: "session.encodeRemotePermissionResponse",
+            productId: this.productId,
+            requestId,
+            granted,
+        });
+    }
+    async encodeRemotePermissionError(requestId) {
+        return this.runtime.call({
+            method: "session.encodeRemotePermissionError",
+            productId: this.productId,
+            requestId,
+        });
+    }
+    async encodeCreateTransactionResponse(requestId, signedTxBytes) {
+        return this.runtime.call({
+            method: "session.encodeCreateTransactionResponse",
+            productId: this.productId,
+            requestId,
+            signedTxBytes,
+        });
+    }
+    async encodeCreateTransactionError(requestId) {
+        return this.runtime.call({
+            method: "session.encodeCreateTransactionError",
+            productId: this.productId,
+            requestId,
+        });
+    }
+    async encodeCreateTxNonProductResponse(requestId, signedTxBytes) {
+        return this.runtime.call({
+            method: "session.encodeCreateTxNonProductResponse",
+            productId: this.productId,
+            requestId,
+            signedTxBytes,
+        });
+    }
+    async encodeCreateTxNonProductError(requestId) {
+        return this.runtime.call({
+            method: "session.encodeCreateTxNonProductError",
+            productId: this.productId,
+            requestId,
+        });
+    }
+    async encodePaymentBalance(requestId, balance) {
+        return this.runtime.call({
+            method: "session.encodePaymentBalance",
+            productId: this.productId,
+            requestId,
+            balance,
+        });
+    }
+    async encodePaymentBalanceInterrupt(requestId) {
+        return this.runtime.call({
+            method: "session.encodePaymentBalanceInterrupt",
+            productId: this.productId,
+            requestId,
+        });
+    }
+    async encodePaymentTopUpResponse(requestId) {
+        return this.runtime.call({
+            method: "session.encodePaymentTopUpResponse",
+            productId: this.productId,
+            requestId,
+        });
+    }
+    async encodePaymentTopUpError(requestId, reason) {
+        return this.runtime.call({
+            method: "session.encodePaymentTopUpError",
+            productId: this.productId,
+            requestId,
+            reason,
+        });
+    }
+    async encodePaymentRequestResponse(requestId, receiptId) {
+        return this.runtime.call({
+            method: "session.encodePaymentRequestResponse",
+            productId: this.productId,
+            requestId,
+            receiptId,
+        });
+    }
+    async encodePaymentRequestError(requestId, reason) {
+        return this.runtime.call({
+            method: "session.encodePaymentRequestError",
+            productId: this.productId,
+            requestId,
+            reason,
+        });
+    }
+    async encodePaymentStatus(requestId, status) {
+        return this.runtime.call({
+            method: "session.encodePaymentStatus",
+            productId: this.productId,
+            requestId,
+            status,
+        });
+    }
+    async encodePaymentStatusInterrupt(requestId) {
+        return this.runtime.call({
+            method: "session.encodePaymentStatusInterrupt",
+            productId: this.productId,
+            requestId,
+        });
+    }
+    async encodeChainQueryResponse(requestId, jsonRpcResult) {
+        return this.runtime.call({
+            method: "session.encodeChainQueryResponse",
+            productId: this.productId,
+            requestId,
+            jsonRpcResult,
+        });
+    }
+    async encodeChainQueryError(requestId) {
+        return this.runtime.call({
+            method: "session.encodeChainQueryError",
+            productId: this.productId,
+            requestId,
+        });
+    }
+    async encodeChainRpcResponse(requestId, requestTag, jsonRpcMessage) {
+        return this.runtime.call({
+            method: "session.encodeChainRpcResponse",
+            productId: this.productId,
+            requestId,
+            requestTag,
+            jsonRpcMessage,
+        });
+    }
+    async encodeChainRpcError(requestId, requestTag, reason) {
+        return this.runtime.call({
+            method: "session.encodeChainRpcError",
+            productId: this.productId,
+            requestId,
+            requestTag,
+            reason,
+        });
+    }
+    async encodeNavigateResponse(requestId) {
+        return this.runtime.call({
+            method: "session.encodeNavigateResponse",
+            productId: this.productId,
+            requestId,
+        });
+    }
+    async encodePushNotificationResponse(requestId) {
+        return this.runtime.call({
+            method: "session.encodePushNotificationResponse",
+            productId: this.productId,
+            requestId,
+        });
+    }
+    async encodeChainFollowStop(requestId) {
+        return this.runtime.call({
+            method: "session.encodeChainFollowStop",
+            productId: this.productId,
+            requestId,
+        });
+    }
+    async encodeChainNotification(requestId, jsonRpcMessage) {
+        return this.runtime.call({
+            method: "session.encodeChainNotification",
+            productId: this.productId,
+            requestId,
+            jsonRpcMessage,
+        });
+    }
+    async encodeStorageReadResponse(requestId, value) {
+        return this.runtime.call({
+            method: "session.encodeStorageReadResponse",
+            productId: this.productId,
+            requestId,
+            value,
+        });
+    }
+    async encodeStorageWriteResponse(requestId) {
+        return this.runtime.call({
+            method: "session.encodeStorageWriteResponse",
+            productId: this.productId,
+            requestId,
+        });
+    }
+    async encodeStorageClearResponse(requestId) {
+        return this.runtime.call({
+            method: "session.encodeStorageClearResponse",
+            productId: this.productId,
+            requestId,
+        });
+    }
+}
+async function dispatchRuntimeRequest(runtime, chainService, request, subscriptionState, port) {
+    switch (request.method) {
+        case "setAccounts":
+            runtime.setAccounts(request.accounts);
+            return undefined;
+        case "clearAccounts":
+            runtime.clearAccounts();
+            return undefined;
+        case "setSupportedChains":
+            runtime.setSupportedChains(request.chains);
+            return undefined;
+        case "destroySession":
+            runtime.destroySession(request.productId);
+            return undefined;
+        case "resetRuntime":
+            runtime.reset();
+            return undefined;
+        case "chain.statuses":
+            return chainService?.statuses() ?? [];
+        case "chain.connect":
+            if (chainService == null)
+                throw new Error("Runtime chain service unavailable");
+            await chainService.connect(request.chainName);
+            return undefined;
+        case "chain.disconnect":
+            if (chainService == null)
+                throw new Error("Runtime chain service unavailable");
+            chainService.disconnect(request.chainName);
+            return undefined;
+        case "chain.refreshRouting":
+            if (chainService == null)
+                throw new Error("Runtime chain service unavailable");
+            return [...(await chainService.refreshRouting(request.chainNames)).entries()];
+        case "chain.routingTable":
+            if (chainService == null)
+                throw new Error("Runtime chain service unavailable");
+            return [...chainService.routingTable().entries()];
+        case "chain.supportedGenesisHashes":
+            if (chainService == null)
+                throw new Error("Runtime chain service unavailable");
+            return chainService.supportedGenesisHashes();
+        case "chain.routeChainByGenesisHash":
+            if (chainService == null)
+                throw new Error("Runtime chain service unavailable");
+            return chainService.routeChainByGenesisHash(request.genesisHash);
+        case "chain.sendRpc":
+            if (chainService == null)
+                throw new Error("Runtime chain service unavailable");
+            return chainService.sendRpc(request.chainName, request.jsonRpcMethod, request.paramsJson);
+        case "chain.startSubscription": {
+            if (chainService == null)
+                throw new Error("Runtime chain service unavailable");
+            const subscriptionId = subscriptionState.allocateChainSubscriptionId();
+            console.info(`[runtime-frame] start subscription ${request.chainName} ${request.jsonRpcMethod} local=${subscriptionId}`);
+            const queuedEvents = [];
+            let responsePosted = false;
+            const sendChainEvent = (message) => {
+                if (responsePosted) {
+                    console.info(`[runtime-frame] forwarding subscription event local=${subscriptionId} type=${message.type}`);
+                    port.postMessage(message);
+                }
+                else {
+                    console.info(`[runtime-frame] queueing subscription event local=${subscriptionId} type=${message.type}`);
+                    queuedEvents.push(message);
+                }
+            };
+            const stop = chainService.startSubscription(request.chainName, request.jsonRpcMethod, request.paramsJson, (jsonRpcMessage) => {
+                sendChainEvent({
+                    type: "chain.subscriptionMessage",
+                    subscriptionId,
+                    jsonRpcMessage,
+                });
+            }, (reason) => {
+                sendChainEvent({
+                    type: "chain.subscriptionAbort",
+                    subscriptionId,
+                    reason,
+                });
+                subscriptionState.stopChainSubscription(subscriptionId);
+            });
+            subscriptionState.stopChainSubscription(subscriptionId);
+            subscriptionState.setChainSubscriptionStop(subscriptionId, stop);
+            return {
+                subscriptionId,
+                __queuedChainEvents: queuedEvents,
+                __markResponsePosted() {
+                    console.info(`[runtime-frame] subscription response posted local=${subscriptionId} queued=${queuedEvents.length}`);
+                    responsePosted = true;
+                },
+            };
+        }
+        case "chain.stopSubscription":
+            subscriptionState.stopChainSubscription(request.subscriptionId);
+            return undefined;
+        case "chain.stopAllSubscriptions":
+            subscriptionState.stopAllChainSubscriptions();
+            return undefined;
+        default:
+            return dispatchSessionRequest(runtime.session(request.productId), request);
+    }
+}
+function dispatchSessionRequest(session, request) {
+    switch (request.method) {
+        case "session.handleMessage":
+            return session.handleMessage(request.raw);
+        case "session.reset":
+            session.reset();
+            return undefined;
+        case "session.forgetRequest":
+            session.forgetRequest(request.requestId);
+            return undefined;
+        case "session.isFollowRequest":
+            return session.isFollowRequest(request.requestId);
+        case "session.encodeSignResponse":
+            return session.encodeSignResponse(request.requestId, request.requestTag, request.signature);
+        case "session.encodeSignError":
+            return session.encodeSignError(request.requestId, request.requestTag);
+        case "session.encodeAccountGetResponse":
+            return session.encodeAccountGetResponse(request.requestId, request.publicKey, request.name);
+        case "session.encodeAccountGetError":
+            return session.encodeAccountGetError(request.requestId, request.errorKind, request.reason);
+        case "session.encodeAccountGetAliasResponse":
+            return session.encodeAccountGetAliasResponse(request.requestId, request.context, request.alias);
+        case "session.encodeAccountGetAliasError":
+            return session.encodeAccountGetAliasError(request.requestId, request.errorKind, request.reason);
+        case "session.encodeAccountCreateProofResponse":
+            return session.encodeAccountCreateProofResponse(request.requestId, request.proof);
+        case "session.encodeAccountCreateProofError":
+            return session.encodeAccountCreateProofError(request.requestId, request.errorKind, request.reason);
+        case "session.encodeDevicePermissionResponse":
+            return session.encodeDevicePermissionResponse(request.requestId, request.granted);
+        case "session.encodeDevicePermissionError":
+            return session.encodeDevicePermissionError(request.requestId);
+        case "session.encodeRemotePermissionResponse":
+            return session.encodeRemotePermissionResponse(request.requestId, request.granted);
+        case "session.encodeRemotePermissionError":
+            return session.encodeRemotePermissionError(request.requestId);
+        case "session.encodeCreateTransactionResponse":
+            return session.encodeCreateTransactionResponse(request.requestId, request.signedTxBytes);
+        case "session.encodeCreateTransactionError":
+            return session.encodeCreateTransactionError(request.requestId);
+        case "session.encodeCreateTxNonProductResponse":
+            return session.encodeCreateTxNonProductResponse(request.requestId, request.signedTxBytes);
+        case "session.encodeCreateTxNonProductError":
+            return session.encodeCreateTxNonProductError(request.requestId);
+        case "session.encodePaymentBalance":
+            return session.encodePaymentBalance(request.requestId, request.balance);
+        case "session.encodePaymentBalanceInterrupt":
+            return session.encodePaymentBalanceInterrupt(request.requestId);
+        case "session.encodePaymentTopUpResponse":
+            return session.encodePaymentTopUpResponse(request.requestId);
+        case "session.encodePaymentTopUpError":
+            return session.encodePaymentTopUpError(request.requestId, request.reason);
+        case "session.encodePaymentRequestResponse":
+            return session.encodePaymentRequestResponse(request.requestId, request.receiptId);
+        case "session.encodePaymentRequestError":
+            return session.encodePaymentRequestError(request.requestId, request.reason);
+        case "session.encodePaymentStatus":
+            return session.encodePaymentStatus(request.requestId, request.status);
+        case "session.encodePaymentStatusInterrupt":
+            return session.encodePaymentStatusInterrupt(request.requestId);
+        case "session.encodeChainQueryResponse":
+            return session.encodeChainQueryResponse(request.requestId, request.jsonRpcResult);
+        case "session.encodeChainQueryError":
+            return session.encodeChainQueryError(request.requestId);
+        case "session.encodeChainRpcResponse":
+            return session.encodeChainRpcResponse(request.requestId, request.requestTag, request.jsonRpcMessage);
+        case "session.encodeChainRpcError":
+            return session.encodeChainRpcError(request.requestId, request.requestTag, request.reason);
+        case "session.encodeNavigateResponse":
+            return session.encodeNavigateResponse(request.requestId);
+        case "session.encodePushNotificationResponse":
+            return session.encodePushNotificationResponse(request.requestId);
+        case "session.encodeChainFollowStop":
+            return session.encodeChainFollowStop(request.requestId);
+        case "session.encodeChainNotification":
+            return session.encodeChainNotification(request.requestId, request.jsonRpcMessage);
+        case "session.encodeStorageReadResponse":
+            return session.encodeStorageReadResponse(request.requestId, request.value);
+        case "session.encodeStorageWriteResponse":
+            return session.encodeStorageWriteResponse(request.requestId);
+        case "session.encodeStorageClearResponse":
+            return session.encodeStorageClearResponse(request.requestId);
+    }
+}
+/**
+ * Serve a HostRuntime over a MessagePort-compatible transport.
+ *
+ * This is the runtime-frame side of the common-origin iframe pattern.
+ */
+export function serveHostRuntimePort(port, runtime, chainService = null) {
+    const subscriptionStops = new Map();
+    let nextChainSubscriptionId = 1;
+    const stopChainSubscription = (subscriptionId) => {
+        const stop = subscriptionStops.get(subscriptionId);
+        if (stop) {
+            subscriptionStops.delete(subscriptionId);
+            stop();
+        }
+    };
+    const stopAllChainSubscriptions = () => {
+        for (const subscriptionId of [...subscriptionStops.keys()]) {
+            stopChainSubscription(subscriptionId);
+        }
+    };
+    startPort(port);
+    port.onmessage = async (event) => {
+        const request = event.data;
+        if (typeof request !== "object" ||
+            request == null ||
+            !("id" in request) ||
+            !("method" in request) ||
+            typeof request.method !== "string" ||
+            !isHostRuntimePortMethodName(request.method)) {
+            return;
+        }
+        try {
+            const result = await dispatchRuntimeRequest(runtime, chainService, request, {
+                allocateChainSubscriptionId() {
+                    const subscriptionId = nextChainSubscriptionId;
+                    nextChainSubscriptionId += 1;
+                    return subscriptionId;
+                },
+                setChainSubscriptionStop(subscriptionId, stop) {
+                    subscriptionStops.set(subscriptionId, stop);
+                },
+                stopChainSubscription,
+                stopAllChainSubscriptions,
+            }, port);
+            if (typeof result === "object" &&
+                result != null &&
+                "__queuedChainEvents" in result &&
+                "__markResponsePosted" in result) {
+                const queuedResult = result;
+                console.info(`[runtime-frame] returning subscription handle local=${queuedResult.subscriptionId} queued=${queuedResult.__queuedChainEvents.length}`);
+                port.postMessage({
+                    id: request.id,
+                    ok: true,
+                    result: { subscriptionId: queuedResult.subscriptionId },
+                });
+                queuedResult.__markResponsePosted();
+                for (const queuedEvent of queuedResult.__queuedChainEvents) {
+                    port.postMessage(queuedEvent);
+                }
+            }
+            else {
+                port.postMessage({ id: request.id, ok: true, result });
+            }
+        }
+        catch (error) {
+            port.postMessage({
+                id: request.id,
+                ok: false,
+                error: toErrorMessage(error),
+            });
+        }
+    };
+    return () => {
+        stopAllChainSubscriptions();
+        port.onmessage = null;
+        closePort(port);
+    };
+}
+/**
+ * Connect to a HostRuntime that is already exposed over a MessagePort.
+ */
+export function connectHostRuntimePort(port) {
+    return new PortRemoteHostRuntime(port);
+}
+export function connectHostRuntimeFramePort(port, hasChainService) {
+    const remote = new PortRemoteHostRuntime(port, hasChainService);
+    return {
+        runtime: remote,
+        chainService: remote.chainService,
+    };
+}
+/**
+ * Install the runtime-frame server inside a trusted common-origin iframe page.
+ *
+ * The host page should create the iframe, then call `mountHostRuntimeFrame()`
+ * to transfer a MessagePort into it. Instantiate host-owned browser services
+ * like SmoldotDriver in this page to keep cache/storage scoped to the shared
+ * runtime origin.
+ */
+export function installHostRuntimeFrame(options) {
+    const registry = options.registry ?? defaultHostRuntimeRegistry;
+    const scopeId = options.scopeId ?? "default";
+    let lease = null;
+    let chainService = null;
+    return installScopedFrame({
+        source: HOST_RUNTIME_FRAME_SOURCE,
+        initType: HOST_RUNTIME_FRAME_INIT,
+        readyType: HOST_RUNTIME_FRAME_READY,
+        scopeId,
+        serviceIds: HOST_RUNTIME_FRAME_SERVICE_IDS,
+        readyTransport: "first-port",
+        trustedParentOrigin: options.trustedParentOrigin,
+        async onConnect({ runtime }) {
+            lease?.release();
+            const nextLease = registry.acquire(scopeId, () => options.createRuntime?.() ?? new HostRuntime(options.sdk));
+            const previousChainService = chainService;
+            let nextChainService = null;
+            try {
+                nextChainService = (await options.createChainService?.()) ?? null;
+            }
+            catch (error) {
+                nextLease.release();
+                throw error;
+            }
+            lease = nextLease;
+            chainService = nextChainService;
+            const stopServing = serveHostRuntimePort(runtime, nextLease.runtime, nextChainService);
+            void previousChainService?.destroy();
+            return {
+                payload: {
+                    chainService: nextChainService != null,
+                },
+                dispose: () => {
+                    stopServing();
+                    nextLease.release();
+                    void nextChainService?.destroy();
+                    if (lease === nextLease) {
+                        lease = null;
+                    }
+                    if (chainService === nextChainService) {
+                        chainService = null;
+                    }
+                },
+            };
+        },
+    });
+}
+/**
+ * Mount a hidden trusted runtime iframe and connect to its HostRuntime server.
+ *
+ * The iframe should be served from a common host-controlled origin, such as
+ * `https://host.dot.li/runtime-frame.html`, so host-owned browser services can
+ * live behind one trusted runtime boundary. Note that modern browsers may still
+ * partition iframe storage by top-level site; hosts that need unpartitioned
+ * durable cache reuse across pages must account for those browser policies.
+ */
+export async function mountHostRuntimeFrame(options) {
+    const frame = await mountScopedFrame({
+        source: HOST_RUNTIME_FRAME_SOURCE,
+        initType: HOST_RUNTIME_FRAME_INIT,
+        readyType: HOST_RUNTIME_FRAME_READY,
+        scopeId: options.scopeId ?? "default",
+        serviceIds: HOST_RUNTIME_FRAME_SERVICE_IDS,
+        readyTransport: "first-port",
+        frameUrl: options.runtimeUrl,
+        frameOrigin: options.runtimeOrigin,
+        parent: options.parent,
+        timeoutMs: options.timeoutMs,
+        iframeAttributes: options.iframeAttributes,
+    });
+    const remoteFrame = connectHostRuntimeFramePort(frame.ports.runtime, frame.payload.chainService);
+    return {
+        iframe: frame.iframe,
+        runtime: remoteFrame.runtime,
+        chainService: remoteFrame.chainService,
+        destroy() {
+            void remoteFrame.chainService?.destroy();
+            remoteFrame.runtime.destroy();
+            frame.destroy();
+        },
+    };
+}
+//# sourceMappingURL=host-runtime-frame.js.map