@proto-labs-inc/rig-core 0.2.5 → 0.3.0

package/README.md

@@ -1,7 +1,10 @@
 # @proto-labs-inc/rig-core
 
-The rig, framework-free: URL-state sync, the postMessage bridge to Proto's
-Frame, and comment mode. Prototypes use it through an adapter,
-`@proto-labs-inc/rig` for React or `@proto-labs-inc/rig-vue` for Vue.
-Comment capture lazy-imports `modern-screenshot` from the prototype's own
-dependencies; without it a comment still works, with no picture.
+The stable loader and framework contract for Proto's hosted rig. React and Vue
+adapters load the current compatible runtime through `loadRuntime(manifest,
+signal)`, then use its store and lifecycle methods. The runtime owns state,
+URL/history, bridge, themes, capture, and selection behavior.
+
+Every opening checks the active release and verifies downloaded code by SHA-256.
+There is no offline startup fallback. Existing running sessions survive connection
+loss; opening or refreshing without a compatible runtime fails with Retry.

package/dist/contract.d.ts

@@ -0,0 +1,36 @@
+import type { Manifest } from "@proto-labs-inc/wire";
+export declare const ADAPTER_CONTRACT = 1;
+export declare const ADAPTER_VERSION = "0.3.0";
+export interface RuntimeStore {
+    get(key: string): string | undefined;
+    set(key: string, value: string): void;
+    subscribe(listener: () => void): () => void;
+}
+export interface RuntimeOptions {
+    frameOrigin?: string;
+    tools: boolean;
+    release: string;
+    adapterVersion: string;
+    owner?: "desktop";
+}
+export interface RuntimeInstance {
+    store: RuntimeStore;
+    start(): void;
+    dispose(): void;
+}
+export interface RuntimeModule {
+    adapterContract: number;
+    createRuntime(manifest: Manifest, options: RuntimeOptions): RuntimeInstance;
+}
+export interface RuntimeRelease {
+    contract: number;
+    release: string;
+    sha256: string;
+    asset: string;
+}
+export interface RuntimePacket {
+    descriptor: RuntimeRelease;
+    source: string;
+}
+export declare function isRuntimeRelease(value: unknown): value is RuntimeRelease;
+export declare function verifyRuntime(packet: RuntimePacket): Promise<void>;

package/dist/contract.js

@@ -0,0 +1,19 @@
+export const ADAPTER_CONTRACT = 1;
+export const ADAPTER_VERSION = "0.3.0";
+export function isRuntimeRelease(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const r = value;
+    return r.contract === ADAPTER_CONTRACT && typeof r.release === "string" &&
+        typeof r.sha256 === "string" && /^[a-f0-9]{64}$/.test(r.sha256) &&
+        r.release === r.sha256 && r.asset === `/rig-runtime/${r.sha256}.js`;
+}
+export async function verifyRuntime(packet) {
+    if (!isRuntimeRelease(packet.descriptor) || typeof packet.source !== "string")
+        throw new Error("Incompatible rig runtime");
+    const bytes = new TextEncoder().encode(packet.source);
+    const hash = await crypto.subtle.digest("SHA-256", bytes);
+    const hex = [...new Uint8Array(hash)].map(b => b.toString(16).padStart(2, "0")).join("");
+    if (hex !== packet.descriptor.sha256)
+        throw new Error("Rig runtime integrity check failed");
+}

package/dist/index.d.ts

@@ -1,38 +1,5 @@
-/**
- * The rig's framework-free core: URL-state sync, the bridge, and the Frame tools
- * loader. Everything here is plain DOM + history + postMessage — no framework.
- * Framework adapters (@proto-labs-inc/rig for React, @proto-labs-inc/rig-vue for Vue) wrap
- * this with their own idioms and nothing else.
- */
-import { type Manifest, type ResolvedPreviewTheme, type RigToFrame } from "@proto-labs-inc/wire";
+/** Stable bootstrap and framework contract. Product behavior lives in rig-runtime. */
+export { loadRuntime } from "./loader.js";
+export { ADAPTER_CONTRACT, ADAPTER_VERSION } from "./contract.js";
+export type { RuntimeInstance, RuntimeStore, RuntimeModule, RuntimeOptions } from "./contract.js";
 export { STATE_PARAM, variantParam } from "@proto-labs-inc/wire";
