npm - @tyndall/react - Versions diffs - 0.0.1 - Mend

@tyndall/react 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (35) hide show

package/README.md +32 -0
package/dist/adapter.d.ts +16 -0
package/dist/adapter.d.ts.map +1 -0
package/dist/adapter.js +750 -0
package/dist/components.d.ts +30 -0
package/dist/components.d.ts.map +1 -0
package/dist/components.js +74 -0
package/dist/dynamic-manifest.d.ts +27 -0
package/dist/dynamic-manifest.d.ts.map +1 -0
package/dist/dynamic-manifest.js +86 -0
package/dist/head-manager.d.ts +3 -0
package/dist/head-manager.d.ts.map +1 -0
package/dist/head-manager.js +34 -0
package/dist/head.d.ts +3 -0
package/dist/head.d.ts.map +1 -0
package/dist/head.js +112 -0
package/dist/index.d.ts +15 -0
package/dist/index.d.ts.map +1 -0
package/dist/index.js +10 -0
package/dist/islands.d.ts +3 -0
package/dist/islands.d.ts.map +1 -0
package/dist/islands.js +78 -0
package/dist/react-router-bridge.d.ts +10 -0
package/dist/react-router-bridge.d.ts.map +1 -0
package/dist/react-router-bridge.js +148 -0
package/dist/registry.d.ts +4 -0
package/dist/registry.d.ts.map +1 -0
package/dist/registry.js +18 -0
package/dist/router.d.ts +82 -0
package/dist/router.d.ts.map +1 -0
package/dist/router.js +470 -0
package/dist/types.d.ts +17 -0
package/dist/types.d.ts.map +1 -0
package/dist/types.js +1 -0
package/package.json +32 -0

package/dist/adapter.js ADDED Viewed

