@tyndall/build 0.0.1

package/dist/build.js

@@ -0,0 +1,925 @@
+import { copyFile, mkdir, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createRouteGraph, loadConfig, renderClientRouterBootstrap, resolvePageModule, resolveUIAdapter, serializeProps, } from "@tyndall/core";
+import { buildModuleGraphSnapshot, computeGraphKey, computeCacheRootKey, getBunVersion, getOsArch, hash, normalizePath, readFileSafe, readModuleGraphCache, resolveCacheRoot, stableStringify, writeModuleGraphCache, } from "@tyndall/shared";
+import { bundleClient, bundleServer, } from "./bundler.js";
+import { build as esbuild } from "esbuild";
+import { transform } from "@swc/core";
+import { computeDepsHashByEntry, readChunkCache, writeChunkCache, } from "./chunk-cache.js";
+import { computePropsHash, computePropsKey, computeRenderKey, readPropsCache, readRenderCache, writePropsCache, writeRenderCache, } from "./ssg-cache.js";
+import { updateCacheIndex } from "./cache-gc.js";
+import { collectStaticData } from "./ssg-data.js";
+import { computeTemplateHash, defaultHtmlTemplate, renderHtml } from "./renderer.js";
+import { generateManifest } from "./manifest.js";
+import { copyPublicDir } from "./emit.js";
+import { runBuildPipeline } from "./pipeline.js";
+const resolvePath = (root, value) => (isAbsolute(value) ? value : join(root, value));
+const normalizeCacheOptions = (rootDir, cache, configCache) => {
+    const enabled = cache?.enabled ?? configCache?.enabled ?? true;
+    const dir = resolvePath(rootDir, cache?.dir ?? configCache?.dir ?? join(".hyper", "cache"));
+    return {
+        enabled,
+        dir,
+        maxSizeMB: cache?.maxSizeMB ?? configCache?.maxSizeMB,
+        maxAgeDays: cache?.maxAgeDays ?? configCache?.maxAgeDays,
+        propsTTLSeconds: cache?.propsTTLSeconds ?? configCache?.propsTTLSeconds ?? false,
+        renderCache: cache?.renderCache ?? configCache?.renderCache ?? true,
+        chunkCache: cache?.chunkCache ?? configCache?.chunkCache ?? true,
+    };
+};
+const readFileHash = async (filePath) => {
+    const content = await readFileSafe(filePath);
+    if (!content) {
+        return null;
+    }
+    return hash(content instanceof Uint8Array ? content : content);
+};
+const resolveGraphKey = async (rootDir, bundlerOptions) => {
+    const lockfileHash = (await readFileHash(join(rootDir, "bun.lock"))) ??
+        (await readFileHash(join(rootDir, "bun.lockb"))) ??
+        (await readFileHash(join(rootDir, "package-lock.json"))) ??
+        "missing";
+    const tsconfigHash = (await readFileHash(join(rootDir, "tsconfig.json"))) ??
+        (await readFileHash(join(rootDir, "tsconfig.base.json"))) ??
+        "missing";
+    const bundlerOptionsHash = hash(stableStringify(bundlerOptions));
+    return computeGraphKey({ lockfileHash, tsconfigHash, bundlerOptionsHash });
+};
+const resolveHyperVersion = async (rootDir) => {
+    const packagePath = join(rootDir, "packages", "tyndall-core", "package.json");
+    const raw = await readFileSafe(packagePath, "utf-8");
+    const content = raw ? raw.toString() : null;
+    if (!content) {
+        return "unknown";
+    }
+    try {
+        const parsed = JSON.parse(content);
+        return parsed.version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+};
+const isStaticRoute = (route) => route.segments.every((segment) => segment.type === "static");
+const isDynamicRoute = (route) => route.segments.some((segment) => segment.type === "dynamic" || segment.type === "catchAll");
+const routeIdToPath = (routeId, params) => {
+    if (routeId === "/") {
+        return "";
+    }
+    const segments = routeId
+        .split("/")
+        .filter(Boolean)
+        .map((segment) => {
+        if (segment.startsWith(":")) {
+            const value = params?.[segment.slice(1)];
+            return Array.isArray(value) ? value.join("/") : String(value ?? "");
+        }
+        if (segment.startsWith("*")) {
+            const value = params?.[segment.slice(1)];
+            return Array.isArray(value) ? value.join("/") : String(value ?? "");
+        }
+        return segment;
+    });
+    return segments.join("/");
+};
+const writeFileSafe = async (filePath, contents) => {
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, contents, "utf-8");
+};
+const toPosixPath = (value) => value.split(sep).join("/");
+const toImportSpecifier = (fromDir, targetPath) => {
+    const relativePath = toPosixPath(relative(fromDir, targetPath));
+    if (relativePath.startsWith("../") || relativePath === "..") {
+        return relativePath;
+    }
+    return relativePath.startsWith("./") ? relativePath : `./${relativePath}`;
+};
+const normalizePathSegment = (value) => value.replace(/^\/+|\/+$/g, "");
+const resolveAssetUrl = (basePath, assetsDir, file) => {
+    const base = normalizePathSegment(basePath);
+    const assets = normalizePathSegment(assetsDir);
+    const prefix = [base, assets].filter(Boolean).join("/");
+    const fileName = file.replace(/^\/+/, "");
+    return `/${prefix ? `${prefix}/` : ""}${fileName}`;
+};
+const isExternalUrl = (value) => value.startsWith("http://") || value.startsWith("https://") || value.startsWith("//");
+const appendBuildVersion = (value, buildVersion) => {
+    if (!buildVersion) {
+        return value;
+    }
+    if (isExternalUrl(value)) {
+        return value;
+    }
+    const separator = value.includes("?") ? "&" : "?";
+    return `${value}${separator}v=${encodeURIComponent(buildVersion)}`;
+};
+const resolveBundleScripts = (bundle, routeId, basePath, assetsDir, buildVersion) => {
+    const entryKey = bundle.entryChunks[routeId];
+    if (!entryKey) {
+        return [];
+    }
+    const scripts = [];
+    const visited = new Set();
+    const walk = (key) => {
+        if (visited.has(key)) {
+            return;
+        }
+        visited.add(key);
+        const chunk = bundle.chunks[key];
+        if (!chunk) {
+            return;
+        }
+        for (const dep of chunk.imports ?? []) {
+            walk(dep);
+        }
+        scripts.push(appendBuildVersion(resolveAssetUrl(basePath, assetsDir, chunk.file), buildVersion));
+    };
+    walk(entryKey);
+    return scripts;
+};
+const LEGACY_AUTO_POLYFILLS_FILE = "hyper-legacy-polyfills.js";
+const renderLegacyClientBootstrap = () => [
+    "(function () {",
+    "  if (typeof window === \"undefined\") { return; }",
+    "  if (window.__HYPER_LEGACY_BOOTSTRAP__) { return; }",
+    "  window.__HYPER_LEGACY_BOOTSTRAP__ = true;",
+    "  var doc = window.document;",
+    "  if (!doc || !doc.addEventListener) { return; }",
+    "  var findAnchor = function (node) {",
+    "    while (node && node.nodeType === 1) {",
+    "      if (node.tagName && node.tagName.toLowerCase() === \"a\") {",
+    "        return node;",
+    "      }",
+    "      node = node.parentNode;",
+    "    }",
+    "    return null;",
+    "  };",
+    "  doc.addEventListener(\"click\", function (event) {",
+    "    event = event || window.event;",
+    "    var anchor = findAnchor(event.target || event.srcElement);",
+    "    if (!anchor) { return; }",
+    "    if (anchor.getAttribute(\"data-hyper-link\") === \"false\") { return; }",
+    "    if (!anchor.getAttribute(\"data-hyper-link\")) { return; }",
+    "    if (anchor.getAttribute(\"target\") || anchor.getAttribute(\"download\")) { return; }",
+    "    var href = anchor.getAttribute(\"href\");",
+    "    if (!href || href.indexOf(\"#\") === 0) { return; }",
+    "    if (event.preventDefault) {",
+    "      event.preventDefault();",
+    "    } else {",
+    "      event.returnValue = false;",
+    "    }",
+    "    window.location.href = href;",
+    "  }, true);",
+    "})();",
+    "",
+].join("\n");
+const renderLegacyAutoPolyfillsChunk = () => [
+    "(function () {",
+    "  if (!Array.isArray) {",
+    "    Array.isArray = function (arg) {",
+    "      return Object.prototype.toString.call(arg) === \"[object Array]\";",
+    "    };",
+    "  }",
+    "  if (!Object.assign) {",
+    "    Object.assign = function (target) {",
+    "      if (target === null || target === undefined) {",
+    "        throw new TypeError(\"Cannot convert undefined or null to object\");",
+    "      }",
+    "      var to = Object(target);",
+    "      for (var index = 1; index < arguments.length; index += 1) {",
+    "        var nextSource = arguments[index];",
+    "        if (nextSource !== null && nextSource !== undefined) {",
+    "          for (var key in nextSource) {",
+    "            if (Object.prototype.hasOwnProperty.call(nextSource, key)) {",
+    "              to[key] = nextSource[key];",
+    "            }",
+    "          }",
+    "        }",
+    "      }",
+    "      return to;",
+    "    };",
+    "  }",
+    "})();",
+    "",
+].join("\n");
+const resolveConfiguredScriptUrl = (basePath, script) => {
+    if (isExternalUrl(script)) {
+        return script;
+    }
+    const base = normalizePathSegment(basePath);
+    const cleaned = script.replace(/^\/+/, "");
+    return `/${base ? `${base}/` : ""}${cleaned}`;
+};
+const resolveLegacyPolyfillPlan = (basePath, assetsDir, polyfills) => {
+    if (polyfills === "auto") {
+        return {
+            scripts: [resolveAssetUrl(basePath, assetsDir, LEGACY_AUTO_POLYFILLS_FILE)],
+            autoPolyfillsFile: LEGACY_AUTO_POLYFILLS_FILE,
+            autoPolyfillsChunk: renderLegacyAutoPolyfillsChunk(),
+        };
+    }
+    const scripts = polyfills
+        .filter((entry) => entry.trim().length > 0)
+        .map((entry) => resolveConfiguredScriptUrl(basePath, entry));
+    return { scripts };
+};
+const getBunBuildApi = () => {
+    const runtime = globalThis;
+    if (!runtime.Bun || typeof runtime.Bun.build !== "function") {
+        return null;
+    }
+    return { build: runtime.Bun.build };
+};
+let hyperCoreBrowserShimSource = null;
+const resolveCoreShimModulePath = async (entryDir, moduleName) => {
+    const candidates = [
+        `${moduleName}.js`,
+        `${moduleName}.mjs`,
+        `${moduleName}.cjs`,
+        `${moduleName}.ts`,
+        `${moduleName}.tsx`,
+    ];
+    for (const candidate of candidates) {
+        const candidatePath = join(entryDir, candidate);
+        const exists = await stat(candidatePath)
+            .then((result) => result.isFile())
+            .catch(() => false);
+        if (exists) {
+            return candidatePath;
+        }
+    }
+    throw new Error(`Missing core shim module "${moduleName}" in ${entryDir}.`);
+};
+const resolveHyperCoreBrowserShimSource = async () => {
+    if (hyperCoreBrowserShimSource) {
+        return hyperCoreBrowserShimSource;
+    }
+    const resolver = import.meta;
+    if (typeof resolver.resolve !== "function") {
+        throw new Error("import.meta.resolve is unavailable while building browser entries.");
+    }
+    const resolvedEntry = await resolver.resolve("@tyndall/core");
+    const entryPath = resolvedEntry.startsWith("file://")
+        ? fileURLToPath(resolvedEntry)
+        : resolvedEntry;
+    const entryDir = dirname(entryPath);
+    const headPath = await resolveCoreShimModulePath(entryDir, "head");
+    const propsPath = await resolveCoreShimModulePath(entryDir, "props");
+    const renderPolicyPath = await resolveCoreShimModulePath(entryDir, "render-policy");
+    const resolverFallbackPath = await resolveCoreShimModulePath(entryDir, "resolver-fallback");
+    hyperCoreBrowserShimSource = {
+        source: [
+            `export { mergeHeadDescriptors } from ${JSON.stringify(headPath)};`,
+            `export { serializeProps } from ${JSON.stringify(propsPath)};`,
+            `export { evaluateRenderPolicy } from ${JSON.stringify(renderPolicyPath)};`,
+            `export { shouldForceDynamicFallback } from ${JSON.stringify(resolverFallbackPath)};`,
+        ].join("\n"),
+        // Required so esbuild resolves filesystem imports from a virtual namespace.
+        resolveDir: entryDir,
+    };
+    return hyperCoreBrowserShimSource;
+};
+const emitBundleAssets = async (bundle, outDir, assetsDir, chunkSource) => {
+    for (const chunk of Object.values(bundle.chunks)) {
+        const filePath = join(outDir, assetsDir, chunk.file);
+        await writeFileSafe(filePath, chunkSource);
+    }
+};
+const buildChunkFile = async (entryPath, outputPath, options) => {
+    const shimSource = options.shimHyperCore ? await resolveHyperCoreBrowserShimSource() : null;
+    const shimPlugin = shimSource
+        ? {
+            name: "@tyndall/core-browser-shim",
+            setup(build) {
+                build.onResolve({ filter: /^@tyndall\/core$/ }, () => ({
+                    path: "@tyndall/core-browser-shim",
+                    namespace: "@tyndall/core-browser-shim",
+                }));
+                build.onLoad({
+                    filter: /^@tyndall\/core-browser-shim$/,
+                    namespace: "@tyndall/core-browser-shim",
+                }, () => ({
+                    contents: shimSource.source,
+                    loader: "js",
+                    resolveDir: shimSource.resolveDir,
+                }));
+            },
+        }
+        : null;
+    if (options.syntaxTarget === "es5") {
+        try {
+            const bundled = await esbuild({
+                entryPoints: [entryPath],
+                bundle: true,
+                platform: options.target === "node" ? "node" : "browser",
+                format: options.format,
+                target: "es2015",
+                splitting: false,
+                sourcemap: false,
+                minify: false,
+                logLevel: "silent",
+                jsx: "automatic",
+                plugins: shimPlugin ? [shimPlugin] : undefined,
+                write: false,
+            });
+            const outputText = bundled.outputFiles?.[0]?.text;
+            if (!outputText) {
+                throw new Error("ES5 bundling produced no output.");
+            }
+            const transformed = await transform(outputText, {
+                jsc: {
+                    target: "es5",
+                    parser: {
+                        syntax: "ecmascript",
+                    },
+                },
+                sourceMaps: false,
+            });
+            await mkdir(dirname(outputPath), { recursive: true });
+            await writeFile(outputPath, transformed.code, "utf-8");
+        }
+        catch (error) {
+            const messages = typeof error === "object" && error !== null && "errors" in error
+                ? error.errors
+                    ?.map((entry) => entry.text)
+                    .filter((text) => typeof text === "string" && text.length > 0) ?? []
+                : [];
+            throw new Error(`Failed to emit ES5 bundle chunk (${entryPath} -> ${outputPath})${messages.length > 0 ? `: ${messages.join(" | ")}` : "."}`);
+        }
+        return;
+    }
+    const bun = getBunBuildApi();
+    if (!bun) {
+        throw new Error("Bun.build API is unavailable while emitting build chunks.");
+    }
+    const tempOutDir = join(dirname(outputPath), `.@tyndall/build-tmp-${hash(`${outputPath}-${Date.now()}`)}`);
+    await mkdir(tempOutDir, { recursive: true });
+    const result = await bun.build({
+        entrypoints: [entryPath],
+        outdir: tempOutDir,
+        target: options.target,
+        format: options.format,
+        write: true,
+        splitting: false,
+        sourcemap: "none",
+        minify: false,
+        plugins: shimPlugin ? [shimPlugin] : undefined,
+    });
+    if (!result.success) {
+        const errors = (result.logs ?? [])
+            .map((log) => log.message)
+            .filter((message) => typeof message === "string" && message.length > 0);
+        await rm(tempOutDir, { recursive: true, force: true }).catch(() => { });
+        throw new Error(`Failed to emit bundle chunk (${entryPath} -> ${outputPath})${errors.length > 0 ? `: ${errors.join(" | ")}` : "."}`);
+    }
+    const emittedPath = result.outputs
+        ?.map((output) => output.path)
+        .find((path) => typeof path === "string" && path.length > 0);
+    if (!emittedPath) {
+        await rm(tempOutDir, { recursive: true, force: true }).catch(() => { });
+        throw new Error(`Build chunk output is missing (${entryPath}).`);
+    }
+    await mkdir(dirname(outputPath), { recursive: true });
+    await copyFile(emittedPath, outputPath);
+    await rm(tempOutDir, { recursive: true, force: true }).catch(() => { });
+};
+const dynamicImportPattern = /import\s*\(/;
+const findDynamicImportModules = async (modulePaths) => {
+    const offenders = [];
+    for (const modulePath of modulePaths) {
+        const content = await readFileSafe(modulePath);
+        if (!content) {
+            continue;
+        }
+        const source = typeof content === "string" ? content : content.toString("utf-8");
+        if (dynamicImportPattern.test(source)) {
+            offenders.push(modulePath);
+        }
+    }
+    return offenders;
+};
+export const build = async (options) => {
+    const rootDir = options.rootDir;
+    const routesDir = resolvePath(rootDir, options.routesDir ?? join("src", "pages"));
+    const publicDir = resolvePath(rootDir, options.publicDir ?? "public");
+    const outDir = resolvePath(rootDir, options.outDir ?? "dist");
+    const mode = options.mode ?? "ssg";
+    const config = await loadConfig(rootDir);
+    const buildVersion = config.build.version.trim();
+    const adapterRegistry = options.adapterRegistry ?? {};
+    const ssrClientRoutingEnabled = mode === "ssr" && config.routing.ssrClientRouting;
+    const resolvedNavigationMode = ssrClientRoutingEnabled ? "client" : config.routing.navigation;
+    const clientBootstrapChunk = renderClientRouterBootstrap({
+        navigationMode: resolvedNavigationMode,
+        clientRenderMode: config.routing.clientRender,
+        linkInterceptionMode: ssrClientRoutingEnabled ? "all" : "marked",
+    });
+    const legacyBootstrapChunk = renderLegacyClientBootstrap();
+    const legacyEnabled = config.legacy.enabled;
+    const modernTarget = config.target;
+    const isEs5Target = modernTarget === "es5";
+    const clientScriptType = isEs5Target ? "classic" : "module";
+    const serverTarget = "es2018";
+    const assetsDir = config.assetsDir;
+    const legacyPolyfillPlan = legacyEnabled
+        ? resolveLegacyPolyfillPlan(config.basePath, assetsDir, config.legacy.polyfills)
+        : { scripts: [] };
+    const cache = normalizeCacheOptions(rootDir, options.cache, config.cache);
+    const uiAdapter = typeof config.ui.adapter === "string"
+        ? config.ui.adapter
+        : config.ui.adapter?.name ?? "custom";
+    const hyperVersion = cache.enabled ? await resolveHyperVersion(rootDir) : "disabled";
+    const rootKey = cache.enabled
+        ? computeCacheRootKey({
+            projectId: normalizePath(resolve(rootDir)),
+            hyperVersion,
+            bunVersion: getBunVersion(),
+            uiAdapter,
+            osArch: getOsArch(),
+        })
+        : "disabled";
+    // Important: rootKey isolates caches across projects/toolchains/adapters.
+    const cacheRoot = cache.enabled ? resolveCacheRoot(cache.dir, rootKey) : cache.dir;
+    const graphKey = cache.enabled
+        ? await resolveGraphKey(rootDir, {
+            client: { format: "esm", target: modernTarget },
+            server: mode === "ssr" ? { format: "cjs", target: serverTarget } : null,
+        })
+        : null;
+    const envHash = cache.enabled ? hash(stableStringify(process.env)) : "disabled";
+    let depsHashByEntry = null;
+    let legacyBundle = null;
+    const routeModules = new Map();
+    const routeById = new Map();
+    const clientRuntimeEntries = new Map();
+    const serverRuntimeEntries = new Map();
+    const entryWorkspaceRoot = join(cacheRoot, "build-runtime-entries", hash(`${Date.now()}-${Math.random()}`).slice(0, 12));
+    // Important: clear output to avoid stale HTML/chunks when route render policy changes.
+    await rm(outDir, { recursive: true, force: true }).catch(() => { });
+    await mkdir(outDir, { recursive: true });
+    const assertLegacyChunkingSafe = async (snapshot) => {
+        if (!legacyEnabled || config.legacy.chunking !== "safe") {
+            return;
+        }
+        const offenders = await findDynamicImportModules(Object.keys(snapshot.moduleGraph));
+        if (offenders.length > 0) {
+            throw new Error(`Legacy chunking (safe) forbids dynamic import in: ${offenders.slice(0, 3).join(", ")}`);
+        }
+    };
+    const bundleWithCache = async (kind, entries, format, bundler, target) => {
+        const depsHash = depsHashByEntry ?? undefined;
+        const cacheActive = cache.enabled && cache.chunkCache;
+        const cacheOptions = {
+            format,
+            target,
+            define: undefined,
+            depsHashByEntry: depsHash,
+        };
+        if (cacheActive) {
+            const cached = await readChunkCache(cacheRoot, entries, cacheOptions, depsHash);
+            if (cached) {
+                console.info(`[@tyndall/build] chunk cache hit (${kind}, ${entries.length} entries)`);
+                return cached;
+            }
+        }
+        const result = bundler({ entries, target, depsHashByEntry: depsHash, format });
+        if (cacheActive) {
+            await writeChunkCache(cacheRoot, entries, result, depsHash);
+        }
+        return result;
+    };
+    try {
+        const result = await runBuildPipeline({ rootDir, routesDir, outDir, publicDir, cache }, {
+            scanRoutes: () => createRouteGraph({
+                routesDir,
+                routeMeta: config.routing.routeMeta,
+                nestedLayouts: config.routing.nestedLayouts,
+            }),
+            analyzeGraph: async (_ctx, state) => {
+                const routes = state.routeGraph?.routes ?? [];
+                routeById.clear();
+                for (const route of routes) {
+                    routeById.set(route.id, route);
+                }
+                const entries = routes.map((route) => ({ id: route.id, filePath: route.filePath }));
+                if (!cache.enabled || !graphKey) {
+                    const snapshot = buildModuleGraphSnapshot(entries);
+                    await assertLegacyChunkingSafe(snapshot);
+                    depsHashByEntry = cache.enabled ? await computeDepsHashByEntry(snapshot) : null;
+                    return snapshot;
+                }
+                const cached = await readModuleGraphCache(cacheRoot, graphKey);
+                if (cached) {
+                    // Important: cached graph must cover all current routes to be valid.
+                    const hasAllRoutes = entries.every((route) => cached.routeToModules[route.id]);
+                    if (hasAllRoutes) {
+                        await assertLegacyChunkingSafe(cached);
+                        depsHashByEntry = await computeDepsHashByEntry(cached);
+                        return cached;
+                    }
+                }
+                const snapshot = buildModuleGraphSnapshot(entries);
+                await writeModuleGraphCache(cacheRoot, graphKey, snapshot);
+                await assertLegacyChunkingSafe(snapshot);
+                depsHashByEntry = await computeDepsHashByEntry(snapshot);
+                return snapshot;
+            },
+            bundleClient: async (_ctx, state) => {
+                const routeGraph = state.routeGraph;
+                if (!routeGraph) {
+                    return bundleClient({ entries: [] });
+                }
+                const entryAdapter = resolveUIAdapter(config.ui.adapter, {
+                    ...config.ui.options,
+                    navigationMode: resolvedNavigationMode,
+                    clientRenderMode: config.routing.clientRender,
+                }, adapterRegistry);
+                if (typeof entryAdapter.createClientEntry !== "function") {
+                    throw new Error(`UI adapter \"${entryAdapter.name}\" does not support createClientEntry.`);
+                }
+                const clientEntryDir = join(entryWorkspaceRoot, "client");
+                await mkdir(clientEntryDir, { recursive: true });
+                const buildClientRouteModules = routeGraph.routes.reduce((acc, route) => {
+                    acc[route.id] = toImportSpecifier(clientEntryDir, route.filePath);
+                    return acc;
+                }, {});
+                const entries = [];
+                clientRuntimeEntries.clear();
+                for (const route of routeGraph.routes) {
+                    const entryFilePath = join(clientEntryDir, `entry-${hash(route.id).slice(0, 12)}.tsx`);
+                    const pageModule = toImportSpecifier(clientEntryDir, route.filePath);
+                    const entrySource = entryAdapter.createClientEntry({
+                        routeId: route.id,
+                        routeGraph,
+                        basePath: config.basePath,
+                        rootDir,
+                        entryDir: clientEntryDir,
+                        uiOptions: {
+                            ...config.ui.options,
+                            pageModule,
+                            navigationMode: resolvedNavigationMode,
+                            clientRenderMode: config.routing.clientRender,
+                            clientRouteModules: buildClientRouteModules,
+                            nestedLayouts: config.routing.nestedLayouts,
+                        },
+                        adapterOptions: {
+                            ...config.ui.options,
+                            pageModule,
+                            navigationMode: resolvedNavigationMode,
+                            clientRenderMode: config.routing.clientRender,
+                            clientRouteModules: buildClientRouteModules,
+                            nestedLayouts: config.routing.nestedLayouts,
+                        },
+                    });
+                    if (typeof entrySource !== "string" || entrySource.trim().length === 0) {
+                        throw new Error(`Client entry generation failed for route ${route.id}`);
+                    }
+                    await writeFileSafe(entryFilePath, `${entrySource}\n\n${clientBootstrapChunk}\n`);
+                    clientRuntimeEntries.set(route.id, entryFilePath);
+                    entries.push({ id: route.id, input: entryFilePath });
+                }
+                const clientFormat = isEs5Target ? "iife" : "esm";
+                const modernBundle = await bundleWithCache("client", entries, clientFormat, bundleClient, modernTarget);
+                if (legacyEnabled && !isEs5Target) {
+                    legacyBundle = await bundleWithCache("client-legacy", entries, "iife", bundleClient, "es5");
+                }
+                return modernBundle;
+            },
+            bundleServer: mode === "ssr"
+                ? async (_ctx, state) => {
+                    const routeGraph = state.routeGraph;
+                    if (!routeGraph) {
+                        return bundleServer({ entries: [] });
+                    }
+                    const entryAdapter = resolveUIAdapter(config.ui.adapter, {
+                        ...config.ui.options,
+                        navigationMode: resolvedNavigationMode,
+                        clientRenderMode: config.routing.clientRender,
+                    }, adapterRegistry);
+                    if (typeof entryAdapter.createServerEntry !== "function") {
+                        throw new Error(`UI adapter \"${entryAdapter.name}\" does not support createServerEntry.`);
+                    }
+                    const serverEntryDir = join(entryWorkspaceRoot, "server");
+                    await mkdir(serverEntryDir, { recursive: true });
+                    const entries = [];
+                    serverRuntimeEntries.clear();
+                    for (const route of routeGraph.routes) {
+                        const pageModule = toImportSpecifier(serverEntryDir, route.filePath);
+                        const rawEntryFilePath = join(serverEntryDir, `entry-${hash(route.id).slice(0, 12)}.raw.tsx`);
+                        const wrappedEntryFilePath = join(serverEntryDir, `entry-${hash(route.id).slice(0, 12)}.ts`);
+                        const serverEntrySource = entryAdapter.createServerEntry({
+                            routeId: route.id,
+                            routeGraph,
+                            basePath: config.basePath,
+                            rootDir,
+                            entryDir: serverEntryDir,
+                            uiOptions: {
+                                ...config.ui.options,
+                                pageModule,
+                                navigationMode: resolvedNavigationMode,
+                                clientRenderMode: config.routing.clientRender,
+                                nestedLayouts: config.routing.nestedLayouts,
+                            },
+                            adapterOptions: {
+                                ...config.ui.options,
+                                pageModule,
+                                navigationMode: resolvedNavigationMode,
+                                clientRenderMode: config.routing.clientRender,
+                                nestedLayouts: config.routing.nestedLayouts,
+                            },
+                        });
+                        if (typeof serverEntrySource !== "string" || serverEntrySource.trim().length === 0) {
+                            throw new Error(`Server entry generation failed for route ${route.id}`);
+                        }
+                        await writeFileSafe(rawEntryFilePath, serverEntrySource);
+                        const rawSpecifier = toImportSpecifier(serverEntryDir, rawEntryFilePath);
+                        const wrapperSource = [
+                            `import * as pageModule from ${JSON.stringify(pageModule)};`,
+                            `import * as serverEntryModule from ${JSON.stringify(rawSpecifier)};`,
+                            "export const renderToHtml = serverEntryModule.renderToHtml;",
+                            "export const renderToStream = serverEntryModule.renderToStream;",
+                            "export const hydration =",
+                            "  serverEntryModule.hydration === \"full\" || serverEntryModule.hydration === \"islands\"",
+                            "    ? serverEntryModule.hydration",
+                            "    : \"islands\";",
+                            "export const getServerProps =",
+                            "  typeof pageModule.getServerProps === \"function\" ? pageModule.getServerProps : undefined;",
+                            "export const getServerSideProps =",
+                            "  typeof pageModule.getServerSideProps === \"function\" ? pageModule.getServerSideProps : undefined;",
+                            "",
+                        ].join("\n");
+                        await writeFileSafe(wrappedEntryFilePath, wrapperSource);
+                        serverRuntimeEntries.set(route.id, wrappedEntryFilePath);
+                        entries.push({ id: route.id, input: wrappedEntryFilePath });
+                    }
+                    return bundleWithCache("server", entries, "cjs", bundleServer, serverTarget);
+                }
+                : undefined,
+            runStaticData: async (_ctx, state) => {
+                const routeGraph = state.routeGraph;
+                if (!routeGraph) {
+                    return { entries: [] };
+                }
+                routeModules.clear();
+                for (const route of routeGraph.routes) {
+                    const loaded = await import(`${pathToFileURL(route.filePath).href}?build=${Date.now()}-${hash(route.id).slice(0, 6)}`);
+                    routeModules.set(route.id, resolvePageModule(loaded));
+                }
+                const resolveDepsHash = (routeId) => depsHashByEntry?.[routeId] ?? "missing";
+                const propsCacheEnabled = cache.enabled;
+                const staticDataCache = propsCacheEnabled
+                    ? {
+                        read: async (routeId, params, paramsKeyValue) => {
+                            const cached = await readPropsCache(cacheRoot, {
+                                routeId,
+                                paramsKey: paramsKeyValue,
+                                depsHash: resolveDepsHash(routeId),
+                                envHash,
+                            }, cache.propsTTLSeconds);
+                            if (!cached) {
+                                return null;
+                            }
+                            return {
+                                routeId,
+                                params,
+                                paramsKey: paramsKeyValue,
+                                props: cached.props,
+                                revalidate: cached.revalidate,
+                            };
+                        },
+                        write: async (entry) => {
+                            const depsHash = resolveDepsHash(entry.routeId);
+                            const propsKey = computePropsKey({
+                                routeId: entry.routeId,
+                                paramsKey: entry.paramsKey,
+                                depsHash,
+                                envHash,
+                            });
+                            await writePropsCache(cacheRoot, {
+                                routeId: entry.routeId,
+                                paramsKey: entry.paramsKey,
+                                props: entry.props,
+                                revalidate: entry.revalidate,
+                                propsKey,
+                                propsHash: computePropsHash(entry.props),
+                                depsHash,
+                                envHash,
+                                generatedAt: Date.now(),
+                            });
+                        },
+                    }
+                    : undefined;
+                const pageModules = {};
+                for (const route of routeGraph.routes) {
+                    const pageModule = routeModules.get(route.id);
+                    if (!pageModule) {
+                        continue;
+                    }
+                    if (mode === "ssr" && typeof pageModule.getServerProps === "function") {
+                        continue;
+                    }
+                    if (isStaticRoute(route)) {
+                        pageModules[route.id] = pageModule;
+                        continue;
+                    }
+                    if (mode === "ssg" || (isDynamicRoute(route) && typeof pageModule.getStaticPaths === "function")) {
+                        pageModules[route.id] = pageModule;
+                    }
+                }
+                return collectStaticData(routeGraph, pageModules, staticDataCache);
+            },
+            renderHtml: async (_ctx, state) => {
+                if (!state.staticData || typeof state.staticData !== "object") {
+                    return {};
+                }
+                const entries = state.staticData.entries;
+                const renderCacheEnabled = cache.enabled && cache.renderCache;
+                const clientBundle = state.clientBundle;
+                const routeGraph = state.routeGraph;
+                if (!routeGraph) {
+                    return {};
+                }
+                const outputs = {};
+                for (const entry of entries) {
+                    const route = routeById.get(entry.routeId);
+                    const pageModule = routeModules.get(entry.routeId);
+                    if (!route || !pageModule) {
+                        continue;
+                    }
+                    const depsHash = depsHashByEntry?.[entry.routeId] ?? "missing";
+                    const propsHash = computePropsHash(entry.props);
+                    const scripts = resolveBundleScripts(clientBundle, entry.routeId, config.basePath, assetsDir, buildVersion);
+                    const legacyPolyfillScripts = legacyEnabled
+                        ? legacyPolyfillPlan.scripts.map((script) => appendBuildVersion(script, buildVersion))
+                        : [];
+                    const legacyBundleScripts = legacyEnabled && legacyBundle
+                        ? resolveBundleScripts(legacyBundle, entry.routeId, config.basePath, assetsDir, buildVersion)
+                        : [];
+                    const legacyScripts = legacyEnabled && !isEs5Target
+                        ? [...legacyPolyfillScripts, ...legacyBundleScripts]
+                        : [];
+                    const assets = {
+                        scripts: isEs5Target ? [...legacyPolyfillScripts, ...scripts] : scripts,
+                        legacyScripts,
+                        scriptType: clientScriptType,
+                        buildVersion,
+                    };
+                    const templateHash = computeTemplateHash(defaultHtmlTemplate, assets);
+                    const renderKey = computeRenderKey({
+                        routeId: entry.routeId,
+                        paramsKey: entry.paramsKey,
+                        templateHash,
+                        depsHash,
+                        propsHash,
+                    });
+                    if (renderCacheEnabled) {
+                        const cached = await readRenderCache(cacheRoot, {
+                            routeId: entry.routeId,
+                            paramsKey: entry.paramsKey,
+                            templateHash,
+                            depsHash,
+                            propsHash,
+                        });
+                        if (cached) {
+                            const routePath = routeIdToPath(entry.routeId, entry.params);
+                            const htmlPath = routePath
+                                ? join(outDir, routePath, "index.html")
+                                : join(outDir, "index.html");
+                            await writeFileSafe(htmlPath, cached.finalHtml);
+                            outputs[routePath || "/"] = cached.finalHtml;
+                            continue;
+                        }
+                    }
+                    const routeAdapter = resolveUIAdapter(config.ui.adapter, {
+                        ...config.ui.options,
+                        navigationMode: resolvedNavigationMode,
+                        clientRenderMode: config.routing.clientRender,
+                        nestedLayouts: config.routing.nestedLayouts,
+                        routeGraph,
+                        rootDir,
+                        routeRender: (props) => pageModule.default(props),
+                        routeHead: pageModule.head
+                            ? (props) => pageModule.head(props)
+                            : undefined,
+                    }, adapterRegistry);
+                    if (typeof routeAdapter.renderToHtml !== "function") {
+                        throw new Error(`UI adapter \"${routeAdapter.name}\" does not support renderToHtml.`);
+                    }
+                    const rendered = await renderHtml({
+                        renderToHtml: (ctx) => routeAdapter.renderToHtml(ctx),
+                        serializeProps: routeAdapter.serializeProps ?? serializeProps,
+                    }, { routeId: entry.routeId, params: entry.params, props: entry.props }, defaultHtmlTemplate, assets);
+                    const routePath = routeIdToPath(entry.routeId, entry.params);
+                    const htmlPath = routePath
+                        ? join(outDir, routePath, "index.html")
+                        : join(outDir, "index.html");
+                    await writeFileSafe(htmlPath, rendered.finalHtml);
+                    outputs[routePath || "/"] = rendered.finalHtml;
+                    if (renderCacheEnabled) {
+                        await writeRenderCache(cacheRoot, {
+                            routeId: entry.routeId,
+                            paramsKey: entry.paramsKey,
+                            renderKey,
+                            templateHash: rendered.templateHash,
+                            propsHash,
+                            depsHash,
+                            generatedAt: Date.now(),
+                            head: rendered.head,
+                            propsPayload: rendered.propsPayload,
+                            status: rendered.status,
+                            headers: rendered.headers,
+                            finalHtml: rendered.finalHtml,
+                        });
+                    }
+                }
+                return outputs;
+            },
+            emitManifest: async (_ctx, state) => {
+                const routeGraph = state.routeGraph;
+                const clientBundle = state.clientBundle;
+                const serverBundle = state.serverBundle;
+                const manifest = generateManifest({
+                    version: buildVersion,
+                    basePath: config.basePath,
+                    routeGraph,
+                    clientBundle,
+                    serverBundle,
+                    assets: {
+                        assetsDir,
+                        scriptType: clientScriptType,
+                    },
+                });
+                await mkdir(join(outDir, assetsDir), { recursive: true });
+                for (const route of routeGraph.routes) {
+                    const clientEntryKey = clientBundle.entryChunks[route.id];
+                    if (!clientEntryKey) {
+                        continue;
+                    }
+                    const clientChunk = clientBundle.chunks[clientEntryKey];
+                    const clientEntryPath = clientRuntimeEntries.get(route.id);
+                    if (!clientChunk || !clientEntryPath) {
+                        throw new Error(`Missing client runtime metadata for route ${route.id}`);
+                    }
+                    await buildChunkFile(clientEntryPath, join(outDir, assetsDir, clientChunk.file), {
+                        target: "browser",
+                        format: clientScriptType === "classic" ? "iife" : "esm",
+                        shimHyperCore: true,
+                        syntaxTarget: isEs5Target ? "es5" : "modern",
+                    });
+                }
+                if (serverBundle) {
+                    for (const route of routeGraph.routes) {
+                        const serverEntryKey = serverBundle.entryChunks[route.id];
+                        if (!serverEntryKey) {
+                            continue;
+                        }
+                        const serverChunk = serverBundle.chunks[serverEntryKey];
+                        const serverEntryPath = serverRuntimeEntries.get(route.id);
+                        if (!serverChunk || !serverEntryPath) {
+                            throw new Error(`Missing server runtime metadata for route ${route.id}`);
+                        }
+                        await buildChunkFile(serverEntryPath, join(outDir, assetsDir, serverChunk.file), {
+                            target: "node",
+                            format: "cjs",
+                            shimHyperCore: false,
+                            syntaxTarget: isEs5Target ? "es5" : "modern",
+                        });
+                    }
+                }
+                await writeFileSafe(join(outDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+                if (legacyEnabled && legacyBundle) {
+                    await emitBundleAssets(legacyBundle, outDir, assetsDir, legacyBootstrapChunk);
+                }
+                if (legacyEnabled &&
+                    legacyPolyfillPlan.autoPolyfillsFile &&
+                    legacyPolyfillPlan.autoPolyfillsChunk) {
+                    await writeFileSafe(join(outDir, assetsDir, legacyPolyfillPlan.autoPolyfillsFile), legacyPolyfillPlan.autoPolyfillsChunk);
+                }
+                return manifest;
+            },
+            copyPublic: async () => {
+                await copyPublicDir(publicDir, outDir);
+            },
+        }, { ssr: mode === "ssr" });
+        if (!result.state.routeGraph || !result.state.manifest) {
+            throw new Error("Build did not produce route graph or manifest.");
+        }
+        if (cache.enabled) {
+            await updateCacheIndex(cache.dir, rootKey, cacheRoot, {
+                maxSizeMB: cache.maxSizeMB,
+                maxAgeDays: cache.maxAgeDays,
+            });
+        }
+        return {
+            outDir,
+            routeGraph: result.state.routeGraph,
+            manifest: result.state.manifest,
+            timings: result.timings,
+            cache,
+        };
+    }
+    finally {
+        await rm(entryWorkspaceRoot, { recursive: true, force: true }).catch(() => { });
+    }
+};