@tyndall/react 0.0.1

package/dist/components.d.ts

@@ -0,0 +1,30 @@
+import { type Router } from "./router.js";
+type ElementType = string | symbol | ((props: Record<string, unknown>) => unknown);
+export interface ElementLike {
+    $$typeof: symbol;
+    type: ElementType;
+    key: string | null;
+    ref: unknown | null;
+    props: Record<string, unknown>;
+}
+export interface LinkProps {
+    href: string;
+    prefetch?: boolean;
+    children?: unknown;
+    onClick?: (event: unknown) => void;
+    onMouseEnter?: (event: unknown) => void;
+    onFocus?: (event: unknown) => void;
+}
+export declare const Link: ({ href, prefetch, children, onClick, ...rest }: LinkProps) => ElementLike;
+export interface HeadProps {
+    children?: unknown;
+}
+export declare const Head: ({ children }: HeadProps) => ElementLike;
+export interface RouterProviderProps {
+    router?: Router;
+    initialHref?: string;
+    children?: unknown;
+}
+export declare const RouterProvider: ({ router, initialHref, children }: RouterProviderProps) => unknown;
+export {};
+//# sourceMappingURL=components.d.ts.map

package/dist/components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../src/components.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsC,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAE9E,KAAK,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,CAAC;AAEnF,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,WAAW,CAAC;IAClB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,GAAG,EAAE,OAAO,GAAG,IAAI,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAmBD,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACnC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACxC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACpC;AAmBD,eAAO,MAAM,IAAI,GAAI,gDAAgD,SAAS,KAAG,WA0DhF,CAAC;AAEF,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,eAAO,MAAM,IAAI,GAAI,cAAc,SAAS,KAAG,WACN,CAAC;AAE1C,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,eAAO,MAAM,cAAc,GAAI,mCAAmC,mBAAmB,KAAG,OAOvF,CAAC"}

package/dist/components.js

@@ -0,0 +1,74 @@
+import { createRouter, getRouter, setRouter } from "./router.js";
+const REACT_ELEMENT = Symbol.for("react.element");
+// Marker component: render nothing, but allow head extraction from its children.
+const HeadMarker = (_props) => null;
+HeadMarker.__hyperHead = true;
+const createElement = (type, props, children) => ({
+    $$typeof: REACT_ELEMENT,
+    type,
+    key: null,
+    ref: null,
+    props: { ...props, children },
+});
+const shouldHandleClick = (event) => {
+    if (event.defaultPrevented) {
+        return false;
+    }
+    if (event.button !== undefined && event.button !== 0) {
+        return false;
+    }
+    return !(event.metaKey || event.ctrlKey || event.shiftKey || event.altKey);
+};
+export const Link = ({ href, prefetch, children, onClick, ...rest }) => {
+    const shouldPrefetch = prefetch !== false;
+    const schedulePrefetch = () => {
+        if (!shouldPrefetch) {
+            return;
+        }
+        // Prefer idle time to keep hover prefetch from impacting interactivity.
+        const run = () => void getRouter().prefetch(href);
+        const idle = globalThis
+            .requestIdleCallback;
+        if (typeof idle === "function") {
+            idle(run);
+            return;
+        }
+        setTimeout(run, 0);
+    };
+    const handleClick = (event) => {
+        onClick?.(event);
+        if (!shouldHandleClick(event)) {
+            return;
+        }
+        event.preventDefault?.();
+        void getRouter().push(href);
+    };
+    const handleMouseEnter = (event) => {
+        rest.onMouseEnter?.(event);
+        schedulePrefetch();
+    };
+    const handleFocus = (event) => {
+        rest.onFocus?.(event);
+        schedulePrefetch();
+    };
+    return createElement("a", {
+        href,
+        // Keep a stable marker for island-mode delegated navigation handlers.
+        "data-hyper-link": "true",
+        onClick: handleClick,
+        onMouseEnter: handleMouseEnter,
+        onFocus: handleFocus,
+        prefetch,
+        ...rest,
+    }, children);
+};
+export const Head = ({ children }) => createElement(HeadMarker, {}, children);
+export const RouterProvider = ({ router, initialHref, children }) => {
+    if (router) {
+        setRouter(router);
+    }
+    else if (initialHref) {
+        setRouter(createRouter(initialHref));
+    }
+    return children ?? null;
+};