-export declare const INTERNAL_PREVIEW_THEME_PARAM = "__protoTheme";
-/** Mark the page light or dark (data-proto-theme and the "dark" class) for
- *  a prototype that styles both. The page's own CSS decides color-scheme:
- *  forcing it here gave pages that only style light mode dark form fields
- *  on a light page whenever the viewer's system was dark. */
-export declare function applyPreviewTheme(theme: ResolvedPreviewTheme): void;
-/** All addressable state, mirrored to the URL. Keys: "state" | "v.<component>". */
-export declare class RigStore {
-    private manifest;
-    private values;
-    private listeners;
-    constructor(manifest: Manifest);
-    updateManifest(manifest: Manifest): void;
-    get(key: string): string | undefined;
-    set(key: string, value: string): void;
-    setMany(entries: Array<[string, string]>): void;
-    setState(id: string, variants: Record<string, string>): void;
-    subscribe: (l: () => void) => () => void;
-    /** Restore the exact URL, including removed selections, without writing a
-     * new history entry while Back or Forward is traversing an existing one. */
-    restoreUrl(): void;
-    private syncUrl;
-}
-export declare function postToFrame(msg: RigToFrame): void;
-/**
- * Wire a store to the bridge: listen for Frame messages, announce the rig,
- * and report the boot-time state (the deep-link fix). Returns a disposer.
- * Call client-side only.
- */
-export declare function wireRig(store: RigStore, manifest: Manifest): () => void;

package/dist/index.js

@@ -1,277 +1,4 @@
-/**
- * The rig's framework-free core: URL-state sync, the bridge, and the Frame tools
- * loader. Everything here is plain DOM + history + postMessage — no framework.
- * Framework adapters (@proto-labs-inc/rig for React, @proto-labs-inc/rig-vue for Vue) wrap
- * this with their own idioms and nothing else.
- */
-import { PROTOCOL_VERSION, STATE_PARAM, variantParam, applyVariantSelection, isFrameToRig, } from "@proto-labs-inc/wire";
-import { loadFrameTools } from "./frame-tools-loader.js";
-import { observePageHistory } from "./page-history.js";
+/** Stable bootstrap and framework contract. Product behavior lives in rig-runtime. */
+export { loadRuntime } from "./loader.js";
+export { ADAPTER_CONTRACT, ADAPTER_VERSION } from "./contract.js";
 export { STATE_PARAM, variantParam } from "@proto-labs-inc/wire";