@@ -0,0 +1,750 @@
+import React from "react";
+import { createRequire } from "node:module";
+import { join, relative, sep } from "node:path";
+import { mergeHeadDescriptors, serializeProps } from "@tyndall/core";
+import { collectHeadFromTree } from "./head.js";
+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 escapeHtml = (value) => value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/\"/g, "&quot;");
+const renderAttributes = (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.push(`${key}=\"${escapeHtml(String(value))}\"`);
+    }
+    return attrs.length ? ` ${attrs.join(" ")}` : "";
+};
+const renderElementToString = (node) => {
+    if (node === null || node === undefined || typeof node === "boolean") {
+        return "";
+    }
+    if (Array.isArray(node)) {
+        return node.map(renderElementToString).join("");
+    }
+    if (typeof node === "string" || typeof node === "number") {
+        return escapeHtml(String(node));
+    }
+    if (!isElementLike(node)) {
+        return "";
+    }
+    if (isHeadMarker(node)) {
+        return "";
+    }
+    if (typeof node.type === "function") {
+        return renderElementToString(node.type(node.props));
+    }
+    if (typeof node.type !== "string") {
+        return "";
+    }
+    const children = renderElementToString(node.props.children);
+    const attrs = renderAttributes(node.props);
+    return `<${node.type}${attrs}>${children}</${node.type}>`;
+};
+const resolveReactDomServer = async () => {
+    try {
+        return await import("react-dom/server");
+    }
+    catch {
+        return null;
+    }
+};
+const renderWithFallback = async (element) => {
+    const reactDomServer = await resolveReactDomServer();
+    if (reactDomServer?.renderToString) {
+        try {
+            return reactDomServer.renderToString(element);
+        }
+        catch {
+            // Fall back when custom markers (e.g., <Head>) are not React-renderable.
+        }
+    }
+    // Fallback renderer keeps local tests/dev flows working without react-dom.
+    return renderElementToString(element);
+};
+const resolvePageImport = (ctx) => {
+    const options = ctx.uiOptions ?? ctx.adapterOptions;
+    const pageModule = options?.pageModule;
+    const specifier = typeof pageModule === "string" ? pageModule : "./page";
+    return JSON.stringify(specifier);
+};
+const resolveHydrationMode = (ctx) => {
+    const options = ctx.uiOptions ?? ctx.adapterOptions;
+    return options?.hydration === "islands" ? "islands" : "full";
+};
+const resolveNavigationMode = (ctx) => {
+    const options = ctx.uiOptions ?? ctx.adapterOptions;
+    return options?.navigationMode === "url" ? "url" : "client";
+};
+const resolveClientRenderMode = (ctx) => {
+    const options = ctx.uiOptions ?? ctx.adapterOptions;
+    return options?.clientRenderMode === "module" ? "module" : "payload";
+};
+const resolveClientRouteModules = (ctx) => {
+    const options = ctx.uiOptions ?? ctx.adapterOptions;
+    const raw = options?.clientRouteModules;
+    if (!isRecord(raw)) {
+        return {};
+    }
+    const entries = {};
+    for (const [routeId, specifier] of Object.entries(raw)) {
+        if (typeof specifier !== "string") {
+            continue;
+        }
+        entries[routeId] = specifier;
+    }
+    return entries;
+};
+const resolveNestedLayoutsEnabled = (options) => {
+    if (!options) {
+        return true;
+    }
+    if ("nestedLayouts" in options) {
+        return options.nestedLayouts !== false;
+    }
+    return true;
+};
+const findRouteRecord = (routeGraph, routeId) => {
+    if (!routeGraph || !routeId) {
+        return null;
+    }
+    return routeGraph.routes.find((route) => route.id === routeId) ?? null;
+};
+const resolveLayoutFilesForRoute = (routeGraph, routeId) => {
+    const route = findRouteRecord(routeGraph, routeId);
+    return route?.layoutFiles ?? [];
+};
+const resolveLayoutModulePath = (layoutFile, rootDir, routeRoot) => {
+    if (!rootDir || !routeRoot) {
+        return layoutFile;
+    }
+    const relativePath = relative(rootDir, layoutFile);
+    if (!relativePath || relativePath === ".." || relativePath.startsWith(`..${sep}`)) {
+        return layoutFile;
+    }
+    return join(routeRoot, relativePath);
+};
+const toPosixPath = (value) => value.split(sep).join("/");
+const toFileUrl = (value) => {
+    const normalized = toPosixPath(value);
+    const prefix = normalized.startsWith("/") ? "" : "/";
+    return `file://${prefix}${encodeURI(normalized)}`;
+};
+const toImportSpecifier = (fromDir, targetPath) => {
+    const relativePath = toPosixPath(relative(fromDir, targetPath));
+    if (!relativePath || relativePath === ".") {
+        return "./";
+    }
+    return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+};
+const resolveLayoutSpecifiersForRoute = (ctx, routeId) => {
+    if (!ctx.entryDir) {
+        return [];
+    }
+    const layoutFiles = resolveLayoutFilesForRoute(ctx.routeGraph, routeId);
+    if (layoutFiles.length === 0) {
+        return [];
+    }
+    return layoutFiles.map((layoutFile) => {
+        const modulePath = resolveLayoutModulePath(layoutFile, ctx.rootDir, ctx.routeRoot);
+        return toImportSpecifier(ctx.entryDir ?? "", modulePath);
+    });
+};
+const buildClientRouteLayoutLoaderSource = (layoutModules) => {
+    const declarations = [];
+    const entries = [];
+    let index = 0;
+    for (const [routeId, specifiers] of Object.entries(layoutModules).sort(([a], [b]) => a.localeCompare(b))) {
+        if (!Array.isArray(specifiers) || specifiers.length === 0) {
+            entries.push(`${JSON.stringify(routeId)}: []`);
+            continue;
+        }
+        const loaders = specifiers.map((specifier) => {
+            const loaderName = `loadLayoutModule${index++}`;
+            declarations.push(`const ${loaderName} = () => import(${JSON.stringify(specifier)});`);
+            return loaderName;
+        });
+        entries.push(`${JSON.stringify(routeId)}: [${loaders.join(", ")}]`);
+    }
+    return {
+        declarations,
+        objectLiteral: `{${entries.join(", ")}}`,
+    };
+};
+const layoutComponentCache = new Map();
+const extractLayoutComponent = (loaded) => {
+    if (loaded && typeof loaded === "object" && "default" in loaded) {
+        const candidate = loaded.default;
+        if (typeof candidate === "function") {
+            return candidate;
+        }
+    }
+    if (typeof loaded === "function") {
+        return loaded;
+    }
+    return null;
+};
+const loadLayoutComponent = async (layoutFile, options) => {
+    const modulePath = resolveLayoutModulePath(layoutFile, options.rootDir, options.routeRoot);
+    const cacheKey = `${options.routeRoot ?? ""}::${modulePath}`;
+    if (layoutComponentCache.has(cacheKey)) {
+        return layoutComponentCache.get(cacheKey);
+    }
+    try {
+        const moduleUrl = toFileUrl(modulePath);
+        const loaded = await import(moduleUrl);
+        const component = extractLayoutComponent(loaded);
+        layoutComponentCache.set(cacheKey, component);
+        return component;
+    }
+    catch {
+        try {
+            const require = createRequire(import.meta.url);
+            const loaded = require(modulePath);
+            const component = extractLayoutComponent(loaded);
+            layoutComponentCache.set(cacheKey, component);
+            return component;
+        }
+        catch {
+            return null;
+        }
+    }
+};
+const resolveLayoutComponentsForRender = async (routeId, options) => {
+    if (!resolveNestedLayoutsEnabled(options)) {
+        return [];
+    }
+    const layoutFiles = resolveLayoutFilesForRoute(options.routeGraph, routeId);
+    if (layoutFiles.length === 0) {
+        return [];
+    }
+    const components = await Promise.all(layoutFiles.map((layoutFile) => loadLayoutComponent(layoutFile, options)));
+    return components.filter((component) => Boolean(component));
+};
+const applyLayoutsToElement = (element, props, layouts) => {
+    let tree = element;
+    for (let index = layouts.length - 1; index >= 0; index -= 1) {
+        const Layout = layouts[index];
+        if (typeof Layout === "function") {
+            const LayoutComponent = Layout;
+            tree = React.createElement(LayoutComponent, { ...props, children: tree });
+        }
+    }
+    return tree;
+};
+const buildClientRouteModuleLoaderSource = (modules) => {
+    const declarations = [];
+    const entries = [];
+    let index = 0;
+    for (const [routeId, specifier] of Object.entries(modules).sort(([a], [b]) => a.localeCompare(b))) {
+        const loaderName = `loadClientRouteModule${index++}`;
+        declarations.push(`const ${loaderName} = () => import(${JSON.stringify(specifier)});`);
+        entries.push(`${JSON.stringify(routeId)}: ${loaderName}`);
+    }
+    return {
+        declarations,
+        objectLiteral: `{${entries.join(", ")}}`,
+    };
+};
+const defaultClientEntry = (ctx) => {
+    const pageImport = resolvePageImport(ctx);
+    const hydrationMode = JSON.stringify(resolveHydrationMode(ctx));
+    const navigationMode = JSON.stringify(resolveNavigationMode(ctx));
+    const clientRenderMode = JSON.stringify(resolveClientRenderMode(ctx));
+    const routeGraph = JSON.stringify(ctx.routeGraph ?? { routes: [] });
+    const entryRouteId = JSON.stringify(typeof ctx.routeId === "string" ? ctx.routeId : "");
+    const routeModules = resolveClientRouteModules(ctx);
+    const routeModuleLoaders = buildClientRouteModuleLoaderSource(routeModules);
+    const adapterOptions = (ctx.uiOptions ?? ctx.adapterOptions);
+    const nestedLayoutsEnabled = resolveNestedLayoutsEnabled(adapterOptions);
+    const routeLayoutModules = nestedLayoutsEnabled && ctx.routeGraph
+        ? ctx.routeGraph.routes.reduce((acc, route) => {
+            acc[route.id] = resolveLayoutSpecifiersForRoute(ctx, route.id);
+            return acc;
+        }, {})
+        : {};
+    const routeLayoutLoaders = buildClientRouteLayoutLoaderSource(routeLayoutModules);
+    const entryLayoutSpecifiers = nestedLayoutsEnabled && typeof ctx.routeId === "string"
+        ? resolveLayoutSpecifiersForRoute(ctx, ctx.routeId)
+        : [];
+    const entryLayoutImports = entryLayoutSpecifiers.map((specifier, index) => `import EntryLayout${index} from ${JSON.stringify(specifier)};`);
+    const entryLayoutRefs = entryLayoutSpecifiers.map((_specifier, index) => `EntryLayout${index}`);
+    const entryLayoutArray = entryLayoutRefs.length > 0 ? `[${entryLayoutRefs.join(", ")}]` : "[]";
+    return [
+        "import React from \"react\";",
+        "import { createRoot, hydrateRoot } from \"react-dom/client\";",
+        "import {",
+        "  RouterProvider,",
+        "  createClientRouteModuleResolver,",
+        "  createRouter,",
+        "  installRouterIslands,",
+        "} from \"@tyndall/react\";",
+        `import Page from ${pageImport};`,
+        ...entryLayoutImports,
+        ...routeModuleLoaders.declarations,
+        ...routeLayoutLoaders.declarations,
+        "const ROUTE_PAYLOAD_EVENT = \"hyper:route-payload-applied\";",
+        "const HYDRATED_EVENT = \"hyper:hydrated\";",
+        "const container = document.getElementById(\"app\");",
+        "const readPropsPayload = () => {",
+        "  const propsEl = document.getElementById(\"__HYPER_PROPS__\");",
+        "  if (!propsEl?.textContent) {",
+        "    return {};",
+        "  }",
+        "  try {",
+        "    return JSON.parse(propsEl.textContent);",
+        "  } catch {",
+        "    return {};",
+        "  }",
+        "};",
+        "let props = readPropsPayload();",
+        `const entryRouteId = ${entryRouteId};`,
+        "const runtimeModuleUrl = (() => {",
+        "  try {",
+        "    return new URL(import.meta.url).pathname;",
+        "  } catch {",
+        "    return \"\";",
+        "  }",
+        "})();",
+        "const previousRuntimeModuleUrl = typeof window.__HYPER_CLIENT_RUNTIME_MODULE_URL__ === \"string\"",
+        "  ? window.__HYPER_CLIENT_RUNTIME_MODULE_URL__",
+        "  : \"\";",
+        "const runtimeGenerationChanged =",
+        "  previousRuntimeModuleUrl.length > 0 && previousRuntimeModuleUrl !== runtimeModuleUrl;",
+        "if (runtimeGenerationChanged) {",
+        "  // Prevent mixed React dispatchers across runtime generations during HMR.",
+        "  const disposeRuntime = window.__HYPER_CLIENT_RUNTIME_DISPOSE__;",
+        "  if (typeof disposeRuntime === \"function\") {",
+        "    disposeRuntime(\"generation-change\");",
+        "  }",
+        "}",
+        "window.__HYPER_CLIENT_RUNTIME_MODULE_URL__ = runtimeModuleUrl;",
+        "let runtimeAlreadyInitialized = window.__HYPER_CLIENT_RUNTIME_READY__ === true;",
+        `const routeGraph = ${routeGraph};`,
+        `const navigationMode = ${navigationMode};`,
+        `const clientRenderMode = ${clientRenderMode};`,
+        `let routeModuleLoaders = ${routeModuleLoaders.objectLiteral};`,
+        "window.__HYPER_CLIENT_ROUTE_MODULES__ = routeModuleLoaders;",
+        `let routeLayoutLoaders = ${routeLayoutLoaders.objectLiteral};`,
+        "window.__HYPER_CLIENT_ROUTE_LAYOUTS__ = routeLayoutLoaders;",
+        "const routeModuleResolver =",
+        "  Object.keys(routeModuleLoaders).length > 0",
+        "    ? createClientRouteModuleResolver(routeModuleLoaders)",
+        "    : undefined;",
+        "const router = runtimeAlreadyInitialized && window.__HYPER_CLIENT_RUNTIME_ROUTER__",
+        "  ? window.__HYPER_CLIENT_RUNTIME_ROUTER__",
+        "  : createRouter(window.location.href, {",
+        "      routeGraph,",
+        "      navigationMode,",
+        "      clientRenderMode,",
+        "      resolveClientRouteModule: routeModuleResolver,",
+        "    });",
+        "if (!runtimeAlreadyInitialized) {",
+        "  installRouterIslands(router);",
+        "  window.__HYPER_CLIENT_RUNTIME_ROUTER__ = router;",
+        "}",
+        `const configuredHydration = ${hydrationMode};`,
+        "const documentHydration = container?.getAttribute(\"data-hyper-hydration\");",
+        "const hydration = documentHydration === \"islands\" ? \"islands\" : configuredHydration;",
+        "if (container && hydration !== \"islands\") {",
+        "  container.setAttribute(\"data-hyper-hydrated\", \"false\");",
+        "}",
+        "if (!runtimeAlreadyInitialized) {",
+        "  window.__HYPER_HYDRATED__ = false;",
+        "  window.__HYPER_CLIENT_APP_MOUNTED__ = false;",
+        "}",
+        "let activePage = Page;",
+        "let routeEntryPages = {};",
+        "if (entryRouteId) {",
+        "  routeEntryPages[entryRouteId] = Page;",
+        "}",
+        "let routeEntryLayouts = {};",
+        "if (entryRouteId) {",
+        `  routeEntryLayouts[entryRouteId] = ${entryLayoutArray};`,
+        "}",
+        "let activeLayouts = routeEntryLayouts[entryRouteId] ?? [];",
+        "let activeProps = props;",
+        "let root = null;",
+        "const runtimeDisposers = [];",
+        "const registerRuntimeDisposer = (dispose) => {",
+        "  if (typeof dispose === \"function\") {",
+        "    runtimeDisposers.push(dispose);",
+        "  }",
+        "};",
+        "const addRuntimeListener = (target, eventName, listener) => {",
+        "  target.addEventListener(eventName, listener);",
+        "  registerRuntimeDisposer(() => {",
+        "    target.removeEventListener(eventName, listener);",
+        "  });",
+        "};",
+        "const markHydrated = () => {",
+        "  if (!container || hydration === \"islands\") {",
+        "    return;",
+        "  }",
+        "  container.setAttribute(\"data-hyper-hydrated\", \"true\");",
+        "  window.__HYPER_HYDRATED__ = true;",
+        "  const routeId = typeof window.__HYPER_ROUTE_ID__ === \"string\"",
+        "    ? window.__HYPER_ROUTE_ID__",
+        "    : container.getAttribute(\"data-hyper-route\");",
+        "  window.dispatchEvent(new CustomEvent(HYDRATED_EVENT, { detail: { routeId } }));",
+        "};",
+        "const applyLayouts = (PageComponent, props, layouts) => {",
+        "  let tree = React.createElement(PageComponent, props);",
+        "  if (Array.isArray(layouts)) {",
+        "    for (let i = layouts.length - 1; i >= 0; i -= 1) {",
+        "      const Layout = layouts[i];",
+        "      if (typeof Layout === \"function\") {",
+        "        tree = React.createElement(Layout, { ...props, children: tree });",
+        "      }",
+        "    }",
+        "  }",
+        "  return tree;",
+        "};",
+        "const renderActivePage = (hydrate = false) => {",
+        "  if (!container || hydration === \"islands\") {",
+        "    return;",
+        "  }",
+        "  const element = React.createElement(",
+        "    RouterProvider,",
+        "    { router, children: applyLayouts(activePage, activeProps, activeLayouts) }",
+        "  );",
+        "  if (root && typeof root.render === \"function\") {",
+        "    window.__HYPER_CLIENT_APP_MOUNTED__ = true;",
+        "    root.render(element);",
+        "    markHydrated();",
+        "    return;",
+        "  }",
+        "  if (hydrate && container.hasChildNodes()) {",
+        "    root = hydrateRoot(container, element);",
+        "    window.__HYPER_CLIENT_APP_MOUNTED__ = true;",
+        "    markHydrated();",
+        "    return;",
+        "  }",
+        "  root = createRoot(container);",
+        "  window.__HYPER_CLIENT_APP_MOUNTED__ = true;",
+        "  root.render(element);",
+        "  markHydrated();",
+        "};",
+        "const resolvePageComponent = async (routeId) => {",
+        "  const load = routeModuleLoaders[routeId];",
+        "  if (typeof load !== \"function\") {",
+        "    return routeEntryPages[routeId] ?? null;",
+        "  }",
+        "  try {",
+        "    const loaded = await load();",
+        "    if (loaded && typeof loaded === \"object\" && typeof loaded.default === \"function\") {",
+        "      return loaded.default;",
+        "    }",
+        "    if (typeof loaded === \"function\") {",
+        "      return loaded;",
+        "    }",
+        "  } catch {",
+        "    return routeEntryPages[routeId] ?? null;",
+        "  }",
+        "  return routeEntryPages[routeId] ?? null;",
+        "};",
+        "const resolveLayoutComponents = async (routeId) => {",
+        "  const cached = routeEntryLayouts[routeId];",
+        "  if (Array.isArray(cached) && cached.length > 0) {",
+        "    return cached;",
+        "  }",
+        "  const loaders = routeLayoutLoaders[routeId];",
+        "  if (!Array.isArray(loaders) || loaders.length === 0) {",
+        "    return [];",
+        "  }",
+        "  const modules = await Promise.all(",
+        "    loaders.map((load) => {",
+        "      if (typeof load !== \"function\") {",
+        "        return null;",
+        "      }",
+        "      return load().catch(() => null);",
+        "    })",
+        "  );",
+        "  return modules",
+        "    .map((loaded) => {",
+        "      if (loaded && typeof loaded === \"object\" && typeof loaded.default === \"function\") {",
+        "        return loaded.default;",
+        "      }",
+        "      if (typeof loaded === \"function\") {",
+        "        return loaded;",
+        "      }",
+        "      return null;",
+        "    })",
+        "    .filter(Boolean);",
+        "};",
+        "let routeRenderVersion = 0;",
+        "const rerenderRoute = async (routeId) => {",
+        "  if (!routeId || typeof routeId !== \"string\") {",
+        "    return;",
+        "  }",
+        "  const version = ++routeRenderVersion;",
+        "  const nextPage = await resolvePageComponent(routeId);",
+        "  const nextLayouts = await resolveLayoutComponents(routeId);",
+        "  if (!nextPage || version !== routeRenderVersion) {",
+        "    return;",
+        "  }",
+        "  activePage = nextPage;",
+        "  activeLayouts = nextLayouts;",
+        "  activeProps = readPropsPayload();",
+        "  renderActivePage(false);",
+        "};",
+        "const applyRuntimeUpdate = (next) => {",
+        "  if (!next || typeof next !== \"object\") {",
+        "    return;",
+        "  }",
+        "  if (next.routeModuleLoaders && typeof next.routeModuleLoaders === \"object\") {",
+        "    routeModuleLoaders = next.routeModuleLoaders;",
+        "    window.__HYPER_CLIENT_ROUTE_MODULES__ = routeModuleLoaders;",
+        "  }",
+        "  if (next.routeLayoutLoaders && typeof next.routeLayoutLoaders === \"object\") {",
+        "    routeLayoutLoaders = next.routeLayoutLoaders;",
+        "    window.__HYPER_CLIENT_ROUTE_LAYOUTS__ = routeLayoutLoaders;",
+        "  }",
+        "  if (next.entryRouteId && typeof next.entryRouteId === \"string\" && typeof next.page === \"function\") {",
+        "    routeEntryPages[next.entryRouteId] = next.page;",
+        "  }",
+        "  if (next.entryRouteId && Array.isArray(next.entryLayouts)) {",
+        "    routeEntryLayouts[next.entryRouteId] = next.entryLayouts;",
+        "  }",
+        "};",
+        "if (runtimeAlreadyInitialized) {",
+        "  const updateRuntime = window.__HYPER_CLIENT_RUNTIME_UPDATE__;",
+        "  if (typeof updateRuntime === \"function\") {",
+        "    updateRuntime({",
+        "      entryRouteId,",
+        "      page: Page,",
+        "      routeModuleLoaders,",
+        "      routeLayoutLoaders,",
+        "      entryLayouts: routeEntryLayouts[entryRouteId] ?? [],",
+        "    });",
+        "  }",
+        "}",
+        "const deferRouteSync = (callback) => {",
+        "  if (typeof queueMicrotask === \"function\") {",
+        "    queueMicrotask(callback);",
+        "    return;",
+        "  }",
+        "  setTimeout(callback, 0);",
+        "};",
+        "const syncRouteFromDom = () => {",
+        "  const routeId = typeof window.__HYPER_ROUTE_ID__ === \"string\"",
+        "    ? window.__HYPER_ROUTE_ID__",
+        "    : container?.getAttribute(\"data-hyper-route\");",
+        "  void rerenderRoute(routeId);",
+        "};",
+        "const patchHistoryForRouteSync = () => {",
+        "  if (window.__HYPER_CLIENT_HISTORY_PATCHED__ === true) {",
+        "    return;",
+        "  }",
+        "  const history = window.history;",
+        "  if (!history) {",
+        "    return;",
+        "  }",
+        "  const wrap = (method) => {",
+        "    const original = history[method];",
+        "    if (typeof original !== \"function\") {",
+        "      return;",
+        "    }",
+        "    try {",
+        "      history[method] = (...args) => {",
+        "        const value = original.apply(history, args);",
+        "        const sync = window.__HYPER_CLIENT_RUNTIME_SYNC_ROUTE__;",
+        "        if (typeof sync === \"function\") {",
+        "          deferRouteSync(() => {",
+        "            sync();",
+        "          });",
+        "        }",
+        "        return value;",
+        "      };",
+        "    } catch {",
+        "      // Ignore environments where History methods are not writable.",
+        "    }",
+        "  };",
+        "  wrap(\"pushState\");",
+        "  wrap(\"replaceState\");",
+        "  window.__HYPER_CLIENT_HISTORY_PATCHED__ = true;",
+        "};",
+        "const disposeRuntime = () => {",
+        "  while (runtimeDisposers.length > 0) {",
+        "    const dispose = runtimeDisposers.pop();",
+        "    if (typeof dispose === \"function\") {",
+        "      try {",
+        "        dispose();",
+        "      } catch {",
+        "        // Keep runtime disposal resilient for repeated HMR updates.",
+        "      }",
+        "    }",
+        "  }",
+        "  if (root && typeof root.unmount === \"function\") {",
+        "    try {",
+        "      root.unmount();",
+        "    } catch {",
+        "      // Ignore unmount failures during runtime replacement.",
+        "    }",
+        "  }",
+        "  root = null;",
+        "  window.__HYPER_CLIENT_RUNTIME_READY__ = false;",
+        "  window.__HYPER_CLIENT_RUNTIME_ROUTER__ = undefined;",
+        "  window.__HYPER_CLIENT_RUNTIME_UPDATE__ = undefined;",
+        "  window.__HYPER_CLIENT_RUNTIME_RERENDER__ = undefined;",
+        "  window.__HYPER_CLIENT_RUNTIME_SYNC_ROUTE__ = undefined;",
+        "  window.__HYPER_CLIENT_RUNTIME_DISPOSE__ = undefined;",
+        "  window.__HYPER_CLIENT_APP_MOUNTED__ = false;",
+        "  window.__HYPER_HYDRATED__ = false;",
+        "  if (container && hydration !== \"islands\") {",
+        "    container.setAttribute(\"data-hyper-hydrated\", \"false\");",
+        "  }",
+        "};",
+        "if (container && hydration !== \"islands\" && !runtimeAlreadyInitialized) {",
+        "  const onRoutePayloadApplied = (event) => {",
+        "    const detail = event && typeof event === \"object\" && \"detail\" in event",
+        "      ? event.detail",
+        "      : undefined;",
+        "    const routeId = detail && typeof detail === \"object\" && \"routeId\" in detail",
+        "      ? detail.routeId",
+        "      : window.__HYPER_ROUTE_ID__;",
+        "    void rerenderRoute(routeId);",
+        "  };",
+        "  const onPopState = () => {",
+        "    deferRouteSync(syncRouteFromDom);",
+        "  };",
+        "  window.__HYPER_CLIENT_RUNTIME_UPDATE__ = applyRuntimeUpdate;",
+        "  window.__HYPER_CLIENT_RUNTIME_RERENDER__ = (routeId) => {",
+        "    void rerenderRoute(routeId);",
+        "  };",
+        "  window.__HYPER_CLIENT_RUNTIME_SYNC_ROUTE__ = syncRouteFromDom;",
+        "  window.__HYPER_CLIENT_RUNTIME_DISPOSE__ = () => {",
+        "    disposeRuntime();",
+        "  };",
+        "  window.__HYPER_CLIENT_RUNTIME_READY__ = true;",
+        "  patchHistoryForRouteSync();",
+        "  renderActivePage(true);",
+        "  addRuntimeListener(window, ROUTE_PAYLOAD_EVENT, onRoutePayloadApplied);",
+        "  addRuntimeListener(window, \"popstate\", onPopState);",
+        "} else if (runtimeAlreadyInitialized) {",
+        "  const rerenderRuntime = window.__HYPER_CLIENT_RUNTIME_RERENDER__;",
+        "  if (typeof rerenderRuntime === \"function\") {",
+        "    const routeId = typeof window.__HYPER_ROUTE_ID__ === \"string\"",
+        "      ? window.__HYPER_ROUTE_ID__",
+        "      : container?.getAttribute(\"data-hyper-route\");",
+        "    rerenderRuntime(routeId);",
+        "  }",
+        "}",
+    ].join("\n");
+};
+const defaultServerEntry = (ctx) => {
+    const pageImport = resolvePageImport(ctx);
+    const hydrationMode = JSON.stringify(resolveHydrationMode(ctx));
+    const adapterOptions = (ctx.uiOptions ?? ctx.adapterOptions);
+    const nestedLayoutsEnabled = resolveNestedLayoutsEnabled(adapterOptions);
+    const layoutSpecifiers = nestedLayoutsEnabled && typeof ctx.routeId === "string"
+        ? resolveLayoutSpecifiersForRoute(ctx, ctx.routeId)
+        : [];
+    const layoutImports = layoutSpecifiers.map((specifier, index) => `import Layout${index} from ${JSON.stringify(specifier)};`);
+    const layoutRefs = layoutSpecifiers.map((_specifier, index) => `Layout${index}`);
+    const layoutArray = layoutRefs.length > 0 ? `[${layoutRefs.join(", ")}]` : "[]";
+    return [
+        "import React from \"react\";",
+        "import { renderToString, renderToPipeableStream } from \"react-dom/server\";",
+        "import { PassThrough } from \"stream\";",
+        "import { collectHeadFromTree } from \"@tyndall/react\";",
+        `import Page from ${pageImport};`,
+        ...layoutImports,
+        `export const hydration = ${hydrationMode};`,
+        "export const renderToHtml = async (ctx) => {",
+        "  let element = React.createElement(Page, ctx.props);",
+        `  const layouts = ${layoutArray};`,
+        "  if (Array.isArray(layouts) && layouts.length > 0) {",
+        "    for (let i = layouts.length - 1; i >= 0; i -= 1) {",
+        "      const Layout = layouts[i];",
+        "      if (typeof Layout === \"function\") {",
+        "        element = React.createElement(Layout, { ...ctx.props, children: element });",
+        "      }",
+        "    }",
+        "  }",
+        "  const html = renderToString(element);",
+        "  const head = collectHeadFromTree(element);",
+        "  return { html, head };",
+        "};",
+        "export const renderToStream = async (ctx) => {",
+        "  if (typeof renderToPipeableStream !== \"function\") {",
+        "    return null;",
+        "  }",
+        "  let element = React.createElement(Page, ctx.props);",
+        `  const layouts = ${layoutArray};`,
+        "  if (Array.isArray(layouts) && layouts.length > 0) {",
+        "    for (let i = layouts.length - 1; i >= 0; i -= 1) {",
+        "      const Layout = layouts[i];",
+        "      if (typeof Layout === \"function\") {",
+        "        element = React.createElement(Layout, { ...ctx.props, children: element });",
+        "      }",
+        "    }",
+        "  }",
+        "  const head = collectHeadFromTree(element);",
+        "  return await new Promise((resolve, reject) => {",
+        "    let didError = false;",
+        "    const stream = new PassThrough();",
+        "    const { pipe, abort } = renderToPipeableStream(element, {",
+        "      onShellReady() {",
+        "        pipe(stream);",
+        "        resolve({ stream, head, abort });",
+        "      },",
+        "      onShellError(error) {",
+        "        reject(error);",
+        "      },",
+        "      onError() {",
+        "        didError = true;",
+        "      },",
+        "    });",
+        "    if (didError) {",
+        "      abort();",
+        "    }",
+        "  });",
+        "};",
+    ].join("\n");
+};
+const defaultRenderToHtml = async (ctx, options) => {
+    if (!options.render) {
+        return { html: `<div data-hyper-react=\"true\">${ctx.routeId}</div>` };
+    }
+    const element = await options.render(ctx);
+    const layouts = await resolveLayoutComponentsForRender(ctx.routeId, options);
+    const composed = layouts.length > 0 ? applyLayoutsToElement(element, ctx.props, layouts) : element;
+    const html = await renderWithFallback(composed);
+    const collected = collectHeadFromTree(composed);
+    const provided = options.getHead?.(ctx);
+    const head = mergeHeadDescriptors(provided ?? {}, collected);
+    return { html, head };
+};
+export const createReactAdapter = (options = {}) => ({
+    name: options.name ?? "react",
+    createClientEntry: options.createClientEntry ?? defaultClientEntry,
+    createServerEntry: options.createServerEntry ?? defaultServerEntry,
+    renderToHtml: options.renderToHtml ?? ((ctx) => defaultRenderToHtml(ctx, options)),
+    serializeProps,
+    getHead: options.getHead,
+    hmrIntegration: options.hmrIntegration,
+});