package/dist/dynamic-manifest.d.ts

@@ -0,0 +1,27 @@
+import type { DynamicManifestEnvelope, DynamicManifestResolver } from "./router.js";
+export interface DynamicManifestCacheOptions {
+    ttlMs?: number;
+    maxEntries?: number;
+    now?: () => number;
+}
+export interface DynamicManifestCacheEntry {
+    envelope: DynamicManifestEnvelope;
+    etag?: string;
+    expiresAt: number;
+}
+export interface DynamicManifestCache {
+    get: (path: string) => DynamicManifestCacheEntry | null;
+    set: (path: string, envelope: DynamicManifestEnvelope, etag?: string) => void;
+    delete: (path: string) => void;
+    clear: () => void;
+}
+export declare const createDynamicManifestCache: (options?: DynamicManifestCacheOptions) => DynamicManifestCache;
+export interface DynamicManifestResolverOptions {
+    baseUrl?: string;
+    cache?: DynamicManifestCache;
+    fetcher?: typeof fetch;
+    ttlMs?: number;
+    maxEntries?: number;
+}
+export declare const createDynamicManifestResolver: (options?: DynamicManifestResolverOptions) => DynamicManifestResolver;
+//# sourceMappingURL=dynamic-manifest.d.ts.map

package/dist/dynamic-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-manifest.d.ts","sourceRoot":"","sources":["../src/dynamic-manifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAEpF,MAAM,WAAW,2BAA2B;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,uBAAuB,CAAC;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,yBAAyB,GAAG,IAAI,CAAC;IACxD,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,uBAAuB,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9E,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED,eAAO,MAAM,0BAA0B,GACrC,UAAS,2BAAgC,KACxC,oBA6CF,CAAC;AAEF,MAAM,WAAW,8BAA8B;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,oBAAoB,CAAC;IAC7B,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAeD,eAAO,MAAM,6BAA6B,GACxC,UAAS,8BAAmC,KAC3C,uBAmCF,CAAC"}

package/dist/dynamic-manifest.js

@@ -0,0 +1,86 @@
+export const createDynamicManifestCache = (options = {}) => {
+    const ttlMs = options.ttlMs ?? 5 * 60000;
+    const maxEntries = options.maxEntries ?? 100;
+    const now = options.now ?? (() => Date.now());
+    const entries = new Map();
+    const touch = (path, entry) => {
+        entries.delete(path);
+        entries.set(path, entry);
+    };
+    return {
+        get: (path) => {
+            const entry = entries.get(path);
+            if (!entry) {
+                return null;
+            }
+            if (entry.expiresAt <= now()) {
+                entries.delete(path);
+                return null;
+            }
+            touch(path, entry);
+            return entry;
+        },
+        set: (path, envelope, etag) => {
+            const entry = {
+                envelope,
+                etag,
+                expiresAt: now() + ttlMs,
+            };
+            entries.set(path, entry);
+            if (entries.size > maxEntries) {
+                const oldestKey = entries.keys().next().value;
+                if (oldestKey) {
+                    entries.delete(oldestKey);
+                }
+            }
+        },
+        delete: (path) => {
+            entries.delete(path);
+        },
+        clear: () => {
+            entries.clear();
+        },
+    };
+};
+const resolveBaseUrl = (baseUrl) => {
+    if (baseUrl) {
+        return baseUrl;
+    }
+    if (typeof globalThis !== "undefined" && "location" in globalThis) {
+        const location = globalThis.location;
+        if (location?.origin) {
+            return location.origin;
+        }
+    }
+    return "http://localhost";
+};
+export const createDynamicManifestResolver = (options = {}) => {
+    const cache = options.cache ??
+        createDynamicManifestCache({
+            ttlMs: options.ttlMs,
+            maxEntries: options.maxEntries,
+        });
+    const fetcher = options.fetcher ?? fetch;
+    const baseUrl = resolveBaseUrl(options.baseUrl);
+    return async (path) => {
+        const cached = cache.get(path);
+        const url = new URL("/api/pages/resolve", baseUrl);
+        url.searchParams.set("path", path);
+        const headers = {};
+        if (cached?.etag) {
+            headers["If-None-Match"] = cached.etag;
+        }
+        const response = await fetcher(url.toString(), { method: "GET", headers });
+        if (response.status === 304 && cached) {
+            cache.set(path, cached.envelope, cached.etag);
+            return cached.envelope;
+        }
+        if (!response.ok) {
+            return null;
+        }
+        const envelope = (await response.json());
+        const etag = response.headers.get("ETag") ?? response.headers.get("etag") ?? undefined;
+        cache.set(path, envelope, etag);
+        return envelope;
+    };
+};