-const RIG_VERSION = "0.2.5";
-export const INTERNAL_PREVIEW_THEME_PARAM = "__protoTheme";
-/** Mark the page light or dark (data-proto-theme and the "dark" class) for
- *  a prototype that styles both. The page's own CSS decides color-scheme:
- *  forcing it here gave pages that only style light mode dark form fields
- *  on a light page whenever the viewer's system was dark. */
-export function applyPreviewTheme(theme) {
-    if (typeof document === "undefined")
-        return;
-    const root = document.documentElement;
-    root.dataset.protoTheme = theme;
-    root.classList.toggle("dark", theme === "dark");
-}
-function resolvedSystemTheme() {
-    return window.matchMedia("(prefers-color-scheme: dark)").matches
-        ? "dark"
-        : "light";
-}
-function searchForFrame() {
-    const params = new URLSearchParams(window.location.search);
-    params.delete(INTERNAL_PREVIEW_THEME_PARAM);
-    const search = params.toString();
-    return search ? `?${search}` : "";
-}
-/** All addressable state, mirrored to the URL. Keys: "state" | "v.<component>". */
-export class RigStore {
-    manifest;
-    values = new Map();
-    listeners = new Set();
-    constructor(manifest) {
-        this.manifest = manifest;
-        if (typeof window === "undefined")
-            return;
-        const params = new URLSearchParams(window.location.search);
-        const bootTheme = params.get(INTERNAL_PREVIEW_THEME_PARAM);
-        applyPreviewTheme(bootTheme === "light" || bootTheme === "dark"
-            ? bootTheme
-            : resolvedSystemTheme());
-        for (const [k, v] of params) {
-            if (k === STATE_PARAM || k.startsWith("v."))
-                this.values.set(k, v);
-        }
-        const state = manifest.states.find((s) => s.id === this.values.get(STATE_PARAM));
-        let hydrated = false;
-        for (const [component, variant] of Object.entries(state?.variants ?? {})) {
-            const key = variantParam(component);
-            if (this.values.has(key))
-                continue;
-            this.values.set(key, variant);
-            params.set(key, variant);
-            hydrated = true;
-        }
-        if (hydrated) {
-            window.history.replaceState(null, "", `?${params.toString()}${window.location.hash || ""}`);
-        }
-    }
-    updateManifest(manifest) {
-        this.manifest = manifest;
-    }
-    get(key) {
-        return this.values.get(key);
-    }
-    set(key, value) {
-        if (key.startsWith("v.")) {
-            const params = new URLSearchParams([...this.values]);
-            if (!applyVariantSelection(this.manifest.variantSets, params, key.slice(2), value))
-                return;
-            this.setMany([...params.entries()]);
-            return;
-        }
-        this.setMany([[key, value]]);
-    }
-    setMany(entries) {
-        let changed = false;
-        for (const [key, value] of entries) {
-            if (this.values.get(key) === value)
-                continue;
-            this.values.set(key, value);
-            changed = true;
-        }
-        if (!changed)
-            return;
-        this.syncUrl();
-        this.listeners.forEach((l) => l());
-    }
-    setState(id, variants) {
-        const next = new Map([[STATE_PARAM, id]]);
-        for (const [component, variant] of Object.entries(variants)) {
-            next.set(variantParam(component), variant);
-        }
-        let changed = this.values.size !== next.size;
-        if (!changed) {
-            for (const [key, value] of next) {
-                if (this.values.get(key) !== value) {
-                    changed = true;
-                    break;
-                }
-            }
-        }
-        if (!changed)
-            return;
-        this.values = next;
-        this.syncUrl();
-        this.listeners.forEach((l) => l());
-    }
-    subscribe = (l) => {
-        this.listeners.add(l);
-        return () => {
-            this.listeners.delete(l);
-        };
-    };
-    /** Restore the exact URL, including removed selections, without writing a
-     * new history entry while Back or Forward is traversing an existing one. */
-    restoreUrl() {
-        const next = new Map();
-        for (const [key, value] of new URLSearchParams(window.location.search)) {
-            if (key === STATE_PARAM || key.startsWith("v."))
-                next.set(key, value);
-        }
-        const changed = next.size !== this.values.size ||
-            [...next].some(([key, value]) => this.values.get(key) !== value);
-        if (!changed)
-            return;
-        this.values = next;
-        this.listeners.forEach((listener) => listener());
-    }
-    syncUrl() {
-        const params = new URLSearchParams(window.location.search);
-        for (const key of [...params.keys()]) {
-            if (key === STATE_PARAM || key.startsWith("v."))
-                params.delete(key);
-        }
-        for (const [k, v] of this.values)
-            params.set(k, v);
-        const search = `?${params.toString()}${window.location.hash || ""}`;
-        window.history.replaceState(null, "", search);
-    }
-}
-export function postToFrame(msg) {
-    // P0: the Frame's origin isn't known to the prototype; "*" is acceptable
-    // because nothing sensitive crosses the bridge. Revisit with link protection.
-    if (typeof window !== "undefined" && window.parent !== window)
-        window.parent.postMessage(msg, "*");
-}
-async function waitForCaptureReady() {
-    const pendingImages = [...document.images]
-        .filter((image) => !image.complete)
-        .map((image) => new Promise((resolve) => {
-        image.addEventListener("load", () => resolve(), { once: true });
-        image.addEventListener("error", () => resolve(), { once: true });
-    }));
-    const assetsReady = Promise.all([document.fonts.ready, ...pendingImages]);
-    await Promise.race([
-        assetsReady,
-        new Promise((resolve) => window.setTimeout(resolve, 3000)),
-    ]);
-    // requestAnimationFrame may be suspended for an invisible iframe. The timer
-    // also lets entrance transitions and canvas-backed backgrounds reach their
-    // resting state before the gallery captures them.
-    await new Promise((resolve) => window.setTimeout(resolve, 1500));
-}
-async function captureThumbnail() {
-    const restingState = document.createElement("style");
-    restingState.textContent = `
-    *, *::before, *::after {
-      animation-delay: 0s !important;
-      animation-duration: 0s !important;
-      transition-delay: 0s !important;
-      transition-duration: 0s !important;
-    }
-    .opacity-0,
-    [style*="opacity: 0"] {
-      opacity: 1 !important;
-      transform: none !important;
-    }
-  `;
-    document.head.append(restingState);
-    try {
-        for (const animation of document.getAnimations()) {
-            try {
-                animation.finish();
-            }
-            catch {
-                animation.cancel();
-            }
-        }
-        await waitForCaptureReady();
-        // Optional peer provided by the prototype, not the rig.
-        const mod = (await import("modern-screenshot"));
-        const bodyBackground = window.getComputedStyle(document.body).backgroundColor;
-        const htmlBackground = window.getComputedStyle(document.documentElement).backgroundColor;
-        const backgroundColor = bodyBackground !== "rgba(0, 0, 0, 0)" ? bodyBackground : htmlBackground;
-        return await mod.domToDataUrl(document.documentElement, {
-            backgroundColor,
-            timeout: 5000,
-            width: window.innerWidth,
-            height: window.innerHeight,
-            scale: 1,
-        });
-    }
-    catch {
-        return null;
-    }
-    finally {
-        restingState.remove();
-    }
-}
-/**
- * Wire a store to the bridge: listen for Frame messages, announce the rig,
- * and report the boot-time state (the deep-link fix). Returns a disposer.
- * Call client-side only.
- */
-export function wireRig(store, manifest) {
-    store.updateManifest(manifest);
-    const disposeHistory = observePageHistory(() => {
-        store.restoreUrl();
-        postToFrame({ type: "state-changed", search: searchForFrame() });
-    });
-    const disposeTools = loadFrameTools(manifest.frameOrigin);
-    let controlledTheme = false;
-    const media = window.matchMedia("(prefers-color-scheme: dark)");
-    const onSystemTheme = () => {
-        if (!controlledTheme)
-            applyPreviewTheme(resolvedSystemTheme());
-    };
-    media.addEventListener("change", onSystemTheme);
-    const onMessage = (e) => {
-        if (e.source !== window.parent)
-            return;
-        if (!isFrameToRig(e.data))
-            return; // tolerate unknown messages silently
-        if (e.data.type === "set-state") {
-            const state = manifest.states.find((s) => s.id === e.data.id);
-            store.setState(e.data.id, state?.variants ?? {});
-        }
-        else if (e.data.type === "set-theme") {
-            controlledTheme = true;
-            applyPreviewTheme(e.data.theme);
-        }
-        else if (e.data.type === "set-variant")
-            store.set(variantParam(e.data.component), e.data.variant);
-    };
-    window.addEventListener("message", onMessage);
-    postToFrame({
-        type: "hello",
-        protocolVersion: PROTOCOL_VERSION,
-        rigVersion: RIG_VERSION,
-        name: manifest.name,
-    });
-    postToFrame({ type: "state-changed", search: searchForFrame() });
-    const thumbnailRequestId = new URLSearchParams(window.location.search).get("_protoThumbnail");
-    if (thumbnailRequestId) {
-        void captureThumbnail().then((image) => {
-            postToFrame({
-                type: "thumbnail-capture",
-                image,
-                requestId: thumbnailRequestId,
-            });
-        });
-    }
-    return () => {
-        disposeHistory();
-        media.removeEventListener("change", onSystemTheme);
-        window.removeEventListener("message", onMessage);
-        disposeTools();
-    };
-}

