fuzor 0.5.0 → 0.5.2

package/dist/vite.js

@@ -3,12 +3,13 @@ import { compileDataDocument } from './compiler/data-document.js';
 import { parseRoutePolicy } from './compiler/route-policy.js';
 import { extractPageScripts, compilePageScript } from "./compiler/page-scripts.js";
 import { compileNativeScript } from "./compiler/native-scripts.js";
+import { renderNativeBinding } from "./native-ranges.js";
+import { compileAuthoredNativeScript, prepareNativeScripts, htmlServerPlugin, assertNoServerScripts, resolveHtmlServer, loadHtmlServer } from "./compiler/native-authoring.js";
+import { emitNativeManifests } from "./compiler/native-manifest.js";
 import { compileWorkflows, workflowPlugin } from "./workflow/compiler.js";
+import { resolveInternalSpecifier } from "./internal-specifiers.js";
 import { assertBrowserViewImport } from "./server-components/environment.js";
-import { replaceClosures } from "./server-components/closures.js";
-import { discoverViewReferences, browserReferencesCode } from "./server-components/references.js";
 import { randomUUID } from "node:crypto";
-import { compileFragment, compiledFragmentsPlugin } from "./server-components/compiler.js";
 import { makeRouteMatches } from "./runtime/route-matches.js";
 import { makeClientRouteMatcher } from "./runtime/client-routes.js";
 import { errorHtml, notFoundHtml } from "./boundaries.js";
@@ -35,6 +36,7 @@ import { toWebRequest, writeWebResponse } from "./server/node.js";
 import { routeTypes } from "./runtime/href.js";
 import { writeElectronScaffold } from "./electron.js";
 import { createEnvironmentModuleRuntime, detectViteEnvironmentApi, invalidateEnvironmentModule, normalizeEnvironmentConfiguration } from "./vite-environments.js";