package/dist/head-manager.d.ts

@@ -0,0 +1,3 @@
+import type { HeadDescriptor } from "@tyndall/core";
+export declare const applyHead: (descriptor: HeadDescriptor) => void;
+//# sourceMappingURL=head-manager.d.ts.map

package/dist/head-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"head-manager.d.ts","sourceRoot":"","sources":["../src/head-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAyBpD,eAAO,MAAM,SAAS,GAAI,YAAY,cAAc,KAAG,IActD,CAAC"}

package/dist/head-manager.js

@@ -0,0 +1,34 @@
+const HEAD_ATTR = "data-hyper-head";
+const removeManagedHead = (head) => {
+    const managed = head.querySelectorAll?.(`[${HEAD_ATTR}]`) ?? [];
+    for (const node of managed) {
+        node.remove?.();
+    }
+};
+const appendEntries = (head, tag, entries) => {
+    if (!entries?.length) {
+        return;
+    }
+    for (const entry of entries) {
+        const element = document.createElement(tag);
+        for (const [key, value] of Object.entries(entry)) {
+            element.setAttribute(key, value);
+        }
+        element.setAttribute(HEAD_ATTR, "");
+        head.appendChild(element);
+    }
+};
+export const applyHead = (descriptor) => {
+    if (typeof document === "undefined" || !document.head) {
+        return;
+    }
+    if (descriptor.title !== undefined) {
+        document.title = descriptor.title;
+    }
+    const head = document.head;
+    // Remove previously managed nodes to keep navigation updates deterministic.
+    removeManagedHead(head);
+    appendEntries(head, "meta", descriptor.meta);
+    appendEntries(head, "link", descriptor.link);
+    appendEntries(head, "script", descriptor.script);
+};

package/dist/head.d.ts

@@ -0,0 +1,3 @@
+import type { HeadDescriptor } from "@tyndall/core";
+export declare const collectHeadFromTree: (node: unknown) => HeadDescriptor;
+//# sourceMappingURL=head.d.ts.map

package/dist/head.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"head.d.ts","sourceRoot":"","sources":["../src/head.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AA8DpD,eAAO,MAAM,mBAAmB,GAAI,MAAM,OAAO,KAAG,cAsEnD,CAAC"}

package/dist/head.js

