@jxsuite/compiler 6.1.0 → 8.0.0

package/src/site/schema-command.ts

@@ -24,7 +24,7 @@ import {
   flattenSchema,
 } from "@jxsuite/schema/project-schemas";
 import { isJsonObject } from "@jxsuite/schema/guards";
-import { buildProjectExtensionRegistry } from "./format-host.ts";
+import { buildProjectExtensionRegistry, resolveFromProject } from "./format-host.ts";
 import { loadProjectConfig } from "./site-loader.ts";
 import type { ExtensionInfo } from "@jxsuite/schema/extension-registry";
 import type { SchemaJsonLoader } from "@jxsuite/schema/project-schemas";
@@ -156,21 +156,24 @@ function readSchemaFile(path: string): JsonObject {
   return parsed;
 }
 
-/** Packages whose schemas define the Jx document contract itself, never a project's own content. */
-const FIRST_PARTY_SCHEMA_SCOPE = "@jxsuite/";
+/**
+ * The package whose schemas define the Jx document contract itself. Only the core: an extension's
+ * fragments, first-party ones included, are the project's (specs/extensions.md §5.4).
+ */
+const CORE_SCHEMA_SCOPE = "@jxsuite/schema/";
 
 /**
- * Is this specifier one of the shipped core schemas, as opposed to a project-local fragment?
+ * Is this specifier one of the shipped core schemas, as opposed to an extension's fragment?
  *
  * @param {string} specifier - Bare specifier, e.g. `@jxsuite/schema/schema.json`
  * @returns {boolean}
  */