+import { validateBrandPrefix } from "./ui/core/brand.js";
 const virtualId = "virtual:fuzor/client";
 const rendererModules = {
     "virtual:fuzor/compiler/react": 'export { createElement } from "react"; export { renderToString, renderToStaticMarkup } from "react-dom/server";',
@@ -287,13 +289,6 @@ function replaceOutlet(document, content) {
         throw new Error(`index.html must contain ${outletStart} and ${outletEnd}.`);
     return document.slice(0, start + outletStart.length) + content + document.slice(end);
 }
-function serverViewDocument(html) {
-    let found = false;
-    const document = html.replace(/(<fuzor-router\b[^>]*>)[\s\S]*?<\/fuzor-router>/, (_match, open) => { found = true; return open + "<!--fuzor-view--></fuzor-router>"; });
-    if (!found || !document.includes("</body>"))
-        throw new Error("Server views require a compiled outlet and a document body.");
-    return document.replace("</body>", "<!--fuzor-snapshot--></body>");
-}
 /**
  * The plugin creates private Vite servers to load island and `paths` modules. Their config file loads
  * this plugin again; those nested instances only provide virtual modules and never compile the project.
@@ -304,17 +299,19 @@ const nestedServer = new AsyncLocalStorage();
  * open an HMR WebSocket (two would compete for its port, and a failed one never closes) and must not share the
  * dev server's dependency cache (each would re-optimize and invalidate the other's pre-bundled files).
  */
-export function nestedServerConfig(config) {
+export function nestedServerConfig(config, nativeModules) {
     return {
         root: config.root,
         configFile: config.configFile ?? false,
-        plugins: [workflowPlugin(), {
+        plugins: [{ name: "fuzor:internal-specifiers", enforce: "pre", resolveId: id => resolveInternalSpecifier(id) }, htmlServerPlugin(nativeModules), workflowPlugin(), {
                 name: "fuzor:nested-renderers",
                 resolveId(id) { if (Object.hasOwn(rendererModules, id))
                     return `\0${id}`; },
                 load(id) { if (id.startsWith("\0") && Object.hasOwn(rendererModules, id.slice(1)))
                     return rendererModules[id.slice(1)]; }
             }],
+        // Fuzor's server runtime is one module graph: compiler-owned modules and `fuzor/server` must not load twice.
+        ssr: { noExternal: ["fuzor"] },
         server: { middlewareMode: true, hmr: false, ws: false },
         cacheDir: path.join(config.cacheDir, "fuzor-nested"),
         optimizeDeps: { noDiscovery: true, include: [] },
@@ -380,20 +377,6 @@ export function resolveFuzorProfile(options = {}, env = process.env, serverModul
     const electron = options.electron ?? envElectron ?? requestedTarget === "electron";
     const target = (requestedTarget === "electron" ? "spa" : requestedTarget);
     const serverReasons = serverModules.map(file => file.startsWith("api/") ? `${file} defines an API endpoint` : file.endsWith(".html") ? `${file} declares request rendering` : `${file} defines server data`);
-    if (options.serverComponents) {
-        makeClientRouteMatcher(Object.fromEntries(options.serverComponents.routes.map(route => [route, "/"])));
-        for (const entry of [options.serverComponents.server, options.serverComponents.client, options.serverComponents.references].filter((value) => value !== undefined)) {
-            if (!entry || path.isAbsolute(entry) || entry.split(/[\\/]/).includes(".."))
-                throw new Error("Server component entries must be paths inside the project.");
-        }
-        if (!options.serverComponents.client && !options.serverComponents.references)
-            throw new Error("Server components require a client entry or generated reference directory.");
-        if (!options.serverComponents.routes.length)
-            throw new Error("Server components need at least one route.");
-        if (options.navigation === "embedded")
-            throw new Error("Server components require HTTP navigation.");
-        serverReasons.push(`${options.serverComponents.server} defines server components`);
-    }
     const inline = electron || packaged ? true : options.inline ?? envInline ?? false;
     if (inline && target !== "spa")
         throw new Error("Inline output is only supported for the SPA target.");
@@ -418,27 +401,11 @@ export function resolveFuzorProfile(options = {}, env = process.env, serverModul
     return { target, mixed, backendOutDir: ".fuzor/dist-backend", platform, server, inline, outDir: electron ? ".fuzor/dist-desktop" : platform !== "web" ? `.fuzor/dist-${platform}` : mixed ? ".fuzor/web/dist" : `.fuzor/web/dist-${target}`, serverReasons, adapter, ...(electron ? { electron: true } : {}) };
 }
 export function fuzorPlugin(options = {}) {
+    if (options.ui?.brand !== undefined)
+        validateBrandPrefix(options.ui.brand);
     const nested = nestedServer.getStore() === true;
+    const nativeServerModules = new Map();
     let viewBuildId = randomUUID();
-    let referencesPromise;
-    const references = () => referencesPromise ??= discoverViewReferences(vite.root, options.serverComponents.references);
-    const referenceStub = (file, refs) => {
-        const relative = path.relative(vite.root, file).split(path.sep).join("/");
-        const client = refs.clients.find(ref => ref.file === relative);
-        if (client)
-            return `export default ${JSON.stringify({ id: client.id })};`;
-        const closures = refs.closures.filter(ref => ref.file === relative);
-        if (closures.length)
-            return readFile(file, "utf8").then(code => replaceClosures(code, closures));
-        const handlers = refs.handlers.filter(ref => ref.file === relative);
-        return handlers.length ? handlers.map(ref => `export const ${ref.name}=${JSON.stringify({ id: ref.id })};`).join("\n") : undefined;
-    };
-    const generatedViews = async (views) => {
-        if (!options.serverComponents?.references)
-            return views;
-        const refs = await references();
-        return { ...views, manifest: { buildId: viewBuildId, templates: refs.templates }, components: refs.clients.map(ref => ref.id), handlers: [...refs.handlers.map(ref => ref.id), ...refs.closures.map(ref => ref.id)] };
-    };
     const configuredEnvironments = normalizeEnvironmentConfiguration(options.experimental?.environments);
     const environmentNames = {
         client: configuredEnvironments.client ?? "client",
@@ -481,6 +448,8 @@ export function fuzorPlugin(options = {}) {
     let project;
     let pageScripts = [];
     const nativeHandlers = new Map();
+    const authoredNative = new Map();
+    let nativeAdmissions = new Map();
     let inlineModuleFiles = [];
     let scriptRoutes = [];
     const routeScriptId = (route) => `virtual:fuzor/route-client/${encodeURIComponent(route.path)}/${route.path === "/" ? "index" : route.path.split("/").filter(Boolean).join("-").replace(/[^a-zA-Z0-9_-]/g, "_")}-client.js`;
@@ -503,7 +472,7 @@ export function fuzorPlugin(options = {}) {
         let solidHydrationScript = "";
         const pending = (async () => {
             let owned;
-            const createModuleServer = () => nestedServer.run(true, () => createServer(nestedServerConfig(vite)));
+            const createModuleServer = () => nestedServer.run(true, () => createServer(nestedServerConfig(vite, nativeServerModules)));
             const moduleServer = () => devServer ? Promise.resolve(devServer) : owned ??= createModuleServer();
             // client:none analysis reads client transforms without HMR code, which the dev server would add. It has its
             // own server: client transforms wait for pending requests to settle, and preview renders on the module
@@ -672,6 +641,8 @@ export function fuzorPlugin(options = {}) {
     const compileRaw = async (signal, loadModule) => {
         let compiled = await compileProject(vite.root, { ...(options.markdown ? { markdown: options.markdown } : {}), ...(options.redirects ? { redirects: options.redirects } : {}), platform: profile.platform, signal, loadModule, cache: compileCache })
             .catch(async (error) => { throw await withViteLocation(error); });
+        nativeServerModules.clear();
+        compiled = await prepareNativeScripts(compiled, vite.root, loadModule, nativeServerModules);
         const entry = options.entry ?? process.env.FUZOR_ENTRY;
         if (entry) {
             if (!inline || target !== "spa")
@@ -688,15 +659,20 @@ export function fuzorPlugin(options = {}) {
             if (!compiled.routes.some(route => route.path === "/"))
                 throw new Error("Application entry must have a static root template; request-rendered routes require an HTTP rendering deployment.");
         }
+        const inferredServer = compiled.routes.filter(route => route.serverData || route.policy?.rendering === "request");
+        if (inferredServer.length) {
+            profile = resolveFuzorProfile(options, process.env, [...new Set([...serverModuleFiles, ...inferredServer.map(route => path.relative(vite.root, route.source).split(path.sep).join("/"))])]);
+            withServer = profile.server;
+        }
         const deployment = options.deployment ?? process.env.FUZOR_DEPLOYMENT;
         const requestRoutes = compiled.routes.filter(route => route.policy?.rendering === "request");
         if (deployment && !["static", "github-pages", "node", "cloudflare"].includes(deployment))
             throw new Error("Unknown Fuzor deployment target: " + deployment);
-        if ((deployment === "static" || deployment === "github-pages") && (requestRoutes.length || options.serverComponents?.routes.length))
-            throw new Error(`Route ${(requestRoutes[0]?.path ?? options.serverComponents.routes[0])} requires request-time server rendering. ${deployment} supports static files only. Pre-render this route, regenerate and republish its files, or choose node/cloudflare rendering. Remote API calls from static SPAs are allowed.`);
+        if ((deployment === "static" || deployment === "github-pages") && requestRoutes.length)
+            throw new Error(`Route ${requestRoutes[0].path} requires request-time server rendering. ${deployment} supports static files only. Pre-render this route, regenerate and republish its files, or choose node/cloudflare rendering. Remote API calls from static SPAs are allowed.`);
         for (const route of requestRoutes)
-            if (route.requestPattern && route.policy?.navigation === "spa" && !options.serverComponents?.routes.some(pattern => makeClientRouteMatcher({ [pattern]: "/" })(route.path)))
-                throw new Error(`${route.source}: unenumerated request routes inside an SPA require a server-component renderer. Use navigation=document or register serverComponents.`);
+            if (route.requestPattern && route.policy?.navigation === "spa" && !route.serverData?.startsWith("virtual:fuzor/native-data/"))
+                throw new Error(`${route.source}: unenumerated request routes inside an SPA need an HTML server component. Add one or use navigation=document.`);
         if (options.routeTree) {
             if (target !== "spa" && !profile.mixed)
                 throw new Error("routeTree requires a SPA target.");
@@ -716,8 +692,8 @@ export function fuzorPlugin(options = {}) {
             check(options.routeTree);
         }
         if (options.clientRoutes && Object.keys(options.clientRoutes).length) {
-            if (target !== "spa" || !options.serverComponents && (withServer || apiFiles.length > 0 || serverModuleFiles.length > 0))
-                throw new Error("clientRoutes requires a static SPA target.");
+            if (target !== "spa")
+                throw new Error("clientRoutes requires an SPA target.");
             makeClientRouteMatcher(options.clientRoutes);
             for (const target of Object.values(options.clientRoutes)) {
                 const route = compiled.routes.find(route => route.path === routeKey(target));
@@ -735,7 +711,18 @@ export function fuzorPlugin(options = {}) {
         const extracted = extractPageScripts(compiled, vite.root);
         pageScripts = extracted.scripts;
         scriptRoutes = extracted.routes;
-        return extracted.project;
+        authoredNative.clear();
+        nativeHandlers.clear();
+        for (const script of pageScripts)
+            if (script.native) {
+                const compiled = compileAuthoredNativeScript(script.code ?? await readFile(script.source, "utf8"), script, viewBuildId);
+                authoredNative.set(script.id, compiled);
+                for (const handler of compiled.handlers)
+                    nativeHandlers.set(handler.id, handler);
+            }
+        const emitted = emitNativeManifests(extracted.project, scriptRoutes, pageScripts, authoredNative, viewBuildId);
+        nativeAdmissions = emitted.admissions;
+        return emitted.project;
     };
     const scanIslands = async () => {
         return Effect.runPromise(scanIslandModulesEffect(vite.root, Object.keys(options.runtimes ?? {})));
@@ -743,7 +730,6 @@ export function fuzorPlugin(options = {}) {
     const refresh = async (server) => {
         const version = ++revision;
         viewBuildId = randomUUID();
-        referencesPromise = undefined;
         compilation?.abort();
         project = undefined;
         projectPromise = undefined;
@@ -810,8 +796,8 @@ export function fuzorPlugin(options = {}) {
             profile = resolveFuzorProfile(options, process.env, serverModuleFiles);
             ({ target, inline } = profile);
             withServer = profile.server;
-            if (options.clientRoutes && Object.keys(options.clientRoutes).length && (target !== "spa" || withServer && !options.serverComponents))
-                throw new Error("clientRoutes requires a static SPA target.");
+            if (options.clientRoutes && Object.keys(options.clientRoutes).length && target !== "spa")
+                throw new Error("clientRoutes requires an SPA target.");
             const packageJson = await readFile(path.join(path.resolve(config.root ?? process.cwd()), "package.json"), "utf8").then(text => JSON.parse(text), () => ({}));
             const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
             const include = ["Cause", "Context", "Deferred", "Effect", "Exit", "Fiber", "Layer", "Schema", "Scope", "reactivity/Atom", "reactivity/AtomRegistry"].map(module => `fuzor > effect/${module}`);
@@ -821,7 +807,9 @@ export function fuzorPlugin(options = {}) {
                 include.push("vue");
             return {
                 resolve: { dedupe: ["react", "react-dom", "solid-js", "vue"] },
-                optimizeDeps: { include, ...runtimeOptimizer },
+                // A `*.fragment.html` is a compiled fragment, not a page: Vite's dependency scan would load it as an entry and
+                // fail on the virtual module it resolves to. Pages keep Vite's own default of every `.html` file.
+                optimizeDeps: { include, ...(config.optimizeDeps?.entries === undefined ? { entries: ["**/*.html", "!**/*.fragment.html"] } : {}), ...runtimeOptimizer },
                 // Vite 6.4 accepts named environments in the config hook. This is
                 // emitted only for explicit opt-in; Vite 6/7 legacy users are untouched.
                 ...(options.experimental?.environments ? {
@@ -848,11 +836,14 @@ export function fuzorPlugin(options = {}) {
             }
         },
         async resolveId(id, importer, resolveOptions) {
+            const internalFile = resolveInternalSpecifier(id);
+            if (internalFile)
+                return internalFile;
+            const serverModule = resolveHtmlServer(id, resolveOptions.ssr, nativeServerModules);
+            if (serverModule)
+                return serverModule;
             if (!resolveOptions.ssr)
                 assertBrowserViewImport(id, importer);
-            if (id === "fuzor/server-components/server" && !resolveOptions.ssr) {
-                throw new Error("The server-component evaluator is server-only. Import browser runtime and protocol separately.");
-            }
             if (id.startsWith("virtual:fuzor/route-client/"))
                 return `\0${id}`;
             if (id.startsWith("virtual:fuzor/page-script/"))
@@ -943,6 +934,8 @@ export function fuzorPlugin(options = {}) {
             }
         },
         async load(id, loadOptions) {
+            if (id.includes("?fuzor-server-script=") || nativeServerModules.has(id))
+                return loadHtmlServer(id, nativeServerModules, file => this.addWatchFile(file));
             if (id.startsWith("\0virtual:fuzor/route-client/")) {
                 await loadProject();
                 const route = scriptRoutes.find(route => `\0${routeScriptId(route)}` === id);
@@ -957,6 +950,8 @@ export function fuzorPlugin(options = {}) {
                     throw new Error("Unknown Fuzor page script");
                 this.addWatchFile(script.source);
                 const source = script.code ?? await readFile(script.source, "utf8");
+                if (script.native)
+                    throw new Error("Authored native declarations are adopted from HTML, not executable descriptor modules");
                 const native = compileNativeScript(source, script);
                 if (native) {
                     for (const handler of native.handlers)
@@ -972,31 +967,6 @@ export function fuzorPlugin(options = {}) {
                     throw new Error("Unknown native handler");
                 return (await import("vite")).transformWithEsbuild(handler.code, handler.source, { loader: handler.language, target: "es2022" });
             }
-            if (id.startsWith("\0fuzor:closure:")) {
-                const refs = await references();
-                const closure = refs.closures.find(ref => id === `\0fuzor:closure:${ref.id}.ts`);
-                if (!closure)
-                    throw new Error("Unknown resumable closure reference");
-                return (await import("vite")).transformWithEsbuild(closure.code, id, { loader: "ts", target: "es2022" }).then(result => result.code);
-            }
-            if (options.serverComponents?.references) {
-                const refs = await references();
-                if (id === "\0virtual:fuzor/views") {
-                    if (loadOptions?.ssr)
-                        return `export const manifest=${JSON.stringify({ buildId: viewBuildId, templates: refs.templates })}; export const components=${JSON.stringify(refs.clients.map(ref => ref.id))}; export const handlers=${JSON.stringify([...refs.handlers.map(ref => ref.id), ...refs.closures.map(ref => ref.id)])};`;
-                    return browserReferencesCode(refs, viewBuildId, file => "/" + file);
-                }
-                if (loadOptions?.ssr) {
-                    const stub = referenceStub(id.split("?")[0], refs);
-                    if (stub)
-                        return stub;
-                }
-            }
-            if (id.startsWith("\0fuzor:fragment:")) {
-                const file = id.slice("\0fuzor:fragment:".length, -3);
-                this.addWatchFile(file);
-                return readFile(file, "utf8").then(html => `export default ${JSON.stringify(compileFragment(html))};`);
-            }
             if (Object.hasOwn(rendererModules, id.slice(1)))
                 return rendererModules[id.slice(1)];
             const runtimeModule = runtimeModules.get(id);
@@ -1005,7 +975,7 @@ export function fuzorPlugin(options = {}) {
             if (!loadOptions?.ssr && !nested && vite) {
                 const file = id.split("?")[0];
                 const relative = path.relative(vite.root, file).split(path.sep).join("/");
-                if (options.serverComponents && path.resolve(vite.root, options.serverComponents.server) === file || serverModuleFiles.includes(relative) || relative.startsWith("api/") || /\.server\.[cm]?[jt]sx?$/.test(relative)) {
+                if (serverModuleFiles.includes(relative) || relative.startsWith("api/") || /\.server\.[cm]?[jt]sx?$/.test(relative)) {
                     throw new Error(`${relative} is server-only and cannot be imported by browser code. Read its data with <fuzor-data> or routeData() instead.`);
                 }
             }
@@ -1013,7 +983,32 @@ export function fuzorPlugin(options = {}) {
                 return undefined;
             await loadProject();
             const mixedClient = profile.mixed && project?.routes.some(route => route.policy?.navigation === "spa");
-            const scriptRegistry = scriptRoutes.map(route => `${JSON.stringify(route.path)}: () => import(${JSON.stringify(routeScriptId(route))}).catch(reloadOnStaleDeployment)`).join(",\n");
+            const scriptRegistry = scriptRoutes.map(route => nativeAdmissions.has(route.path)
+                ? `${JSON.stringify(route.path)}: async () => readNativeManifest(outlet, ${JSON.stringify(route.path)}, ${JSON.stringify(viewBuildId)}, ${JSON.stringify(nativeAdmissions.get(route.path))}, nativeLoaders)`
+                : `${JSON.stringify(route.path)}: () => import(${JSON.stringify(routeScriptId(route))}).catch(reloadOnStaleDeployment)`).join(",\n");
+            const handlerLoaders = new Map();
+            const graphLoaders = new Map();
+            const cssImports = new Set();
+            for (const script of pageScripts) {
+                const compiled = authoredNative.get(script.id);
+                if (!compiled)
+                    continue;
+                this.addWatchFile(script.source);
+                for (const css of compiled.css) {
+                    const resolved = await this.resolve(css, script.source);
+                    if (!resolved)
+                        throw new Error(`${script.source}: cannot resolve native stylesheet ${css}`);
+                    cssImports.add(`import ${JSON.stringify(resolved.id)};`);
+                }
+                for (const [name, id] of compiled.actionIds)
+                    if ((script.native.events.some(event => event.action === name) || script.native.effects?.some(effect => effect.action === name)))
+                        handlerLoaders.set(id, `${JSON.stringify(id)}: {server: ${Object.hasOwn(script.native.serverActions ?? {}, name)}, load: () => import(${JSON.stringify(`virtual:fuzor/native-handler/${id}.js`)}).catch(reloadOnStaleDeployment)}`);
+                if (compiled.graphId)
+                    graphLoaders.set(compiled.graphId, `${JSON.stringify(compiled.graphId)}: (definition, data) => import("fuzor/runtime/native-graph").then(module => module.nativeGraphModule(definition, data, ${JSON.stringify(script.native.computed ?? {})}, ${JSON.stringify(script.native.ranges ?? [])}, [${(script.native.effects ?? []).map(effect => `{dependencies:${JSON.stringify(effect.dependencies)},load:()=>import(${JSON.stringify(`virtual:fuzor/native-handler/${compiled.actionIds.get(effect.action)}.js`)})}`).join(",")}]))`);
+            }
+            const manifestScripts = new Set(scriptRoutes.filter(route => nativeAdmissions.has(route.path)).flatMap(route => route.bindings.filter(binding => !authoredNative.has(binding.id)).map(binding => binding.id)));
+            const nativeData = pageScripts.some(script => script.native?.request);
+            const nativeLoaders = nativeAdmissions.size ? `const nativeLoaders = { ${nativeData ? "data: routeData," : ""} handlers: {${[...handlerLoaders.values()].join(",")}}, graphs: {${[...graphLoaders.values()].join(",")}}, scripts: {${[...manifestScripts].map(id => `${JSON.stringify(id)}: () => import(${JSON.stringify(pageScriptId(pageScripts.find(script => script.id === id)))}).catch(reloadOnStaleDeployment)`).join(",")}} };` : "";
             const registry = islands.map((island) => {
                 const load = island.file.endsWith(".vue")
                     ? `Promise.all([import(${JSON.stringify(island.file)}), import("fuzor/islands/vue")]).then(([component, adapter]) => adapter.vueIsland(component.default)).catch(reloadOnStaleDeployment)`
@@ -1021,16 +1016,24 @@ export function fuzorPlugin(options = {}) {
                 return `${JSON.stringify(island.name)}: () => ${load}`;
             }).join(",\n");
             const withData = target === "mpa" && !!project?.routes.some(route => route.serverData);
+            // Keep every discovered module, including ones introduced by page scripts. An empty static
+            // registry cannot activate an island; retain diagnostics for authored hosts and open server/dev paths.
+            const withIslands = islands.length > 0 || withServer || vite.command === "serve"
+                || [...(project?.routes ?? []), ...(project?.boundaries ?? [])].some(route => /<fuzor-island\b/i.test(route.html));
+            const mountIslandsCode = withIslands ? "mountIslands(outlet, islands, islandErrorHandler, { signal: lifetime.signal })" : "Promise.resolve(() => {})";
             const hasDocs = (project?.routes ?? []).some(route => route.path === "/docs/" || route.path.startsWith("/docs/"));
             const routerModule = profile.electron || options.navigation === "embedded" ? "fuzor/runtime/router/embedded" : options.navigation === "navigation-api" ? "fuzor/runtime/router/navigation-api" : "fuzor/runtime";
             const imports = [
+                ...cssImports,
+                ...(nativeAdmissions.size ? ['import { readNativeManifest } from "fuzor/runtime/native-manifest";'] : []),
+                ...(options.ui?.brand === undefined ? [] : ['import { defineBrand } from "fuzor/ui/core";']),
                 (target === "spa" || mixedClient)
                     ? `import { createRouter } from "${routerModule}"; import { reloadOnStaleDeployment } from "fuzor/runtime/islands";`
-                    : 'import { mountIslands, islandErrorHandler, reloadOnStaleDeployment } from "fuzor/runtime/islands";',
+                    : `import { ${withIslands ? "mountIslands, islandErrorHandler, " : ""}reloadOnStaleDeployment } from "fuzor/runtime/islands";`,
                 ...(target === "mpa" ? ['import { mountPageScripts } from "fuzor/runtime/page-scripts"; import { stripBase } from "fuzor/runtime";'] : []),
-                ...(options.serverComponents ? [options.serverComponents.references ? 'import generatedViewOptions from "virtual:fuzor/views";' : "", options.serverComponents.client ? `import suppliedViewOptions from ${JSON.stringify("/" + options.serverComponents.client)};` : "", `const viewOptions = { ${options.serverComponents.references ? "...generatedViewOptions" : ""}${options.serverComponents.references && options.serverComponents.client ? "," : ""}${options.serverComponents.client ? "...suppliedViewOptions" : ""} };`, (target === "spa" || mixedClient) ? 'import { makeClientRouteMatcher } from "fuzor/runtime"; import { serverViewRoutes } from "fuzor/server-components/navigation"; import { createViewRenderer } from "fuzor/server-components/browser";' : 'import { createViewRenderer } from "fuzor/server-components/browser";'] : []),
-                ...(mixedClient ? ['import { mountIslands, islandErrorHandler } from "fuzor/runtime/islands";'] : []),
-                ...(withData ? ['import { loadRouteData } from "fuzor/runtime/data";'] : []),
+                ...(mixedClient && withIslands ? ['import { mountIslands, islandErrorHandler } from "fuzor/runtime/islands";'] : []),
+                ...(withData || nativeData ? [`import { ${[withData ? "loadRouteData" : "", nativeData ? "routeData" : ""].filter(Boolean).join(",")} } from "fuzor/runtime/data";`] : []),
+                ...(nativeData ? ['import { enableNativeStreams } from "fuzor/runtime/native-stream";'] : []),
                 ...(hasDocs ? ['import { mountDocsUi } from "fuzor/runtime/docs-ui";'] : [])
             ];
             const docsInit = hasDocs ? `let stopDocsUi;
@@ -1040,17 +1043,16 @@ const disposeDocs = () => {
   if (docsDisposed) return;
   docsDisposed = true;
   window.removeEventListener("pagehide", hideDocs);
-  stopDocsUi?.();
+  void stopDocsUi?.().catch(error => console.error(error));
 };
 void mountDocsUi({ document, base: import.meta.env.BASE_URL }).then(stop => {
   stopDocsUi = stop;
-  if (docsDisposed) stop();
+  if (docsDisposed) void stop().catch(error => console.error(error));
 }, error => console.error(error));
 window.addEventListener("pagehide", hideDocs);
 if (import.meta.hot) import.meta.hot.dispose(disposeDocs);
 ` : "";
-            const effectiveViewOptions = `...viewOptions, manifest: { ...viewOptions.manifest, buildId: ${JSON.stringify(viewBuildId)} }`;
-            const spaStart = `export const router = (${mixedClient ? 'outlet.getAttribute("data-fuzor-navigation") === "spa" && ' : ""}!outlet.hasAttribute("data-fuzor-not-found") && !outlet.hasAttribute("data-fuzor-error")) ? createRouter(outlet, { islands, scripts, base: import.meta.env.BASE_URL${options.serverComponents ? `, renderer: serverViewRoutes({ ${effectiveViewOptions}, routes: ${JSON.stringify(options.serverComponents.routes)}, acceptsRoute: path => !${mixedClient} || [...document.querySelectorAll("template[data-fuzor-route]")].some(t => t.getAttribute("data-fuzor-route") === path || t.hasAttribute("data-fuzor-request-pattern") && makeClientRouteMatcher({[t.getAttribute("data-fuzor-request-pattern")]: "/"})(path)), base: import.meta.env.BASE_URL })` : ""}${options.clientRoutes ? `, clientRoutes: ${JSON.stringify(options.clientRoutes)}` : ""}${options.routeTree ? `, routeTree: ${JSON.stringify(options.routeTree)}` : ""}${options.viewTransitions ? ", viewTransitions: true" : ""}${options.prefetch === "intent" ? ', prefetch: "intent"' : ""} }) : undefined;
+            const spaStart = `export const router = (${mixedClient ? 'outlet.getAttribute("data-fuzor-navigation") === "spa" && ' : ""}!outlet.hasAttribute("data-fuzor-not-found") && !outlet.hasAttribute("data-fuzor-error")) ? createRouter(outlet, { islands, scripts, base: import.meta.env.BASE_URL${options.clientRoutes ? `, clientRoutes: ${JSON.stringify(options.clientRoutes)}` : ""}${options.routeTree ? `, routeTree: ${JSON.stringify(options.routeTree)}` : ""}${options.viewTransitions ? ", viewTransitions: true" : ""}${options.prefetch === "intent" ? ', prefetch: "intent"' : ""} }) : undefined;
 export const ready = router ? router.start() : Promise.resolve(undefined);
 void ready.catch(error => console.error(error));
 if (import.meta.hot) import.meta.hot.dispose(() => { void router?.dispose(); });`;
@@ -1059,13 +1061,11 @@ if (import.meta.hot) import.meta.hot.dispose(() => { void router?.dispose(); });
 const lifetime = new AbortController();
 let cleanup;
 const dispose = () => { lifetime.abort(); void cleanup?.(); };
-${options.serverComponents ? `const viewRenderer = document.querySelector("script[data-fuzor-snapshot]") ? createViewRenderer(outlet, { ${effectiveViewOptions} }) : undefined;
-const mountComponents = viewRenderer ? viewRenderer.resume().then(() => () => viewRenderer.dispose()) : mountIslands(outlet, islands, islandErrorHandler, { signal: lifetime.signal });` : `const mountComponents = mountIslands(outlet, islands, islandErrorHandler, { signal: lifetime.signal });`}
-${options.serverComponents ? "const viewRendererActive = !!viewRenderer;" : "const viewRendererActive = false;"}
+const mountComponents = ${mountIslandsCode};
 const pathname = stripBase(location.pathname, import.meta.env.BASE_URL) ?? location.pathname;
 const routePath = pathname.endsWith("/") ? pathname : pathname + "/";
 const scriptRoute = Object.hasOwn(scripts, routePath) ? routePath : outlet.getAttribute("data-fuzor-pattern") ?? "";
-const mount = (async () => { const stopComponents = await mountComponents; try { const stopScripts = await mountPageScripts(outlet, viewRendererActive ? {} : scripts, { signal: lifetime.signal, route: scriptRoute }); return async () => { await stopScripts(); await stopComponents(); }; } catch (error) { await stopComponents(); throw error; } })();
+const mount = (async () => { const stopComponents = await mountComponents; try { const stopScripts = await mountPageScripts(outlet, scripts, { signal: lifetime.signal, route: scriptRoute }); return async () => { await stopScripts(); await stopComponents(); }; } catch (error) { await stopComponents(); throw error; } })();
 void mount.then(stop => {
   cleanup = stop;
   if (lifetime.signal.aborted) void stop();
@@ -1073,7 +1073,10 @@ void mount.then(stop => {
 window.addEventListener("pagehide", event => { if (!event.persisted) dispose(); });
 if (import.meta.hot) import.meta.hot.dispose(dispose);`;
             return `${imports.join("\n")}
+${options.ui?.brand === undefined ? "" : `defineBrand(${JSON.stringify(options.ui.brand)});`}
 const islands = { ${registry} };
+${nativeLoaders}
+${nativeData ? `enableNativeStreams(${JSON.stringify(viewBuildId)});` : ""}
 const scripts = { ${scriptRegistry} };
 const outlet = document.querySelector("fuzor-router");
 if (!outlet) throw new Error("Fuzor outlet is missing");
@@ -1090,6 +1093,7 @@ ${docsInit}${mixedClient ? spaStart + "\nif (!router) {\n" + mpaStart + "\n}" :
                 const pathname = stripBase(requested, pathBase) ?? requested;
                 const currentPath = findRoute(compiled, pathname) ? pathname : "/";
                 parseRoutePolicy(raw, path.join(vite.root, "index.html"), false);
+                assertNoServerScripts(raw, path.join(vite.root, "index.html"));
                 const shell = compilePlatformBlocks(raw, profile.platform, path.join(vite.root, "index.html"));
                 shellHead = readDocumentHead(shell);
                 let html = applyDocumentMetadata(replaceOutlet(shell, outletFor(compiled, target, currentPath, fallbacks(), profile.mixed)), pageHead(shellHead, findRoute(compiled, currentPath)?.metadata ?? {}));
@@ -1161,10 +1165,7 @@ ${docsInit}${mixedClient ? spaStart + "\nif (!router) {\n" + mpaStart + "\n}" :
                             const compiled = await loadProject();
                             const manifest = serverManifest(compiled, target, template, pathBase, fallbacks(), withStaticModuleImports, options.clientRoutes, `/${vite.build.assetsDir}/`, profile.mixed);
                             const data = dataRequest || compiled.routes.some(route => route.policy?.rendering === "request") ? await loadRouteDataModules(compiled, file => createEnvironmentModuleRuntime(server, moduleEnvironment, environmentApiEnabled).loadModule(file), vite.root) : undefined;
-                            const views = options.serverComponents ? await generatedViews((await createEnvironmentModuleRuntime(server, moduleEnvironment, environmentApiEnabled).loadModule("/" + options.serverComponents.server)).default) : undefined;
-                            if (views && JSON.stringify(Object.keys(views.routes).sort()) !== JSON.stringify([...options.serverComponents.routes].sort()))
-                                throw new Error("Server view routes must match serverComponents.routes.");
-                            result = await createServerHandler(manifest, { ...(data ? { data } : {}), ...(views ? { views: { ...views, manifest: { ...views.manifest, buildId: viewBuildId }, documentPatterns: manifest.requestPatterns ?? {}, document: serverViewDocument(template), documents: Object.fromEntries(Object.entries("documents" in manifest ? manifest.documents : manifest.routeDocuments ?? {}).map(([route, html]) => [route, serverViewDocument(html)])) } } : {}), onError })(toWebRequest(request, { url, signal: controller.signal }));
+                            result = await createServerHandler({ ...manifest, buildId: viewBuildId }, { renderBinding: renderNativeBinding, ...(data ? { data } : {}), onError })(toWebRequest(request, { url, signal: controller.signal }));
                         }
                         await writeWebResponse(response, result, { method: request.method ?? "GET", signal: controller.signal });
                     }
@@ -1205,7 +1206,7 @@ ${docsInit}${mixedClient ? spaStart + "\nif (!router) {\n" + mpaStart + "\n}" :
                 }
             });
             server.watcher.on("add", (file) => {
-                if (pageScripts.some(script => script.source === file) || options.serverComponents && (file.endsWith(".fragment.html") || options.serverComponents.references && file.startsWith(path.resolve(vite.root, options.serverComponents.references) + path.sep) || file === path.resolve(vite.root, options.serverComponents.server) || options.serverComponents.client && file === path.resolve(vite.root, options.serverComponents.client)) || ["/pages/", "/components/", "/layouts/", "/islands/", "/api/"].some((part) => file.replaceAll("\\", "/").includes(part))) {
+                if (pageScripts.some(script => script.source === file) || ["/pages/", "/components/", "/layouts/", "/islands/", "/api/"].some((part) => file.replaceAll("\\", "/").includes(part))) {
                     void refresh(server).catch((error) => server.config.logger.error(String(error)));
                 }
             });
@@ -1318,8 +1319,7 @@ ${docsInit}${mixedClient ? spaStart + "\nif (!router) {\n" + mpaStart + "\n}" :
                     await mkdir(serverDir, { recursive: true });
                     await writeFile(path.join(serverDir, "fuzor.manifest.json"), JSON.stringify({ ...artifact, clientDirectory: path.relative(serverDir, outDir).split(path.sep).join("/") }, null, 2) + "\n");
                     const dataRoutes = compiled.routes.filter(route => route.serverData);
-                    const refs = options.serverComponents?.references ? await references() : undefined;
-                    if (!dataRoutes.length && !apiFiles.length && !options.serverComponents) {
+                    if (!dataRoutes.length && !apiFiles.length && !options.serverExternal) {
                         await writeFile(path.join(serverDir, "entry.mjs"), `import { createServerHandler } from "fuzor/server";\n` +
                             `export const manifest = ${JSON.stringify(manifest)};\n` +
                             `export const handler = createServerHandler(manifest);\n`, "utf8");
@@ -1329,8 +1329,7 @@ ${docsInit}${mixedClient ? spaStart + "\nif (!router) {\n" + mpaStart + "\n}" :
                         const files = [...new Set(dataRoutes.map(route => route.serverData))];
                         const entryId = "virtual:fuzor/server-entry";
                         const code = [
-                            `import { createServerHandler, isServerData } from "fuzor/server";`,
-                            ...(options.serverComponents ? [`import suppliedViews from ${JSON.stringify(path.resolve(vite.root, options.serverComponents.server))};`, `const views = { ...suppliedViews${refs ? `, manifest: ${JSON.stringify({ buildId: viewBuildId, templates: refs.templates })}, components: ${JSON.stringify(refs.clients.map(ref => ref.id))}, handlers: ${JSON.stringify([...refs.handlers.map(ref => ref.id), ...refs.closures.map(ref => ref.id)])}` : ""} };`, `if (JSON.stringify(Object.keys(views.routes).sort()) !== ${JSON.stringify(JSON.stringify([...options.serverComponents.routes].sort()))}) throw new Error("Server view routes must match serverComponents.routes.");`] : []),
+                            `import { createServerHandler, isServerData${Object.values(manifest.dataBindings ?? {}).some(bindings => bindings.some(binding => binding.kind === "range")) ? ", renderNativeBinding" : ""} } from "fuzor/server";`,
                             ...files.map((file, index) => `import data${index} from ${JSON.stringify(file)};`),
                             ...apiFiles.map((route, index) => `import * as api${index} from ${JSON.stringify(route.file)};`),
                             `const modules = [${files.map((_, index) => `data${index}`).join(", ")}];`,
@@ -1339,13 +1338,15 @@ ${docsInit}${mixedClient ? spaStart + "\nif (!router) {\n" + mpaStart + "\n}" :
                             `export const manifest = ${JSON.stringify(manifest)};`,
                             `const routes = ${JSON.stringify(dataRoutes.map(route => [route.path, files.indexOf(route.serverData), route.params ?? null]))};`,
                             `const api = [${apiFiles.map((route, index) => `{ pattern: ${JSON.stringify(route.pattern)}, segments: ${JSON.stringify(route.segments)}, source: ${JSON.stringify(route.relative)}, module: api${index} }`).join(", ")}];`,
-                            `export const handler = createServerHandler(manifest, { data: Object.fromEntries(routes.map(([route, index, params]) => [route, params ? { data: modules[index], params } : { data: modules[index] }])), api${options.serverComponents ? `, views: { ...views, manifest: { ...views.manifest, buildId: ${JSON.stringify(viewBuildId)} }, documentPatterns:${JSON.stringify(manifest.requestPatterns ?? {})}, document: ${JSON.stringify(serverViewDocument(rootHtml))}, documents:${JSON.stringify(Object.fromEntries(Object.entries("documents" in manifest ? manifest.documents : manifest.routeDocuments ?? {}).map(([route, html]) => [route, serverViewDocument(html)])))} }` : ""} });`
+                            `export const handler = createServerHandler(manifest, { data: Object.fromEntries(routes.map(([route, index, params]) => [route, params ? { data: modules[index], params } : { data: modules[index] }])), api${Object.values(manifest.dataBindings ?? {}).some(bindings => bindings.some(binding => binding.kind === "range")) ? ", renderBinding: renderNativeBinding" : ""} });`
                         ].join("\n");
                         await nestedServer.run(true, () => viteBuild({
                             root: vite.root, mode: vite.mode, configFile: vite.configFile ?? false, logLevel: "error", publicDir: false,
-                            // One runtime copy: the entry and server modules must share fuzor/server and effect from node_modules.
-                            ssr: { external: ["fuzor", "effect"] },
-                            plugins: [compiledFragmentsPlugin(), workflowPlugin(), ...(refs ? [{ name: "fuzor:server-references", load: (id) => referenceStub(id, refs) }] : []), { name: "fuzor:server-entry", resolveId: id => id === entryId ? `\0${entryId}` : undefined, load: id => id === `\0${entryId}` ? code : undefined }],
+                            // One runtime copy: Fuzor's own server runtime is always bundled into the entry (generated code reaches modules
+                            // that are not package entries), so the entry and server modules share one copy of it. `effect` is imported from
+                            // node_modules by default; with `serverExternal`, everything it does not name is bundled once.
+                            ssr: options.serverExternal ? { external: options.serverExternal.filter(name => name !== "fuzor"), noExternal: true } : { external: ["effect"], noExternal: ["fuzor"] },
+                            plugins: [{ name: "fuzor:internal-specifiers", enforce: "pre", resolveId: id => resolveInternalSpecifier(id) }, htmlServerPlugin(nativeServerModules), workflowPlugin(), { name: "fuzor:server-entry", resolveId: id => id === entryId ? `\0${entryId}` : undefined, load: id => id === `\0${entryId}` ? code : undefined }],
                             build: { ssr: true, outDir: serverDir, emptyOutDir: false, copyPublicDir: false, minify: false,
                                 rollupOptions: { input: entryId, output: { entryFileNames: "entry.mjs", chunkFileNames: "chunks/[name]-[hash].mjs", format: "es" } } }
                         }));
@@ -1353,7 +1354,7 @@ ${docsInit}${mixedClient ? spaStart + "\nif (!router) {\n" + mpaStart + "\n}" :
                     // The same finished documents are also written to client/ below, so it can be served by a CDN or
                     // static host with only /api and server data requests reaching the server.
                     if (profile.adapter === "cloudflare")
-                        await writeCloudflareOutput(serverDir, vite.root, target, pathBase, outDir, [...compiled.routes.filter(route => route.policy?.rendering === "request").map(route => route.requestPattern ? route.requestPattern.slice(0, route.requestPattern.indexOf(":")) + "*" : route.path), ...(options.serverComponents?.routes ?? []).map(pattern => pattern.includes(":") ? pattern.slice(0, pattern.indexOf(":")) + "*" : pattern)], path.relative(path.resolve(vite.root, profile.backendOutDir), process.env.FUZOR_STAGE_DIR && outDir.startsWith(path.resolve(process.env.FUZOR_STAGE_DIR) + path.sep) ? path.resolve(vite.root, path.relative(process.env.FUZOR_STAGE_DIR, outDir)) : outDir).split(path.sep).join("/"));
+                        await writeCloudflareOutput(serverDir, vite.root, target, pathBase, outDir, [...compiled.routes.filter(route => route.policy?.rendering === "request").map(route => route.requestPattern ? route.requestPattern.slice(0, route.requestPattern.indexOf(":")) + "*" : route.path)], path.relative(path.resolve(vite.root, profile.backendOutDir), process.env.FUZOR_STAGE_DIR && outDir.startsWith(path.resolve(process.env.FUZOR_STAGE_DIR) + path.sep) ? path.resolve(vite.root, path.relative(process.env.FUZOR_STAGE_DIR, outDir)) : outDir).split(path.sep).join("/"));
                 }
                 const index = searchIndex(compiled, options.searchIndex);
                 if (index)
@@ -1403,7 +1404,7 @@ ${docsInit}${mixedClient ? spaStart + "\nif (!router) {\n" + mpaStart + "\n}" :
             if (nested)
                 return;
             const file = context.file.replaceAll("\\", "/");
-            if (pageScripts.some(script => script.source === file) || options.serverComponents && (file.endsWith(".fragment.html") || options.serverComponents.references && file.startsWith(path.resolve(vite.root, options.serverComponents.references) + path.sep) || file === path.resolve(vite.root, options.serverComponents.server) || options.serverComponents.client && file === path.resolve(vite.root, options.serverComponents.client)) || ["/pages/", "/components/", "/layouts/", "/islands/", "/api/"].some((part) => file.includes(part))) {
+            if (pageScripts.some(script => script.source === file) || ["/pages/", "/components/", "/layouts/", "/islands/", "/api/"].some((part) => file.includes(part))) {
                 const environment = context.environment?.name;
                 if (environment)
                     invalidateEnvironmentModule(context.server, resolvedVirtualId, environment, environmentApiEnabled);