@@ -0,0 +1,112 @@
+const REACT_ELEMENT = Symbol.for("react.element");
+const REACT_TRANSITIONAL_ELEMENT = Symbol.for("react.transitional.element");
+const HEAD_ELEMENT = Symbol.for("hyper.head");
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isElementLike = (value) => isRecord(value) &&
+    (value.$$typeof === REACT_ELEMENT || value.$$typeof === REACT_TRANSITIONAL_ELEMENT) &&
+    "type" in value &&
+    "props" in value;
+const isHeadMarker = (element) => {
+    if (element.type === HEAD_ELEMENT) {
+        return true;
+    }
+    if (typeof element.type === "function") {
+        return Boolean(element.type.__hyperHead);
+    }
+    return false;
+};
+const extractAttributes = (props) => {
+    const attrs = {};
+    for (const [key, value] of Object.entries(props)) {
+        if (key === "children" || value === undefined || value === null) {
+            continue;
+        }
+        if (typeof value === "function") {
+            continue;
+        }
+        attrs[key] = String(value);
+    }
+    return attrs;
+};
+const extractText = (value) => {
+    if (value === null || value === undefined || typeof value === "boolean") {
+        return "";
+    }
+    if (Array.isArray(value)) {
+        return value.map(extractText).join("");
+    }
+    if (typeof value === "string" || typeof value === "number") {
+        return String(value);
+    }
+    if (isElementLike(value)) {
+        return extractText(value.props.children);
+    }
+    return "";
+};
+export const collectHeadFromTree = (node) => {
+    const head = {};
+    const meta = [];
+    const link = [];
+    const script = [];
+    const visit = (value, inHead) => {
+        if (value === null || value === undefined || typeof value === "boolean") {
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const entry of value) {
+                visit(entry, inHead);
+            }
+            return;
+        }
+        if (isElementLike(value)) {
+            if (isHeadMarker(value)) {
+                visit(value.props.children, true);
+                return;
+            }
+            if (inHead) {
+                if (value.type === "title") {
+                    const text = extractText(value.props.children);
+                    if (text) {
+                        head.title = text;
+                    }
+                    return;
+                }
+                if (value.type === "meta") {
+                    const attrs = extractAttributes(value.props);
+                    if (Object.keys(attrs).length) {
+                        meta.push(attrs);
+                    }
+                    return;
+                }
+                if (value.type === "link") {
+                    const attrs = extractAttributes(value.props);
+                    if (Object.keys(attrs).length) {
+                        link.push(attrs);
+                    }
+                    return;
+                }
+                if (value.type === "script") {
+                    const attrs = extractAttributes(value.props);
+                    if (Object.keys(attrs).length) {
+                        script.push(attrs);
+                    }
+                    return;
+                }
+            }
+            if ("children" in value.props) {
+                visit(value.props.children, inHead);
+            }
+        }
+    };
+    visit(node, false);
+    if (meta.length) {
+        head.meta = meta;
+    }
+    if (link.length) {
+        head.link = link;
+    }
+    if (script.length) {
+        head.script = script;
+    }
+    return head;
+};

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { createReactAdapter } from "./adapter.js";
+export type { ReactAdapterOptions } from "./adapter.js";
+export { createReactUiAdapterFactory, createReactAdapterRegistry } from "./registry.js";
+export { Link, Head, RouterProvider } from "./components.js";
+export type { LinkProps, HeadProps, RouterProviderProps, ElementLike } from "./components.js";
+export { createRouter, getRouter, useRouter } from "./router.js";
+export type { ClientRenderMode, ClientRouteModule, ClientRouteModuleContext, ClientRouteModuleLoader, ClientRouteModuleLoaderMap, ClientRouteModuleResolver, ClientRouteModuleResolverContext, ClientRouteRenderResult, DynamicManifestEnvelope, DynamicManifestRenderer, DynamicManifestResolver, HydrationMode, NavigationMode, RenderPolicy, RoutePayload, RoutePayloadApplier, RoutePayloadResolver, Router, RouterOptions, RouterQuery, } from "./router.js";
+export { createClientRouteModuleResolver } from "./router.js";
+export { installRouterIslands } from "./islands.js";
+export { collectHeadFromTree } from "./head.js";
+export { applyHead } from "./head-manager.js";
+export { createDynamicManifestCache, createDynamicManifestResolver, } from "./dynamic-manifest.js";
+export type { DynamicManifestCache, DynamicManifestCacheEntry, DynamicManifestCacheOptions, DynamicManifestResolverOptions, } from "./dynamic-manifest.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,YAAY,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,2BAA2B,EAAE,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAExF,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAC7D,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9F,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACjE,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,EACxB,uBAAuB,EACvB,0BAA0B,EAC1B,yBAAyB,EACzB,gCAAgC,EAChC,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,EACvB,aAAa,EACb,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,mBAAmB,EACnB,oBAAoB,EACpB,MAAM,EACN,aAAa,EACb,WAAW,GACZ,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,+BAA+B,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EACL,0BAA0B,EAC1B,6BAA6B,GAC9B,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,oBAAoB,EACpB,yBAAyB,EACzB,2BAA2B,EAC3B,8BAA8B,GAC/B,MAAM,uBAAuB,CAAC;AAE/B,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+export { createReactAdapter } from "./adapter.js";
+export { createReactUiAdapterFactory, createReactAdapterRegistry } from "./registry.js";
+export { Link, Head, RouterProvider } from "./components.js";
+export { createRouter, getRouter, useRouter } from "./router.js";
+export { createClientRouteModuleResolver } from "./router.js";
+export { installRouterIslands } from "./islands.js";
+export { collectHeadFromTree } from "./head.js";
+export { applyHead } from "./head-manager.js";
+export { createDynamicManifestCache, createDynamicManifestResolver, } from "./dynamic-manifest.js";
+export * from "./types.js";

package/dist/islands.d.ts