package/dist/loader.d.ts

@@ -0,0 +1,3 @@
+import type { Manifest } from "@proto-labs-inc/wire";
+import { type RuntimeInstance } from "./contract.js";
+export declare function loadRuntime(manifest: Manifest, signal: AbortSignal): Promise<RuntimeInstance>;

package/dist/loader.js

@@ -0,0 +1,124 @@
+import { ADAPTER_CONTRACT, ADAPTER_VERSION, verifyRuntime } from "./contract.js";
+const HOST_KEY = Symbol.for("proto.rig.host");
+const RUNNING_KEY = Symbol.for("proto.rig.running");
+const LOADER_KEY = Symbol.for("proto.rig.loader");
+const global = globalThis;
+// Native desktop authorization supplies the backend, never a query parameter.
+if (typeof window !== "undefined")
+    global[LOADER_KEY] = true;
+function trustedOrigin(value) {
+    const url = new URL(value);
+    const local = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+    if (url.origin !== value || (url.protocol !== "https:" && !(url.protocol === "http:" && local)))
+        throw new Error("Invalid rig origin");
+    return url.origin;
+}
+async function resolveHost(manifest, signal) {
+    const native = global[HOST_KEY];
+    if (native)
+        return { ...native, origin: trustedOrigin(native.origin) };
+    if (!document.referrer && window.name.startsWith("prototype-page:")) {
+        return new Promise((resolve, reject) => {
+            const finish = () => { clearTimeout(timer); window.removeEventListener("proto:rig-host", ready); signal.removeEventListener("abort", abort); };
+            const ready = () => { const host = global[HOST_KEY]; if (host) {
+                finish();
+                try {
+                    resolve({ ...host, origin: trustedOrigin(host.origin) });
+                }
+                catch (error) {
+                    reject(error);
+                }
+            } };
+            const abort = () => { finish(); reject(signal.reason); };
+            const timer = window.setTimeout(() => { finish(); reject(new Error("Update Proto desktop to load this rig")); }, 15_000);
+            window.addEventListener("proto:rig-host", ready);
+            signal.addEventListener("abort", abort, { once: true });
+            ready();
+        });
+    }
+    if (!manifest.frameOrigin)
+        throw new Error("The prototype has no configured Frame origin");
+    const origin = trustedOrigin(manifest.frameOrigin);
+    const parentMatches = Boolean(document.referrer && new URL(document.referrer).origin === origin);
+    return { origin, tools: window.parent !== window && parentMatches && window.name === "prototype-page" };
+}
+async function requestRuntime(host, signal) {
+    // Embedded previews ask their authenticated parent to fetch public code. This
+    // also avoids HTTPS prototypes making private-network requests to localhost.
+    if (window.parent !== window && host.tools) {
+        return new Promise((resolve, reject) => {
+            const channel = new MessageChannel();
+            const finish = () => { clearTimeout(timer); channel.port1.close(); signal.removeEventListener("abort", abort); };
+            const abort = () => { finish(); reject(signal.reason); };
+            const timer = window.setTimeout(() => { finish(); reject(new Error("Rig runtime request timed out")); }, 15_000);
+            signal.addEventListener("abort", abort, { once: true });
+            channel.port1.onmessage = event => { finish(); if (event.data?.status === "ready")
+                resolve(event.data.packet);
+            else
+                reject(new Error("Rig runtime unavailable")); };
+            window.parent.postMessage({ type: "request-rig-runtime", contract: ADAPTER_CONTRACT }, host.origin, [channel.port2]);
+        });
+    }
+    const response = await fetch(`${host.origin}/rig-runtime/active.json`, { credentials: "omit", cache: "no-store", redirect: "error", signal });
+    if (!response.ok)
+        throw new Error("Rig release unavailable");
+    const descriptor = await response.json();
+    // Validate the descriptor before using any path from the network.
+    const { isRuntimeRelease } = await import("./contract.js");
+    if (!isRuntimeRelease(descriptor))
+        throw new Error("Incompatible rig release");
+    const asset = await fetch(`${host.origin}${descriptor.asset}`, { credentials: "omit", redirect: "error", signal });
+    if (!asset.ok)
+        throw new Error("Rig runtime unavailable");
+    return { descriptor, source: await asset.text() };
+}
+export async function loadRuntime(manifest, signal) {
+    const host = await resolveHost(manifest, signal);
+    signal.throwIfAborted();
+    const activate = async (packet) => {
+        await verifyRuntime(packet);
+        signal.throwIfAborted();
+        const url = URL.createObjectURL(new Blob([packet.source], { type: "text/javascript" }));
+        let instance;
+        try {
+            const runtime = await import(/* webpackIgnore: true */ /* @vite-ignore */ url);
+            signal.throwIfAborted();
+            if (runtime.adapterContract !== ADAPTER_CONTRACT || typeof runtime.createRuntime !== "function")
+                throw new Error("Incompatible rig module");
+            instance = runtime.createRuntime(manifest, { frameOrigin: host.origin, tools: host.tools, release: packet.descriptor.release, adapterVersion: ADAPTER_VERSION, owner: host.owner });
+            if (global[RUNNING_KEY])
+                throw new Error("A rig runtime is already mounted");
+            const mounted = instance;
+            global[RUNNING_KEY] = mounted;
+            const dispose = mounted.dispose.bind(mounted);
+            mounted.dispose = () => {
+                try {
+                    dispose();
+                }
+                finally {
+                    if (global[RUNNING_KEY] === mounted)
+                        delete global[RUNNING_KEY];
+                }
+            };
+            instance.start();
+            return instance;
+        }
+        catch (error) {
+            instance?.dispose();
+            throw error;
+        }
+        finally {
+            URL.revokeObjectURL(url);
+        }
+    };
+    try {
+        const candidate = await requestRuntime(host, AbortSignal.any([signal, AbortSignal.timeout(8_000)]));
+        return await activate(candidate);
+    }
+    catch (error) {
+        signal.throwIfAborted();
+        if (window.parent !== window)
+            window.parent.postMessage({ type: "rig-runtime-status", status: "unavailable" }, host.origin);
+        throw error;
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@proto-labs-inc/rig-core",
-  "version": "0.2.5",
-  "description": "Proto's rig, framework-free: URL-state sync, the postMessage bridge to the Frame, and comment mode.",
+  "version": "0.3.0",
+  "description": "Stable hosted rig loader and framework adapter contract.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -19,20 +19,11 @@
   "files": [
     "dist"
   ],
-  "peerDependencies": {
-    "modern-screenshot": ">=4"
-  },
-  "peerDependenciesMeta": {
-    "modern-screenshot": {
-      "optional": true
-    }
-  },
   "dependencies": {
-    "@proto-labs-inc/wire": "^0.2.4"
+    "@proto-labs-inc/wire": "^0.3.0"
   },
   "devDependencies": {
-    "typescript": "~6.0.2",
-    "modern-screenshot": "^4.7.0"
+    "typescript": "~6.0.2"
   },
   "publishConfig": {
     "access": "public"

package/dist/frame-tools-loader.d.ts

@@ -1,2 +0,0 @@
-/** Stable bootstrap only. Selection behavior is deployed with the Frame app. */
-export declare function loadFrameTools(frameOrigin?: string): () => void;

package/dist/frame-tools-loader.js

@@ -1,83 +0,0 @@
-/** Stable bootstrap only. Selection behavior is deployed with the Frame app. */
-export function loadFrameTools(frameOrigin) {
-    if (window.parent === window)
-        return () => { };
-    let disposed = false;
-    let closeRequest;
-    let unmount;
-    const report = (status, origin = "*") => {
-        if (!disposed)
-            window.parent.postMessage({ type: "frame-tools-status", status }, origin);
-    };
-    const dispose = () => { disposed = true; closeRequest?.(); unmount?.(); };
-    if (!frameOrigin) {
-        report("unavailable");
-        return dispose;
-    }
-    let origin;
-    try {
-        const url = new URL(frameOrigin);
-        const local = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]";
-        if (url.protocol !== "https:" && !(url.protocol === "http:" && local))
-            throw new Error("Invalid Frame origin");
-        if (url.username || url.password || url.origin !== frameOrigin)
-            throw new Error("Expected an origin");
-        origin = url.origin;
-        // The origin is pinned in the prototype, never taken from a message or URL parameter.
-        if (!document.referrer || new URL(document.referrer).origin !== origin)
-            return dispose;
-    }
-    catch {
-        report("unavailable");
-        return dispose;
-    }
-    report("loading", origin);
-    // The Frame fetches its own public module. A published HTTPS prototype
-    // never needs to reach into a localhost or private-network Frame.
-    const channel = new MessageChannel();
-    const source = new Promise((resolve, reject) => {
-        const finish = () => {
-            clearTimeout(timer);
-            channel.port1.close();
-            closeRequest = undefined;
-        };
-        const timer = setTimeout(() => {
-            finish();
-            reject(new Error("Selection runtime request timed out"));
-        }, 15_000);
-        closeRequest = () => {
-            finish();
-            reject(new Error("Selection runtime request disposed"));
-        };
-        channel.port1.onmessage = (event) => {
-            finish();
-            const reply = event.data;
-            if (reply?.status === "ready" && typeof reply.source === "string")
-                resolve(reply.source);
-            else
-                reject(new Error("Selection runtime unavailable"));
-        };
-        window.parent.postMessage({ type: "request-frame-tools" }, origin, [channel.port2]);
-    });
-    void source.then(async (text) => {
-        if (disposed)
-            return;
-        const url = URL.createObjectURL(new Blob([text], { type: "text/javascript" }));
-        try {
-            const runtime = await import(/* webpackIgnore: true */ /* @vite-ignore */ url);
-            if (disposed)
-                return;
-            unmount = runtime.mountFrameTools({ frameOrigin: origin });
-            report("ready", origin);
-        }
-        finally {
-            URL.revokeObjectURL(url);
-        }
-    }).catch((error) => {
-        if (disposed)
-            return;
-        console.warn("Proto selection tools failed to load", error);
-        report("unavailable", origin);
-    });
-    return dispose;
-}

package/dist/page-history.d.ts

@@ -1,4 +0,0 @@
-/** Every URL change in a prototype is a step the browser bar can revisit.
- * Keep state-only history writes intact: routers use those for bookkeeping.
- * Install after boot-time URL hydration, which is not a navigation. */
-export declare function observePageHistory(onNavigate: () => void): () => void;

package/dist/page-history.js

@@ -1,38 +0,0 @@
-/** Every URL change in a prototype is a step the browser bar can revisit.
- * Keep state-only history writes intact: routers use those for bookkeeping.
- * Install after boot-time URL hydration, which is not a navigation. */
-export function observePageHistory(onNavigate) {
-    const history = window.history;
-    const push = history.pushState;
-    const replace = history.replaceState;
-    let currentUrl = window.location.href;
-    const changed = () => {
-        const url = window.location.href;
-        if (url === currentUrl)
-            return;
-        currentUrl = url;
-        onNavigate();
-    };
-    const pushState = function (data, unused, url) {
-        push.call(this, data, unused, url);
-        changed();
-    };
-    const replaceState = function (data, unused, url) {
-        const next = url == null ? window.location.href : new URL(url, window.location.href).href;
-        const write = next === window.location.href ? replace : push;
-        write.call(this, data, unused, url);
-        changed();
-    };
-    history.pushState = pushState;
-    history.replaceState = replaceState;
-    window.addEventListener("popstate", changed);
-    window.addEventListener("hashchange", changed);
-    return () => {
-        if (history.pushState === pushState)
-            history.pushState = push;
-        if (history.replaceState === replaceState)
-            history.replaceState = replace;
-        window.removeEventListener("popstate", changed);
-        window.removeEventListener("hashchange", changed);
-    };
-}