-export function isFirstPartySchema(specifier: string): boolean {
-  return specifier.startsWith(FIRST_PARTY_SCHEMA_SCOPE) && specifier.endsWith(".json");
+export function isCoreSchema(specifier: string): boolean {
+  return specifier.startsWith(CORE_SCHEMA_SCOPE) && specifier.endsWith(".json");
 }
 
 /**
- * Resolve a first-party schema from the HOST — the workspace running the generator.
+ * Resolve the core schema from the HOST — the workspace running the generator.
  *
  * Throws rather than falling back to the project, because a fallback is exactly the behaviour that
  * let a stale published core answer for the workspace one. A generator that cannot find its own
@@ -185,7 +188,7 @@ function hostResolve(specifier: string, path: string): string {
     return createRequire(import.meta.url).resolve(specifier);
   } catch (error) {
     throw new Error(
-      `Schema ref "${path}" names the first-party schema "${specifier}", which must resolve from ` +
+      `Schema ref "${path}" names the core schema "${specifier}", which must resolve from ` +
         `the host workspace and does not. The project's own copy is deliberately not consulted, so ` +
         `the host install is missing "${specifier.split("/").slice(0, 2).join("/")}" — check that ` +
         `the package ships with this build`,
@@ -195,9 +198,10 @@ function hostResolve(specifier: string, path: string): string {
 }
 
 /**
- * Bundler loader restricted to the project root, with the validate-project host fallback: a missing
- * `<root>/node_modules/<specifier>` file resolves the specifier project-first, then through the
- * host (workspace symlinks resolve transparently).
+ * Bundler loader restricted to the project root. The core schema comes from the host; every other
+ * `<root>/node_modules/<specifier>` ref that is not on disk at that path resolves through the
+ * project's own module resolution (workspace symlinks and hoisted installs resolve transparently)
+ * and never through the host's, because an extension's fragments are the project's to supply.
  *
  * Exported for test: both refusals below are reachable only through a project whose `node_modules`
  * has been arranged to provoke them, and a fixture that arranges an extension registry as well says
@@ -217,9 +221,9 @@ export function restrictedSchemaLoader(root: string): SchemaJsonLoader {
     const marker = "node_modules/";
     const markerIndex = posixRel.lastIndexOf(marker);
     const specifier = markerIndex === -1 ? null : posixRel.slice(markerIndex + marker.length);
-    // A FIRST-PARTY core comes from the host, always — before the project-local file is even
-    // Looked at. A project may legitimately carry its own fragments, which is what the rest of this
-    // Loader is for; what it may not do is answer for `@jxsuite/schema` itself.
+    // The core comes from the host, always — before the project-local file is even looked at. A
+    // Project supplies every extension's fragments, first-party ones included, which is what the
+    // Rest of this loader is for; what it may not do is answer for `@jxsuite/schema` itself.
     //
     // This is not hypothetical. A stray `bun install` in packages/starters/sites/shop left a
     // Gitignored node_modules holding @jxsuite/schema@0.35.0 beside a 1.5.0 workspace, and BOTH the
@@ -230,7 +234,7 @@ export function restrictedSchemaLoader(root: string): SchemaJsonLoader {
     // Shop's own pages/products/[sku].json invalid against its own committed schema. Nothing
     // Noticed for six weeks, because the artifact was only ever regenerated on the machine that
     // Had the shadow.
-    if (specifier !== null && isFirstPartySchema(specifier)) {
+    if (specifier !== null && isCoreSchema(specifier)) {
       return readSchemaFile(hostResolve(specifier, path));
     }
     if (existsSync(abs)) {
@@ -241,19 +245,13 @@ export function restrictedSchemaLoader(root: string): SchemaJsonLoader {
     }
     let resolved: string;
     try {
-      const projRequire = createRequire(resolve(root, "package.json"));
-      resolved = projRequire.resolve(specifier);
-    } catch {
-      try {
-        const selfRequire = createRequire(import.meta.url);
-        resolved = selfRequire.resolve(specifier);
-      } catch (error) {
-        throw new Error(
-          `Schema ref "${path}" does not exist and "${specifier}" is not resolvable from the ` +
-            `project or the host`,
-          { cause: error },
-        );
-      }
+      resolved = resolveFromProject(root, specifier);
+    } catch (error) {
+      throw new Error(
+        `Schema ref "${path}" does not exist and "${specifier}" is not resolvable from the ` +
+          `project — is the package installed?`,
+        { cause: error },
+      );
     }
     return readSchemaFile(resolved);
   };

package/src/site/server-entries.ts

@@ -0,0 +1,118 @@
+/**
+ * Server-entries.ts — where the site worker's `timing: "server"` entries come from.
+ *
+ * Every document that can declare a server entry is read as written: the page, each layout in its
+ * chain, `project.json`'s `state` (which every page inherits) and every compiled component
+ * (compiler.md §6.3, site-architecture.md §14.1.1). The merged page cannot stand in for them,
+ * because layout resolution merges state and splices children, and after that nothing records which
+ * file a relative `$src` was written against.
+ *
+ * A relative `$src` (`./`, `../`) resolves against the directory of the document that declares it,
+ * and the worker receives it as a `./` path from the project root, because the worker bundle
+ * resolves every import from there (compiler.md §12). Any other specifier, a package export most
+ * often, is kept as written and resolves from the root unchanged.
+ *
+ * Each entry is served at `/_jx/server/<export>`, so an export name is one function across the
+ * whole site. One module that several documents declare is one route; two different modules
+ * exporting one name cannot both be served, and a page calling the one left out would silently
+ * receive the other's answer, so that is an error rather than a choice made for the author.
+ *
+ * @docs framework/site/deployment
+ */
+
+import { dirname, relative, resolve, sep } from "node:path";
+import { collectServerEntries } from "../shared.ts";
+import type { JxElement } from "@jxsuite/schema/types";
+
+/** One `timing: "server"` entry as one document declares it, before deduplication. */
+export interface ServerEntryRecord {
+  /** The `$export`: the name the worker imports and the route it registers it under. */
+  exportName: string;
+  /** The specifier the worker imports, resolvable from the project root. */
+  src: string;
+  /** The declaring document, project-relative with `/` separators (`layouts/base.json`). */
+  declaredIn: string;
+}
+
+/** What {@link dedupeServerEntries} hands the site worker: its routes, and a message for each clash. */
+export interface DedupedServerEntries {
+  /** One entry per export name, the `{ exportName, src }` pairs `compileSiteServer` imports. */
+  entries: { exportName: string; src: string }[];
+  /** One message per export name that two or more different modules claim. */
+  errors: string[];
+}
+
+/** `path` relative to the project root, with `/` separators whatever the platform's own. */
+function projectRelative(path: string, projectRoot: string): string {
+  return relative(projectRoot, path).split(sep).join("/");
+}
+
+/**
+ * The specifier the worker imports for a `$src` written in a document under `docDir`.
+ *
+ * A `./` or `../` path is resolved against `docDir` and returned as a `./` path from the project
+ * root, in POSIX form so the generated import is valid on every platform. Anything else is returned
+ * as written.
+ */
+export function resolveServerSrc(src: string, docDir: string, projectRoot: string): string {
+  if (!src.startsWith("./") && !src.startsWith("../")) {
+    return src;
+  }
+  return `./${projectRelative(resolve(docDir, src), projectRoot)}`;
+}
+
+/**
+ * Every server entry one document declares, in document order, each `src` resolved against the
+ * document's own directory and each record naming the document.
+ */
+export function documentServerEntries(
+  doc: JxElement,
+  docPath: string,
+  projectRoot: string,
+): ServerEntryRecord[] {
+  const docDir = dirname(docPath);
+  const declaredIn = projectRelative(docPath, projectRoot);
+  return collectServerEntries(doc).map((entry) => ({
+    exportName: entry.exportName,
+    src: resolveServerSrc(entry.src, docDir, projectRoot),
+    declaredIn,
+  }));
+}
+
+/**
+ * One entry per export name, the list the site worker serves, plus one error per export name that
+ * two or more different modules claim.
+ *
+ * Export names keep the order they were first seen in. A name declared by several documents for the
+ * same module is one entry and no message. A name two modules claim keeps the first module, so the
+ * worker can still be written, and its error names every module with the first document that
+ * declared it.
+ */
+export function dedupeServerEntries(records: readonly ServerEntryRecord[]): DedupedServerEntries {
+  // Export name → each distinct module claiming it → the first document declaring that module.
+  const claims = new Map<string, Map<string, string>>();
+  for (const { exportName, src, declaredIn } of records) {
+    const modules = claims.get(exportName) ?? new Map<string, string>();
+    claims.set(exportName, modules);
+    if (!modules.has(src)) {
+      modules.set(src, declaredIn);
+    }
+  }
+
+  const entries: { exportName: string; src: string }[] = [];
+  const errors: string[] = [];
+  for (const [exportName, modules] of claims) {
+    const claimed = [...modules];
+    entries.push({ exportName, src: claimed[0]![0] });
+    if (claimed.length > 1) {
+      const named = claimed.map(([src, declaredIn]) => `${src} (declared in ${declaredIn})`);
+      errors.push(
+        `Server function "${exportName}" is exported by ${claimed.length} different modules: ` +
+          `${named.join(", ")}. The site worker serves one function per export name, at ` +
+          `/_jx/server/${exportName}, so a call meant for any but the first would get the first's ` +
+          `answer. Rename the export in all but one module, and the $export that names it.`,
+      );
+    }
+  }
+  return { entries, errors };
+}

package/src/site/site-build.ts

@@ -68,20 +68,22 @@ import { collectAssetRefs, copyMountedAssets, loadAssetMounts } from "./asset-mo
 import type { AssetMount } from "@jxsuite/schema/asset-paths";
 import type { FormatEntry, FormatRegistry } from "@jxsuite/schema/format-registry";
 import type { ExtensionRegistry } from "@jxsuite/schema/extension-registry";
-import { resolveLayout } from "./layout-resolver.ts";
+import { layoutChain, resolveLayout } from "./layout-resolver.ts";
+import { dedupeServerEntries, documentServerEntries } from "./server-entries.ts";
+import type { DedupedServerEntries, ServerEntryRecord } from "./server-entries.ts";
 import { mergeHead, renderHead, withPageDescription } from "@jxsuite/site/head-merger";
 import { unregisteredHeadRelations } from "./link-relations.ts";
 import { injectContext } from "./context-injection.ts";
-import { compile, compileServer, compileSiteServer } from "../compiler.ts";
+import { compile, compileSiteServer } from "../compiler.ts";
 import type { CompileOptions } from "../compiler.ts";
 import { compileElement } from "../targets/compile-element.ts";
 import type { CompileElementOptions } from "../targets/compile-element.ts";
+import { serverRoutePrefix } from "../targets/compile-server.ts";
 import type { SiteConnectorSpec, SiteMountSpec } from "../targets/compile-server.ts";
 import {
   buildComponentCSS,
   buildInitialScope,
   buildInstanceScope,
-  collectServerEntries,
   collectStyles,
   colorSchemePrePaintScript,
   createSlotFill,
@@ -171,6 +173,13 @@ declare module "@jxsuite/schema/format-registry" {
   }
 }
 
+/**
+ * The remedy both adapter errors give: a dynamic section and a server function are served by the
+ * same worker, so a project that declares either needs one of the same four adapters.
+ */
+const ADAPTER_REMEDY =
+  'set build.adapter to "cloudflare-workers", "cloudflare-pages", "node", or "bun".';
+
 /**
  * Build an entire Jx site from a project directory.
  *
@@ -364,8 +373,7 @@ export async function buildSite(
       .join(", ");
     throw new Error(
       `project.json declares dynamic section(s) ${sections} served by extension mounts, but ` +
-        `build.adapter is "static". Dynamic tables need a server-capable adapter — set ` +
-        `build.adapter to "cloudflare-workers", "cloudflare-pages", "node", or "bun".`,
+        `build.adapter is "static". Dynamic tables need a server-capable adapter — ${ADAPTER_REMEDY}`,
     );
   }
 
@@ -445,6 +453,8 @@ export async function buildSite(
   const compiledComponentTags: string[] = [];
   const componentCSS = new Map<string, string>(); // TagName → CSS text
   const componentDefs = new Map<string, JxElement>(); // TagName → parsed component definition
+  // TagName → the absolute path its definition was read from, for what is relative to that file.
+  const componentPathByTag = new Map<string, string>();
   if (existsSync(componentsDir)) {
     log("Compiling components...");
     const componentExtensions = [".json", ...formatRegistry.documentExtensions("component")];
@@ -478,6 +488,9 @@ export async function buildSite(
      * served from a path does not have.
      */
     const componentBase = siteBasePath(projectConfig.url);
+    // A component's server-function call is written into its module, which no later pass rewrites,
+    // So it is given the deployment base now (site-architecture.md §14.7).
+    const serverBaseUrl = serverRoutePrefix(componentBase);
 
     for (const file of componentFiles) {
       try {
@@ -491,6 +504,7 @@ export async function buildSite(
           },
           rewriteSrc: (specifier: string, docDir: string | null) =>
             withBase(componentBase, rewriteSidecarSrc(specifier, docDir)),
+          serverBaseUrl,
         };
         if (projectConfig.$media) {
           elementOptions.$media = projectConfig.$media;
@@ -528,6 +542,7 @@ export async function buildSite(
         const doc = await readPageDocument(componentPath, formatRegistry);
         if (doc.tagName) {
           componentDefs.set(doc.tagName, doc);
+          componentPathByTag.set(doc.tagName, componentPath);
           const componentShadow = resolveShadowMode(doc, projectConfig.defaults);
           const css = buildComponentCSS(
             doc.tagName,
@@ -561,19 +576,31 @@ export async function buildSite(
     );
   }
 
-  // ── 5b. Collect server entries from components (for site-wide bundling) ──
-  const siteServerEntries: { exportName: string; src: string }[] = [];
-  if (projectConfig.build.adapter) {
-    for (const [, doc] of componentDefs) {
-      const entries = collectServerEntries(doc);
-      for (const entry of entries) {
-        const resolvedSrc = `./components/${entry.src.replace(/^\.\//, "")}`;
-        siteServerEntries.push({
-          exportName: entry.exportName,
-          src: resolvedSrc,
-        });
-      }
-    }
+  // ── 5b. Collect server entries ──────────────────────────────────────────
+  /*
+   * Every `timing: "server"` entry the site declares, before deduplication: each compiled
+   * component's here, then `project.json`'s `state`, which every page that does not shadow a key
+   * inherits (site-architecture.md §3.2), then each route's page and the layouts it is wrapped in,
+   * pushed as the route compiles. Each document is read as written, so a relative `$src` resolves
+   * against the file that declares it (`server-entries.ts`). Collected whatever the adapter; step
+   * 6c deduplicates and serves them when there is one.
+   */
+  const siteServerEntries: ServerEntryRecord[] = [];
+  for (const [tag, doc] of componentDefs) {
+    siteServerEntries.push(
+      ...documentServerEntries(doc, componentPathByTag.get(tag)!, projectRoot),
+    );
+  }
+  if (projectConfig.state) {
+    siteServerEntries.push(
+      ...documentServerEntries(
+        /* SAFETY: `ProjectConfig.state` is a plain record of state entries, and the collector reads
+           only a document's `state`, so a document carrying that one member is all it needs. */
+        { state: projectConfig.state } as JxElement,
+        resolve(projectRoot, "project.json"),
+        projectRoot,
+      ),
+    );
   }
 
   // ── 6. Compile each route ───────────────────────────────────────────────
@@ -741,6 +768,7 @@ export async function buildSite(
         runtimeImports,
         registerElementBundle,
       );
+      siteServerEntries.push(...result.serverEntries);
 
       for (const relation of result.unregisteredRelations) {
         if (!warnedRelations.has(relation)) {
@@ -877,13 +905,6 @@ export async function buildSite(
         writeFileSync(filePath, file.content, "utf8");
         fileCount += 1;
       }
-
-      // Write server handler if present
-      if (result.serverHandler) {
-        const serverPath = resolve(dirname(outPath), "_server.js");
-        writeFileSync(serverPath, result.serverHandler, "utf8");
-        fileCount += 1;
-      }
     } catch (error) {
       const msg = `Error compiling ${route.urlPattern}: ${errorMessage(error)}`;
       errors.push(msg);
@@ -909,15 +930,47 @@ export async function buildSite(
   }
 
   // ── 6c. Generate site-wide server worker ────────────────────────────────
+  // What the worker serves, handed back to the caller: `jx dev` answers the same routes from it.
+  // Empty with no adapter, where nothing is served (compiler.md §6.3).
+  let serverEntries: DedupedServerEntries["entries"] = [];
+  /*
+   * A server function is served by the site worker and by nothing else, so with no adapter its
+   * entry has no route, and a page built that way would ship without the value it declared. It is
+   * an error as an active mount is, but a server entry is only known once each page's layout is
+   * resolved, which is after `dist/` is cleaned: the error goes into `errors`, so the pages are
+   * still written and `jx dev` still serves them, and `jx build` exits non-zero. `siteServerEntries`
+   * holds one record per document that declares an entry, a shared layout's once per page using it,
+   * so each distinct export and document is named once, in the order first seen.
+   */
+  if (!projectConfig.build.adapter && siteServerEntries.length > 0) {
+    const named = [
+      ...new Set(
+        siteServerEntries.map(({ exportName, declaredIn }) => `${exportName} (${declaredIn})`),
+      ),
+    ];
+    const message =
+      `timing: "server" entries ${named.join(", ")} need a server-capable adapter, but ` +
+      `build.adapter is "static": a static deployment has nothing to serve /_jx/server — ${
+        ADAPTER_REMEDY
+      }`;
+    errors.push(message);
+    console.error(message);
+  }
   if (projectConfig.build.adapter) {
     const { adapter } = projectConfig.build;
     log("Generating site-wide server worker...");
 
-    const deduped = new Map<string, { exportName: string; src: string }>();
-    for (const entry of siteServerEntries) {
-      if (!deduped.has(entry.exportName)) {
-        deduped.set(entry.exportName, entry);
-      }
+    /*
+     * One route per export name (compiler.md §6.3). Two modules claiming one name is a build
+     * error, not a silent choice: the worker can serve only one of them, and a page calling the
+     * other would receive its answer. The first module is still kept, so the worker is written
+     * and `jx dev` keeps serving the pages while the author renames one.
+     */
+    const { entries: dedupedEntries, errors: clashErrors } = dedupeServerEntries(siteServerEntries);
+    serverEntries = dedupedEntries;
+    for (const error of clashErrors) {
+      errors.push(error);
+      console.error(error);
     }
 
     // Extension server mounts: static imports of the mount modules and used connector classes,
@@ -932,10 +985,11 @@ export async function buildSite(
     // Cloudflare Pages uses advanced mode (_worker.js inside the build output) — the
     // Functions/ directory convention only works from the project root, not from dist/.
     // A static-only Pages site needs no worker at all; sites with mounts always get one.
-    const skipWorker = adapter === "cloudflare-pages" && deduped.size === 0 && mounts.length === 0;
+    const skipWorker =
+      adapter === "cloudflare-pages" && serverEntries.length === 0 && mounts.length === 0;
     const workerSource = skipWorker
       ? null
-      : compileSiteServer([...deduped.values()], {
+      : compileSiteServer(serverEntries, {
           adapter,
           base: basePath,
           connectors,
@@ -955,7 +1009,7 @@ export async function buildSite(
           projectRoot,
         });
         fileCount += 1;
-        log(`  Generated dist/${workerName} (bundled, ${deduped.size} server function(s))`);
+        log(`  Generated dist/${workerName} (bundled, ${serverEntries.length} server function(s))`);
       } catch (error) {
         const msg = `Error bundling dist/${workerName}: ${errorMessage(error)}`;
         errors.push(msg);
@@ -966,12 +1020,18 @@ export async function buildSite(
         // Only invoke the worker for server routes; everything else stays static.
         writeFileSync(
           resolve(outDir, "_routes.json"),
-          // `/` joins the include list only when there is a locale to negotiate: Pages invokes
-          // The worker for included paths only, so an uninvoked middleware is an inert one.
+          /*
+           * `/` joins the include list only when there is a locale to negotiate: Pages invokes the
+           * worker for included paths only, so an uninvoked middleware is an inert one. Both carry
+           * the deployment base, because Pages matches them against the request path, and the
+           * worker's own routes are registered under it (site-architecture.md §14.7).
+           */
           `${JSON.stringify(
             {
               exclude: [],
-              include: i18n && i18n.locales.length > 1 ? ["/", "/_jx/*"] : ["/_jx/*"],
+              include: (i18n && i18n.locales.length > 1 ? ["/", "/_jx/*"] : ["/_jx/*"]).map(
+                (pattern) => withBase(basePath, pattern),
+              ),
               version: 1,
             },
             null,
@@ -1283,7 +1343,7 @@ export async function buildSite(
     log(`  ${errors.length} error(s)`);
   }
 
-  return { errors, files: fileCount, routes: routes.length };
+  return { errors, files: fileCount, routes: routes.length, serverEntries };
 }
 
 /** The route `compilePage` renders: a URL and the page document that produces it. */
@@ -1308,7 +1368,7 @@ interface PageRoute {
  * @returns {Promise<{
  *   html: string;
  *   files: { path: string; content: string; tagName?: string }[];
- *   serverHandler: string | null;
+ *   serverEntries: ServerEntryRecord[];
  *   doc: JxDocument;
  * }>}
  *   Every parameter is required. There is exactly one caller and it passes all fifteen, so the
@@ -1344,6 +1404,19 @@ async function compilePage(
   // Resolve layout (wraps page in layout with slot distribution)
   const layoutDoc = await resolveLayout(pageDoc, projectConfig, projectRoot);
 
+  /*
+   * This page's and its layouts' server entries, each read from the file that declares it, so a
+   * relative `$src` resolves against that file (compiler.md §6.3). Read here, before
+   * `injectContext`: with no layout `resolveLayout` hands back `pageDoc` itself, and injection
+   * then adds project.json's state to it, which `buildSite` collects once, as project.json's own.
+   */
+  const serverEntries = [
+    ...documentServerEntries(pageDoc, route.sourcePath, projectRoot),
+    ...layoutChain(pageDoc, projectConfig, projectRoot).flatMap((level) =>
+      documentServerEntries(level.doc, level.path, projectRoot),
+    ),
+  ];
+
   // Extract head arrays before they get lost in the merge
   /* SAFETY: `_pageHead` is written only by `resolveLayout`, which copies the page's `$head` (a
      JxHeadEntry[]) into it when the page has one. */
@@ -1559,6 +1632,8 @@ async function compilePage(
      */
     rewriteSrc: (specifier: string) =>
       withBase(basePath, rewriteSidecarSrc(specifier, dirname(route.sourcePath))),
+    // The page's own module calls the worker's routes, under the same base the worker registers.
+    serverBaseUrl: serverRoutePrefix(basePath),
     title,
   };
   /*
@@ -1616,19 +1691,6 @@ async function compilePage(
     result.html = injectNpmElementScripts(result.html, registerElementBundle(npmElements));
   }
 
-  // Compile server handler if applicable (skip when provider bundles site-wide)
-  let serverHandler: string | null = null;
-  if (!projectConfig.build.adapter) {
-    try {
-      const serverResult = await compileServer(route.sourcePath);
-      if (serverResult) {
-        serverHandler = serverResult;
-      }
-    } catch {
-      // No server entries — that's fine
-    }
-  }
-
   return {
     doc: layoutDoc,
     // A page opts out of the sitemap by setting `$sitemap: false` (interim escape hatch
@@ -1642,7 +1704,7 @@ async function compilePage(
      * say it once instead of four hundred times.
      */
     unregisteredRelations: unregisteredHeadRelations(mergedHead),
-    serverHandler,
+    serverEntries,
   };
 }