@@ -0,0 +1,3 @@
+import type { Router } from "./router.js";
+export declare const installRouterIslands: (router: Router) => void;
+//# sourceMappingURL=islands.d.ts.map

package/dist/islands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"islands.d.ts","sourceRoot":"","sources":["../src/islands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAiD1C,eAAO,MAAM,oBAAoB,GAAI,QAAQ,MAAM,KAAG,IAqCrD,CAAC"}

package/dist/islands.js

@@ -0,0 +1,78 @@
+const ISLANDS_BOOTSTRAP_KEY = "__HYPER_ROUTER_ISLANDS__";
+const isPrimaryClick = (event) => event.button === 0 &&
+    !event.defaultPrevented &&
+    !event.metaKey &&
+    !event.ctrlKey &&
+    !event.shiftKey &&
+    !event.altKey;
+const resolveInternalLink = (eventTarget) => {
+    if (!(eventTarget instanceof Element)) {
+        return null;
+    }
+    const anchor = eventTarget.closest("a[data-hyper-link]");
+    if (!anchor) {
+        return null;
+    }
+    if (anchor.target && anchor.target !== "_self") {
+        return null;
+    }
+    if (anchor.hasAttribute("download")) {
+        return null;
+    }
+    const href = anchor.getAttribute("href");
+    if (!href) {
+        return null;
+    }
+    const url = new URL(href, window.location.href);
+    if (url.origin !== window.location.origin) {
+        return null;
+    }
+    return anchor;
+};
+const prefetchInternalLink = (router, eventTarget) => {
+    const anchor = resolveInternalLink(eventTarget);
+    if (!anchor) {
+        return;
+    }
+    const href = anchor.getAttribute("href");
+    if (!href) {
+        return;
+    }
+    void router.prefetch(href);
+};
+export const installRouterIslands = (router) => {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+        return;
+    }
+    const state = window;
+    if (state[ISLANDS_BOOTSTRAP_KEY]) {
+        return;
+    }
+    state[ISLANDS_BOOTSTRAP_KEY] = true;
+    // Keep SSR island pages interactive without hydrating the full app tree.
+    document.addEventListener("click", (event) => {
+        if (!isPrimaryClick(event)) {
+            return;
+        }
+        const anchor = resolveInternalLink(event.target);
+        if (!anchor) {
+            return;
+        }
+        const href = anchor.getAttribute("href");
+        if (!href) {
+            return;
+        }
+        event.preventDefault();
+        if (anchor.getAttribute("data-hyper-replace") === "true") {
+            void router.replace(href);
+            return;
+        }
+        void router.push(href);
+    });
+    document.addEventListener("mouseover", (event) => {
+        prefetchInternalLink(router, event.target);
+    });
+    document.addEventListener("focusin", (event) => {
+        prefetchInternalLink(router, event.target);
+    });
+};

package/dist/react-router-bridge.d.ts

@@ -0,0 +1,10 @@
+import type { RouteGraph, RouteRecord } from "@tyndall/core";
+export interface ReactRouterMatchResult {
+    route: RouteRecord;
+    params: Record<string, string | string[]>;
+}
+export interface ReactRouterRouteMatcher {
+    match: (pathname: string) => ReactRouterMatchResult | null;
+}
+export declare const createReactRouterRouteMatcher: (routeGraph: RouteGraph) => ReactRouterRouteMatcher;
+//# sourceMappingURL=react-router-bridge.d.ts.map

package/dist/react-router-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-router-bridge.d.ts","sourceRoot":"","sources":["../src/react-router-bridge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAgB,MAAM,eAAe,CAAC;AAa3E,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,WAAW,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;CAC3C;AA2JD,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,sBAAsB,GAAG,IAAI,CAAC;CAC5D;AAED,eAAO,MAAM,6BAA6B,GACxC,YAAY,UAAU,KACrB,uBA2BF,CAAC"}

package/dist/react-router-bridge.js

@@ -0,0 +1,148 @@
+import { matchRoutes } from "react-router";
+const segmentOrder = (segment) => {
+    if (segment.type === "root") {
+        return 0;
+    }
+    if (segment.type === "static") {
+        return 1;
+    }
+    if (segment.type === "dynamic") {
+        return 2;
+    }
+    return 3;
+};
+const compareSegments = (left, right) => {
+    const order = segmentOrder(left) - segmentOrder(right);
+    if (order !== 0) {
+        return order;
+    }
+    if (left.type === "root" || right.type === "root") {
+        return 0;
+    }
+    if (left.type === "static" && right.type === "static") {
+        return left.value.localeCompare(right.value);
+    }
+    if (left.type === "dynamic" && right.type === "dynamic") {
+        return left.name.localeCompare(right.name);
+    }
+    if (left.type === "catchAll" && right.type === "catchAll") {
+        return left.name.localeCompare(right.name);
+    }
+    return 0;
+};
+const sameSegment = (left, right) => {
+    if (left.type !== right.type) {
+        return false;
+    }
+    if (left.type === "static" && right.type === "static") {
+        return left.value === right.value;
+    }
+    if (left.type === "dynamic" && right.type === "dynamic") {
+        return left.name === right.name;
+    }
+    if (left.type === "catchAll" && right.type === "catchAll") {
+        return left.name === right.name;
+    }
+    return false;
+};
+const createRootNode = () => ({
+    segment: { type: "root" },
+    children: [],
+});
+const findOrCreateChild = (parent, segment) => {
+    const existing = parent.children.find((child) => child.segment.type !== "root" && sameSegment(child.segment, segment));
+    if (existing) {
+        return existing;
+    }
+    const child = { segment, children: [] };
+    parent.children.push(child);
+    parent.children.sort((a, b) => compareSegments(a.segment, b.segment));
+    return child;
+};
+const buildRouteTree = (routeGraph) => {
+    const root = createRootNode();
+    const orderedRoutes = [...routeGraph.routes].sort((a, b) => a.id.localeCompare(b.id));
+    for (const route of orderedRoutes) {
+        let cursor = root;
+        for (const segment of route.segments) {
+            cursor = findOrCreateChild(cursor, segment);
+        }
+        cursor.route = route;
+    }
+    return root;
+};
+const segmentToPath = (segment) => {
+    if (segment.type === "static") {
+        return segment.value;
+    }
+    if (segment.type === "dynamic") {
+        return `:${segment.name}`;
+    }
+    return "*";
+};
+const createHandle = (route) => route ? { hyperRoute: route } : undefined;
+const nodeToRouteObject = (node) => {
+    const childRoutes = node.children.map((child) => nodeToRouteObject(child));
+    const children = childRoutes.length > 0 ? childRoutes : undefined;
+    if (node.segment.type === "root") {
+        // Keep a single root route so nested routeGraph paths can be matched as one tree.
+        return {
+            path: "/",
+            handle: createHandle(node.route),
+            children,
+        };
+    }
+    return {
+        path: segmentToPath(node.segment),
+        handle: createHandle(node.route),
+        children,
+    };
+};
+const hasHyperRouteHandle = (value) => typeof value === "object" &&
+    value !== null &&
+    "hyperRoute" in value &&
+    typeof value.hyperRoute?.id === "string";
+const normalizeParams = (route, params) => {
+    const normalized = {};
+    for (const segment of route.segments) {
+        if (segment.type === "dynamic") {
+            const value = params[segment.name];
+            if (typeof value === "string") {
+                normalized[segment.name] = value;
+            }
+            continue;
+        }
+        if (segment.type === "catchAll") {
+            // react-router exposes splat as "*" so remap back to routeGraph's named catch-all param.
+            const splat = params["*"];
+            if (typeof splat === "string" && splat.length > 0) {
+                normalized[segment.name] = splat.split("/").filter((entry) => entry.length > 0);
+            }
+        }
+    }
+    return normalized;
+};
+export const createReactRouterRouteMatcher = (routeGraph) => {
+    const tree = buildRouteTree(routeGraph);
+    const routes = [nodeToRouteObject(tree)];
+    return {
+        match: (pathname) => {
+            const matches = matchRoutes(routes, pathname);
+            if (!matches || matches.length === 0) {
+                return null;
+            }
+            for (let index = matches.length - 1; index >= 0; index -= 1) {
+                const candidate = matches[index];
+                if (!candidate || !hasHyperRouteHandle(candidate.route.handle)) {
+                    continue;
+                }
+                const route = candidate.route.handle.hyperRoute;
+                return {
+                    route,
+                    params: normalizeParams(route, candidate.params),
+                };
+            }
+            return null;
+        },
+    };
+};