@phis/ui 0.2.0 → 0.3.0

package/next/area-route.d.ts

@@ -1,6 +1,7 @@
 import "server-only";
 import type { Metadata } from "next";
 import type { PhiCmsErrorPageProps } from "../components/cms/phi-cms-error-page";
+import { type PhiCmsRootErrorPageLoader } from "../components/cms/phi-cms-deferred-error-page";
 import { type PhiCmsAreaChrome } from "../components/cms/phi-cms-root-layout";
 import { PhiCmsRootSlotPage } from "../components/cms/phi-cms-root-slot-page";
 import type { PhiCmsSiteBridge } from "../types/cms-plugins";
@@ -102,7 +103,7 @@ export type PhiNextRootErrorArea = {
  * the Public landing page's script payload with them. Deciding here rather than redirecting still
  * keeps both the status line and the address the visitor asked for.
  */
-export declare function createPhiNextRootErrorPage(code: PhiCmsErrorPageProps["code"], area: PhiNextRootErrorArea): () => Promise<import("react").JSX.Element>;
+export declare function createPhiNextRootErrorPage(code: PhiCmsErrorPageProps["code"], loadErrorPage: PhiCmsRootErrorPageLoader): () => import("react").JSX.Element;
 /** The Public Area's boundary. Its root segment is a locale, so it only reaches it through `params`. */
 export declare function createPhiNextDynamicRootBoundary(cmsBridge: PhiCmsSiteBridge, Provider?: React.ComponentType<{
     children: React.ReactNode;
@@ -129,7 +130,16 @@ type PhiNextStaticPublicLayoutProps = PhiNextStaticAreaLayoutProps & {
     }>;
 };
 /** One branch of the static tree: the Area boundary and the Shell, for the page its segments name. */
-export declare function createPhiNextStaticPublicLayout(cmsBridge: PhiCmsSiteBridge, chrome?: PhiCmsAreaChrome): ({ children, headerBottom, hero, siderRight, footerTop, drawer, params, }: PhiNextStaticPublicLayoutProps) => Promise<import("react").JSX.Element>;
+export declare function createPhiNextStaticPublicLayout(cmsBridge: PhiCmsSiteBridge, chrome: PhiCmsAreaChrome, 
+/**
+ * The Client boundary of the Public Area, mounted here as the dynamic tree mounts it in its `[root]`
+ * Layout. Mounted in the root Layout instead, the Widget clients it loads were split against what the
+ * root segment alone holds, and every one carried its own copy of what the deeper segments already
+ * load: 37 kB gzip more on an anonymous `/de` than on a signed-in one (AUDIT-2026-10-13, PM14).
+ */
+Provider: React.ComponentType<{
+    children: React.ReactNode;
+}>): ({ children, headerBottom, hero, siderRight, footerTop, drawer, params, }: PhiNextStaticPublicLayoutProps) => Promise<import("react").JSX.Element>;
 export declare function createPhiNextStaticPublicPage(cmsBridge: PhiCmsSiteBridge): {
     Page: ({ params }: PhiNextDynamicRootPageProps) => Promise<import("react").JSX.Element>;
     generateMetadata: ({ params }: PhiNextDynamicRootPageProps) => Promise<Metadata>;
@@ -141,7 +151,11 @@ export declare function createPhiNextStaticPublicSlotPage(cmsBridge: PhiCmsSiteB
  * Next gives a `not-found.tsx` no params, so the Site's file reads the locale from `next/root-params` --
  * a module whose getters Next generates from that Site's own segment names -- and hands it in.
  */
-export declare function createPhiNextStaticPublicNotFound(cmsBridge: PhiCmsSiteBridge): ({ locale }: {
+export declare function createPhiNextStaticPublicNotFound(cmsBridge: PhiCmsSiteBridge, 
+/** The Public Area's Client boundary, which the root Layout no longer holds; see the Layout above. */
+Provider: React.ComponentType<{
+    children: React.ReactNode;
+}>): ({ locale }: {
     locale: string;
 }) => import("react").JSX.Element;
 export {};

package/next/area-route.js

@@ -5,6 +5,7 @@ import { buildPhiAreaPageMetadata } from "../helpers/phi-metadata";
 import { resolvePhiSitePublicBase } from "../helpers/phi-seo";
 import { readPhiSiteRuntimeConfigSync } from "../helpers/site-runtime";
 import { PhiCmsErrorPage } from "../components/cms/phi-cms-error-page";
+import { PhiCmsDeferredErrorPage, } from "../components/cms/phi-cms-deferred-error-page";
 import { PhiCmsAreaBoundary, PhiCmsAreaShell, } from "../components/cms/phi-cms-root-layout";
 import { PhiCmsRootPage } from "../components/cms/phi-cms-root-page";
 import { PhiThemeBlockCatalogProvider } from "../components/root/phi-theme-block-catalog-provider";
@@ -120,24 +121,22 @@ export function createPhiNextStaticAreaSlotPage(root, cmsBridge, regionType) {
  * the Public landing page's script payload with them. Deciding here rather than redirecting still
  * keeps both the status line and the address the visitor asked for.
  */
-export function createPhiNextRootErrorPage(code, area) {
-    const { loadBridge, Boundary } = area;
-    return async function PhiNextRootErrorPage() {
-        const cmsBridge = await loadBridge();
-        /*
-         * A refusal draws no Shell at all, and asks for none later.
-         *
-         * Next renders every refusal boundary of the matched segments into the response whether one is
-         * shown or not, so a Shell resolved here was paid for by every successful Page as well -- measured
-         * at three resolutions and roughly 56 KB per request, for output almost no visitor sees. Fetching
-         * it from the client afterwards moved that cost rather than removing it, and bought a page that
-         * changed shape after it had appeared.
-         *
-         * The Client boundary is still mounted, because the error page renders a page tree like any other
-         * and cannot resolve its Runtime Module Clients without one. What the visitor loses is the
-         * navigation, which is why the 404 result carries a link to the Area root.
-         */
-        return (_jsx(Boundary, { children: _jsx(PhiCmsErrorPage, { code: code, cmsBridge: cmsBridge, area: "public" }) }));
+export function createPhiNextRootErrorPage(code, loadErrorPage) {
+    /*
+     * A refusal draws no Shell at all, and resolves its page only once it is shown.
+     *
+     * Next renders every refusal boundary of the matched segments into the response whether one is
+     * shown or not. A Shell resolved here was paid for by every successful Page -- measured at three
+     * resolutions and roughly 56 KB per request -- and so was the error page itself: Area and Page for
+     * 404, 403 and 401, six of the sixteen server calls of a plain page view (measured 03.10.2026). The
+     * route now carries a code and the Site's Action; the page is rendered when a refusal is on screen
+     * (`PhiCmsDeferredErrorPage`, `renderPhiCmsRootErrorPage`), and the plain copy stands until then.
+     *
+     * What the visitor loses is the navigation, which is why the 404 result carries a link to the Area
+     * root, and the moment before the Site's page arrives -- on a page that answers almost no request.
+     */
+    return function PhiNextRootErrorPage() {
+        return _jsx(PhiCmsDeferredErrorPage, { code: code, load: loadErrorPage });
     };
 }
 /** The Public Area's boundary. Its root segment is a locale, so it only reaches it through `params`. */
@@ -200,11 +199,18 @@ export function createPhiNextDynamicRootSlotPage(cmsBridge, regionType) {
     };
 }
 /** One branch of the static tree: the Area boundary and the Shell, for the page its segments name. */
-export function createPhiNextStaticPublicLayout(cmsBridge, chrome = "shell") {
+export function createPhiNextStaticPublicLayout(cmsBridge, chrome, 
+/**
+ * The Client boundary of the Public Area, mounted here as the dynamic tree mounts it in its `[root]`
+ * Layout. Mounted in the root Layout instead, the Widget clients it loads were split against what the
+ * root segment alone holds, and every one carried its own copy of what the deeper segments already
+ * load: 37 kB gzip more on an anonymous `/de` than on a signed-in one (AUDIT-2026-10-13, PM14).
+ */
+Provider) {
     const staticBridge = toPhiStaticCmsSiteBridge(cmsBridge);
     return async function PhiNextStaticPublicLayout({ children, headerBottom, hero, siderRight, footerTop, drawer, params, }) {
         const { root, path } = await params;
-        return (_jsx(PhiCmsAreaBoundary, { root: root, cmsBridge: staticBridge, pagePath: path, children: _jsx(PhiCmsAreaShell, { root: root, cmsBridge: staticBridge, chrome: chrome, pagePath: path, headerBottom: headerBottom, hero: hero, siderRight: siderRight, footerTop: footerTop, drawer: drawer, children: children }) }));
+        return (_jsx(Provider, { children: _jsx(PhiCmsAreaBoundary, { root: root, cmsBridge: staticBridge, pagePath: path, children: _jsx(PhiCmsAreaShell, { root: root, cmsBridge: staticBridge, chrome: chrome, pagePath: path, headerBottom: headerBottom, hero: hero, siderRight: siderRight, footerTop: footerTop, drawer: drawer, children: children }) }) }));
     };
 }
 export function createPhiNextStaticPublicPage(cmsBridge) {
@@ -219,9 +225,11 @@ export function createPhiNextStaticPublicSlotPage(cmsBridge, regionType) {
  * Next gives a `not-found.tsx` no params, so the Site's file reads the locale from `next/root-params` --
  * a module whose getters Next generates from that Site's own segment names -- and hands it in.
  */
-export function createPhiNextStaticPublicNotFound(cmsBridge) {
+export function createPhiNextStaticPublicNotFound(cmsBridge, 
+/** The Public Area's Client boundary, which the root Layout no longer holds; see the Layout above. */
+Provider) {
     const staticBridge = toPhiStaticCmsSiteBridge(cmsBridge);
     return function PhiNextStaticPublicNotFound({ locale }) {
-        return _jsx(PhiCmsErrorPage, { code: 404, cmsBridge: staticBridge, area: "public", locale: locale });
+        return (_jsx(Provider, { children: _jsx(PhiCmsErrorPage, { code: 404, cmsBridge: staticBridge, area: "public", locale: locale }) }));
     };
 }

package/next/config.d.mts

@@ -0,0 +1,25 @@
+import type { NextConfig } from "next";
+
+/** The specifier the root layout imports Ant Design's structure by. */
+export declare const PHI_ANTD_STATIC_CSS: "@phis/ui/antd-static.css";
+
+/** The root font size the structure's px are converted against; `PHI_REM_ROOT_PX` in `theme/phi-css-vars.ts`. */
+export declare const PHI_ANTD_STATIC_REM_ROOT_PX: number;
+
+/** The structural CSS of every Ant Design component, from the Ant Design installed for `projectDir`. */
+export declare function generatePhiAntdStaticCss(projectDir?: string): {
+  versions: { antd: string; cssinjs: string; icons: string };
+  css: string;
+};
+
+/** The generated file for the Ant Design installed for `projectDir`, written once per input. */
+export declare function ensurePhiAntdStaticCss(projectDir?: string): string;
+
+/**
+ * A Site's `next.config`, with `@phis/ui/antd-static.css` resolved to the structure generated for its
+ * Ant Design. `dir` is the Site's root, the directory its `package.json` is in.
+ */
+export declare function withPhiNextConfig<T extends NextConfig>(
+  nextConfig: T,
+  options?: { dir?: string },
+): T & { turbopack: NonNullable<T["turbopack"]> & { resolveAlias: Record<string, unknown> } };

package/next/config.mjs

@@ -0,0 +1,277 @@
+/**
+ * What a Site's `next.config` takes from this package: the structural CSS of every Ant Design component,
+ * generated from the Ant Design the Site has installed.
+ *
+ * Ant Design emits two kinds of CSS. The structure -- `.ant-btn{padding:...;color:var(--ant-color-text)}`
+ * -- reads every Theme value through a custom property, so it is the same for every Site, Theme and mode.
+ * The custom properties themselves -- `.phi-root-...{--ant-color-primary:...}` -- are what a Theme
+ * decides. The root runs Ant Design with `zeroRuntime`, which drops the structure from rendering and
+ * keeps the properties; this file is where the structure comes from instead. Generating it at runtime
+ * cost about 10 ms of CPU per page view and 40-140 KB of inline CSS per page (measured 04.10.2026).
+ *
+ * The structure changes with the Ant Design version, so it is generated where that version is decided:
+ * in the Site, when its `next.config` is read, once per version. The package ships no copy, and a Site
+ * updates Ant Design within the peer range without waiting for a release of this package. The root
+ * layout imports `@phis/ui/antd-static.css`, which names no file; `withPhiNextConfig` points it at the
+ * one generated here.
+ *
+ * Generated with the configuration the root renders with -- prefix `ant`, unhashed, px2rem at
+ * `PHI_ANTD_STATIC_REM_ROOT_PX` -- so its selectors are the ones the components carry. Every component
+ * is rendered, not only the ones this package uses: a Module that ships its own Ant Design component
+ * (the calendar adapter) relies on the file as much as the Controls do. Generating fails when a style
+ * hook Ant Design declares was not reached -- a part registered only under some prop or token that the
+ * render below does not set yet -- and with it the Site's build: a file missing a part would style that
+ * part with nothing.
+ *
+ * Plain JavaScript, because Next reads `next.config` outside any bundler.
+ */
+
+import { createHash } from "node:crypto";
+import { existsSync, globSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** The specifier the root layout imports the structure by. */
+export const PHI_ANTD_STATIC_CSS = "@phis/ui/antd-static.css";
+
+/** The root font size the structure's px are converted against; `PHI_REM_ROOT_PX` in `theme/phi-css-vars.ts`. */
+export const PHI_ANTD_STATIC_REM_ROOT_PX = 16;
+
+// Components that render nothing of their own, or nothing without a context they cannot have here.
+const SKIPPED = new Set(["ConfigProvider", "Grid"]);
+
+// Declared by Ant Design but not reachable from its exports, so no page can render it.
+const UNREACHABLE_STYLE_HOOKS = new Set(["BackTop-BackTop"]);
+
+/*
+ * Components whose styles are only registered with some props, or by a part that is not rendered
+ * closed. Ported from `@ant-design/static-style-extract`, which is the reference for which parts need
+ * a nudge.
+ */
+function customRenders(antd, h, Fragment) {
+  return {
+    Affix: (Affix) => h(Affix, null, h("div")),
+    Cascader: (Cascader) => h(Fragment, null, h(Cascader), h(Cascader.Panel)),
+    // `Form.Item` brings the field-level fallback styles a bare `Form` never registers.
+    Form: (Form) => h(Form, null, h(Form.Item, { label: "Label" }, h(antd.Input))),
+    Dropdown: (Dropdown) => h(Dropdown, { menu: { items: [] } }, h("div")),
+    Menu: (Menu) => h(Menu, { items: [] }),
+    QRCode: (QRCode) => h(QRCode, { value: "https://phisys.com" }),
+    Tree: (Tree) => h(Tree, { treeData: [] }),
+    Tag: (Tag) => h(Fragment, null, h(Tag, { color: "blue" }, "Tag"), h(Tag, { color: "success" }, "Tag")),
+    Badge: (Badge) => h(Fragment, null, h(Badge), h(Badge.Ribbon)),
+    Space: (Space) => h(Fragment, null,
+      h(Space),
+      h(Space.Compact, null, h(antd.Button), h(Space.Addon, null, "1")),
+    ),
+    Input: (Input) => h(Fragment, null,
+      h(Input),
+      h(Input.Group, null, h(Input), h(Input)),
+      h(Input.Search),
+      h(Input.TextArea),
+      h(Input.Password),
+      h(Input.OTP),
+    ),
+    Modal: (Modal) => h(Fragment, null,
+      h(Modal),
+      h(Modal._InternalPanelDoNotUseOrYouWillBeFired),
+      h(Modal._InternalPanelDoNotUseOrYouWillBeFired, { type: "confirm" }),
+    ),
+    message: (message) => h(message._InternalPanelDoNotUseOrYouWillBeFired),
+    notification: (notification) => h(notification._InternalPanelDoNotUseOrYouWillBeFired),
+    Layout: (Layout) => h(Layout, null,
+      h(Layout.Header, null, "Header"),
+      h(Layout.Sider, null, "Sider"),
+      h(Layout.Content, null, "Content"),
+      h(Layout.Footer, null, "Footer"),
+    ),
+  };
+}
+
+/*
+ * What the structure is generated from, resolved from the Site: its Ant Design, and the React and
+ * CSS-in-JS that Ant Design itself resolves. A second copy of either would leave the render registering
+ * its styles in a cache nobody reads.
+ */
+function resolveSiteAntd(projectDir) {
+  const siteRequire = createRequire(path.join(projectDir, "package.json"));
+  const antdManifest = siteRequire.resolve("antd/package.json");
+  const antdRequire = createRequire(antdManifest);
+  const iconsRequire = createRequire(siteRequire.resolve("@ant-design/icons/package.json"));
+  return {
+    antdRoot: path.dirname(antdManifest),
+    antd: antdRequire("./lib/index.js"),
+    cssinjs: antdRequire("@ant-design/cssinjs"),
+    react: antdRequire("react"),
+    renderToString: antdRequire("react-dom/server").renderToString,
+    iconStyles: iconsRequire("./lib/renderUtils.js").iconStyles,
+    versions: {
+      antd: antdRequire("./package.json").version,
+      cssinjs: antdRequire("@ant-design/cssinjs/package.json").version,
+      icons: iconsRequire("./package.json").version,
+    },
+  };
+}
+
+function renderEveryComponent(antd, h, Fragment) {
+  const custom = customRenders(antd, h, Fragment);
+  return Object.keys(antd)
+    .filter((name) => !SKIPPED.has(name) && (/^[A-Z]/.test(name) || name === "message" || name === "notification"))
+    .sort()
+    .map((name) => h(Fragment, { key: name }, custom[name] ? custom[name](antd[name]) : h(antd[name])));
+}
+
+/*
+ * The style hooks Ant Design declares, read from its sources: `genStyleHooks("Button", ...)` registers
+ * under `Button-Button`, `genSubStyleComponent(["Form", "item-item"], ...)` under `Form-item-item`.
+ */
+function listDeclaredStyleHooks(antdRoot) {
+  const declared = new Set();
+  for (const file of globSync("es/**/style/*.js", { cwd: antdRoot })) {
+    const source = readFileSync(path.join(antdRoot, file), "utf8");
+    for (const match of source.matchAll(/gen(?:StyleHooks|ComponentStyleHook|SubStyleComponent)\((\[[^\]]*\]|'[^']*')/gu)) {
+      const names = [...match[1].matchAll(/'([^']*)'/gu)].map((entry) => entry[1]);
+      declared.add(match[1].startsWith("[") ? names.join("-") : `${names[0]}-${names[0]}`);
+    }
+  }
+  return declared;
+}
+
+/*
+ * The link rules Ant Design shares between all its components, scoped back to them.
+ *
+ * Hashed, Ant Design writes them as `:where(.css-<hash>) a` and `a:where(.css-<hash>)`: a link inside
+ * one of its components, or one of them. Unhashed both lose the scope and become `a` -- a colour,
+ * a transition and an outline on every link of the page, the house's own included. The hash class sat
+ * on every Ant Design element, as an `ant-` class does, so the scope is put back as that.
+ */
+const ANTD_ELEMENT = ':where([class^="ant-"],[class*=" ant-"])';
+const LINK_SELECTOR = /^a(?:[:[][^\s,>+~]*)?$/u;
+
+function scopeSharedLinkRules(css) {
+  const seen = new Set();
+  return css.replace(/(?<=^|\})([^{}@]+)\{([^{}]*)\}/gu, (rule, selectorList, body) => {
+    const selectors = selectorList.split(",");
+    if (!selectors.every((selector) => LINK_SELECTOR.test(selector))) return rule;
+    // The descendant and the self form arrive as two copies of one rule; one scoped copy covers both.
+    const scoped = selectors.flatMap((selector) => [
+      `${ANTD_ELEMENT} ${selector}`,
+      `a${ANTD_ELEMENT}${selector.slice(1)}`,
+    ]).join(",");
+    if (seen.has(scoped + body)) return "";
+    seen.add(scoped + body);
+    return `${scoped}{${body}}`;
+  });
+}
+
+/*
+ * Every component is rendered, the deprecated ones included, and in development Ant Design says so once
+ * per component on `console.error`. Those are about the render here, not about the Site.
+ */
+function withoutDeprecationNotices(render) {
+  const reportError = console.error;
+  console.error = (...args) => {
+    if (typeof args[0] === "string" && args[0].startsWith("Warning: [antd:")) return;
+    reportError(...args);
+  };
+  try {
+    return render();
+  } finally {
+    console.error = reportError;
+  }
+}
+
+/** The structural CSS of every Ant Design component, from the Ant Design installed for `projectDir`. */
+export function generatePhiAntdStaticCss(projectDir = process.cwd()) {
+  const site = resolveSiteAntd(projectDir);
+  const { antd, react } = site;
+  const h = react.createElement;
+  const { createCache, extractStyle, px2remTransformer, StyleProvider } = site.cssinjs;
+  const cache = createCache();
+  const theme = { hashed: false, cssVar: { prefix: "ant", key: "phi-static" } };
+  withoutDeprecationNotices(() => site.renderToString(
+    h(StyleProvider, {
+      cache,
+      transformers: [px2remTransformer({ rootValue: PHI_ANTD_STATIC_REM_ROOT_PX, precision: 5, mediaQuery: false })],
+    },
+    // Unhashed and with `cssVar`, as the root renders; the key names nothing in the structure.
+    h(antd.ConfigProvider, { theme }, renderEveryComponent(antd, h, react.Fragment)),
+    /*
+     * Again with `wireframe`, which a Theme may switch on and which decides whether some parts register
+     * at all (the bordered Pagination). The cache is keyed by component, not by token, so this pass
+     * adds only what the first one did not reach.
+     */
+    h(antd.ConfigProvider, { theme: { ...theme, token: { wireframe: true } } }, renderEveryComponent(antd, h, react.Fragment)),
+    ),
+  ));
+
+  const reached = new Set(
+    [...cache.cache.keys()].filter((key) => key.startsWith("style%")).map((key) => key.split("%")[2]),
+  );
+  const unreached = [...listDeclaredStyleHooks(site.antdRoot)]
+    .filter((hook) => !reached.has(hook) && !UNREACHABLE_STYLE_HOOKS.has(hook))
+    .sort();
+  if (unreached.length > 0) {
+    throw new Error(
+      `Ant Design ${site.versions.antd} declares style hooks the @phis/ui render did not reach: ${unreached.join(", ")}. `
+        + "Render the part that registers each (customRenders in @phis/ui/next/config), or name it in UNREACHABLE_STYLE_HOOKS.",
+    );
+  }
+
+  const structure = scopeSharedLinkRules(extractStyle(cache, { plain: true, types: ["style"] })
+    // The cache-path map tells a runtime cache what the server already rendered; nothing reads it here.
+    .replace(/\.data-ant-cssinjs-cache-path\{content:"[^"]*";\}/, ""));
+  return {
+    versions: site.versions,
+    css: [
+      `/* Generated by @phis/ui/next/config from antd ${site.versions.antd}. Do not edit. */`,
+      site.iconStyles.trim(),
+      structure,
+      "",
+    ].join("\n"),
+  };
+}
+
+/*
+ * The generated file, written once per input. Its name carries what decides its content -- the three
+ * packages it is generated from and this module -- so a Site that updates any of them gets a new file,
+ * and a `next.config` read again, in another worker or on the next start, finds the one it wrote.
+ */
+export function ensurePhiAntdStaticCss(projectDir = process.cwd()) {
+  const site = resolveSiteAntd(projectDir);
+  const key = createHash("sha256")
+    .update(JSON.stringify(site.versions))
+    .update(readFileSync(fileURLToPath(import.meta.url)))
+    .digest("hex")
+    .slice(0, 16);
+  const directory = path.join(projectDir, "node_modules", ".cache", "phis-ui");
+  const file = path.join(directory, `antd-static-${site.versions.antd}-${key}.css`);
+  if (existsSync(file)) return file;
+  const { css } = generatePhiAntdStaticCss(projectDir);
+  mkdirSync(directory, { recursive: true });
+  // Renamed into place, so a worker reading the config at the same moment sees the whole file or none.
+  const pending = `${file}.${process.pid}.tmp`;
+  writeFileSync(pending, css);
+  renameSync(pending, file);
+  return file;
+}
+
+/**
+ * A Site's `next.config`, with `@phis/ui/antd-static.css` resolved to the structure generated for its
+ * Ant Design. `dir` is the Site's root, the directory its `package.json` is in.
+ */
+export function withPhiNextConfig(nextConfig, { dir = process.cwd() } = {}) {
+  // Turbopack takes no absolute path as an alias target; a relative one is read from the Site's root.
+  const file = `./${path.relative(dir, ensurePhiAntdStaticCss(dir)).split(path.sep).join("/")}`;
+  return {
+    ...nextConfig,
+    turbopack: {
+      ...nextConfig.turbopack,
+      resolveAlias: {
+        ...nextConfig.turbopack?.resolveAlias,
+        [PHI_ANTD_STATIC_CSS]: file,
+      },
+    },
+  };
+}

package/next/overlay-zones.js

@@ -9,7 +9,8 @@ import { hasPhiCmsRevisionPreview } from "../server-helpers/cms-root";
 import { materializePhiOverlayRuntimeControllerSettings } from "../components/runtime/runtime-controller-materialization";
 import { PhiRuntimeControllerServerHost } from "../components/runtime/runtime-controller-server-host";
 import { resolvePhiRuntimeControllerDefinitions } from "../plugins/runtime-modules/resolver";
-import { capturePhiRequestRuntimeStore, restorePhiRequestRuntimeStore, runInPhiRequestScope, } from "../server-helpers/request-runtime";
+import { capturePhiRequestRuntimeStore, runInPhiRequestScope } from "../server-helpers/request-runtime";
+import { PhiRestoredRequestRuntime } from "../components/runtime/phi-restored-request-runtime";
 function isOverlayZonesRequest(value) {
     if (typeof value !== "object" || value === null)
         return false;
@@ -19,11 +20,6 @@ function isOverlayZonesRequest(value) {
         (path === null || (Array.isArray(path) && path.every((segment) => typeof segment === "string"))) &&
         typeof overlayId === "string" && overlayId.length > 0;
 }
-/** Puts the request runtime the Action resolved back in place for the render of what it returned. */
-function PhiRestoredRequestRuntime({ captured, children, }) {
-    restorePhiRequestRuntimeStore(captured);
-    return children;
-}
 /**
  * An Area Overlay's zones, rendered for whoever asks -- the body of the Site's Server Action.
  *
@@ -91,7 +87,7 @@ async function renderOverlayZones(loadBridge, request) {
             catalog: cmsBridge.runtimeModuleCatalog,
             moduleSet: runtimeModuleScope.moduleSet,
             settings: controllerSettings,
-        }), controllerModuleIdsByType: runtimeModuleScope.moduleSet.ownerModuleIdByControllerType, runtimeModuleCatalog: scope.runtimeRegistry.runtimeModuleCatalog }));
+        }), controllerModuleIdsByType: runtimeModuleScope.moduleSet.ownerModuleIdByControllerType, runtimeModuleCatalog: scope.runtimeRegistry.runtimeModuleCatalog, serverCapabilities: scope.runtimeRegistry.serverCapabilities }));
     // Next renders the returned nodes after this function has returned, outside the request scope above.
     const captured = capturePhiRequestRuntimeStore();
     const restore = (node) => node == null ? null : (_jsx(PhiRestoredRequestRuntime, { captured: captured, children: node }));

package/next/root-error-page.d.ts

@@ -0,0 +1,15 @@
+import "server-only";
+import type { ReactNode } from "react";
+import type { PhiNextRootErrorArea } from "./area-route";
+/**
+ * The Site's error page for a refusal that is on screen -- the body of the Site's Server Action.
+ *
+ * The root refusal routes render a placeholder that asks for this once it is shown
+ * (`PhiCmsDeferredErrorPage`), so a page view that refuses nothing resolves no error page. The code comes
+ * from a browser and is read as such: anything but 401, 403 or 404 answers null, and the placeholder
+ * keeps its plain copy.
+ *
+ * The Site wraps this in a `"use server"` function, because only the Site holds the root error Area
+ * (`src/runtime-modules/root-error-page.ts`, written by the scaffold).
+ */
+export declare function renderPhiCmsRootErrorPage(area: PhiNextRootErrorArea, code: unknown): Promise<ReactNode>;

package/next/root-error-page.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import "server-only";
+import { PhiCmsErrorPage } from "../components/cms/phi-cms-error-page";
+import { PhiRestoredRequestRuntime } from "../components/runtime/phi-restored-request-runtime";
+import { parsePhiCmsErrorCode } from "../constants/cms-error-pages";
+import { capturePhiRequestRuntimeStore, runInPhiRequestScope } from "../server-helpers/request-runtime";
+/**
+ * The Site's error page for a refusal that is on screen -- the body of the Site's Server Action.
+ *
+ * The root refusal routes render a placeholder that asks for this once it is shown
+ * (`PhiCmsDeferredErrorPage`), so a page view that refuses nothing resolves no error page. The code comes
+ * from a browser and is read as such: anything but 401, 403 or 404 answers null, and the placeholder
+ * keeps its plain copy.
+ *
+ * The Site wraps this in a `"use server"` function, because only the Site holds the root error Area
+ * (`src/runtime-modules/root-error-page.ts`, written by the scaffold).
+ */
+export async function renderPhiCmsRootErrorPage(area, code) {
+    const parsed = parsePhiCmsErrorCode(typeof code === "number" || typeof code === "string" ? code : null);
+    if (parsed == null)
+        return null;
+    return runInPhiRequestScope(async () => {
+        const cmsBridge = await area.loadBridge();
+        const page = await PhiCmsErrorPage({ code: parsed, cmsBridge, area: "public" });
+        // Next renders the returned nodes after this function has returned, outside the request scope above.
+        const captured = capturePhiRequestRuntimeStore();
+        const { Boundary } = area;
+        return (_jsx(PhiRestoredRequestRuntime, { captured: captured, children: _jsx(Boundary, { children: page }) }));
+    });
+}

package/next/root-route.d.ts

@@ -36,10 +36,6 @@ export declare function createPhiNextStaticRootLayout(siteModules: PhiSiteModule
 /** The provider of the Site's Server Action for Overlay zones; see `createPhiNextRootLayout`. */
 OverlayZonesProvider: React.ComponentType<{
     children: React.ReactNode;
-}>, 
-/** The Client boundary of the Public Area, which the dynamic tree mounts in its `[root]` Layout. */
-Boundary: React.ComponentType<{
-    children: React.ReactNode;
 }>): ({ children, params, }: {
     children: React.ReactNode;
     params: Promise<{

package/next/root-route.js

@@ -8,6 +8,7 @@ import { loadPhiThemeBlockCatalog } from "../plugins/runtime-modules/theme/block
 import { collectPhiThemeDescriptorContributions } from "../plugins/runtime-modules/theme-descriptors";
 import { resolvePhiThemeComposition } from "../theme/phi-theme-composition";
 import { composePhiFontCatalogue } from "../theme/phi-font-catalogue";
+import { PHI_REM_ROOT_PX } from "../theme/phi-css-vars";
 import { buildPhiRootMetadata } from "../helpers/phi-metadata";
 import { localizePath } from "../helpers/locale";
 import { readPhiSiteRuntimeConfigSync, } from "../helpers/site-runtime";
@@ -131,9 +132,7 @@ OverlayZonesProvider) {
  */
 export function createPhiNextStaticRootLayout(siteModules, fonts, 
 /** The provider of the Site's Server Action for Overlay zones; see `createPhiNextRootLayout`. */
-OverlayZonesProvider, 
-/** The Client boundary of the Public Area, which the dynamic tree mounts in its `[root]` Layout. */
-Boundary) {
+OverlayZonesProvider) {
     const document = createPhiNextRootDocument(siteModules, fonts);
     return async function PhiNextStaticRootLayout({ children, params, }) {
         const { root, mode } = await params;
@@ -152,7 +151,8 @@ Boundary) {
                 requestedLocale: root,
             }),
         ]);
-        if (resolvedLocale.locale !== root.toLowerCase()) {
+        // Exactly the Site's spelling, as the proxy rewrites only that: `pt-BR` is the segment, not `pt-br`.
+        if (resolvedLocale.locale !== root) {
             notFound();
         }
         return document({
@@ -160,7 +160,7 @@ Boundary) {
             site,
             resolvedLocale,
             browserColorScheme: normalizePhiColorSchemeHint(mode),
-            children: (_jsx(OverlayZonesProvider, { children: _jsx(Boundary, { children: children }) })),
+            children: _jsx(OverlayZonesProvider, { children: children }),
         });
     };
 }
@@ -193,10 +193,9 @@ function createPhiNextRootDocument(siteModules, fonts) {
      */
     themeModePreference = PHI_DEFAULT_THEME_MODE_PREFERENCE, children, }) {
         const blocks = await loadThemeBlocks();
-        const remRootValue = site.theme?.rem?.rootValue ?? 16;
         const themeMode = resolvePhiThemeMode(themeModePreference, browserColorScheme);
         const bootstrapScript = buildPhiThemeModeBootstrapScript(themeModePreference);
-        return (_jsxs("html", { lang: resolvedLocale.intlLocale, "data-phi-theme-mode": themeMode, style: { fontSize: `${remRootValue}px`, colorScheme: themeMode }, suppressHydrationWarning: true, children: [_jsx("head", { children: bootstrapScript ? _jsx(PhiThemeModeBootstrapScript, { source: bootstrapScript }) : null }), _jsx("body", { children: _jsx(PhiRootLayout, { themeModePreference: themeModePreference, browserColorScheme: browserColorScheme, apiBaseUrl: readPhiServerApiCredentials().apiBaseUrl, internalToken: readPhiServerApiCredentials().internalToken, siteKey: runtimeConfig.site.key, site: site, resolvedLocale: resolvedLocale, themePresets: blocks.palettes, themeBlocks: blocks, fontCatalogue: fontCatalogue, children: children }) })] }));
+        return (_jsxs("html", { lang: resolvedLocale.intlLocale, "data-phi-theme-mode": themeMode, style: { fontSize: `${PHI_REM_ROOT_PX}px`, colorScheme: themeMode }, suppressHydrationWarning: true, children: [_jsx("head", { children: bootstrapScript ? _jsx(PhiThemeModeBootstrapScript, { source: bootstrapScript }) : null }), _jsx("body", { children: _jsx(PhiRootLayout, { themeModePreference: themeModePreference, browserColorScheme: browserColorScheme, apiBaseUrl: readPhiServerApiCredentials().apiBaseUrl, internalToken: readPhiServerApiCredentials().internalToken, siteKey: runtimeConfig.site.key, site: site, resolvedLocale: resolvedLocale, themePresets: blocks.palettes, themeBlocks: blocks, fontCatalogue: fontCatalogue, children: children }) })] }));
     };
 }
 export async function PhiNextSiteIndexPage() {

package/next/seo-routes.js

@@ -1,6 +1,5 @@
 import "server-only";
 import { createHash } from "node:crypto";
-import { resolvePhiCmsAreaMask } from "../constants/cms-areas";
 import { resolvePhiCmsPageRedirect } from "../components/cms/phi-cms-page-redirect";
 import { getPublicSiteAreaWithPublishedPages } from "../gateway/site-area";
 import { PHI_AREA_META_PUBLIC_DEFAULTS, readPhiAreaLandingSelection, readPhiAreaMeta, readPhiAreaPublicRoutePaths, } from "../helpers/cms-area-config";
@@ -8,10 +7,10 @@ import { collectPhiSitemapCandidates, renderPhiRobotsTxt, renderPhiSitemapXml, r
 import { createPhiFingerprintCache } from "../helpers/phi-sitemap-cache";
 import { readPhiSiteRuntimeConfigSync } from "../helpers/site-runtime";
 import { compilePhiCmsActiveRouteTable, resolvePhiCmsAreaShellPresetBinding, resolvePhiCmsDescriptorCatalog, } from "../plugins/runtime-modules/descriptor-compiler";
-import { getPhiCmsPage, getPhiExactSiteArea } from "../server-helpers/cms";
-import { resolveActivePresetModuleKeys, resolvePhiCmsRequest } from "../server-helpers/cms-request";
-import { runWithPhiRequestRuntime } from "../server-helpers/request-runtime";
-import { buildPhiBlockRuntime, loadPhiSiteRequestContext } from "../server-helpers/runtime";
+import { getPhiExactSiteArea } from "../server-helpers/cms";
+import { resolveActivePresetModuleKeys } from "../server-helpers/cms-request";
+import { resolvePhiCmsLookup } from "../server-helpers/cms-lookup";
+import { loadPhiSiteRequestContext } from "../server-helpers/runtime";
 import { fetchSiteLocaleConfig } from "../server-helpers/site-locale";
 const PHI_SITEMAP_PATH = "/sitemap.xml";
 /** How many candidates are resolved at once. Each one is a page lookup against the server. */
@@ -77,42 +76,15 @@ async function loadPhiPublicSeoContext(bridge, { withPublishedPages }) {
  * Deciding this from the stored rows instead would be a second copy of those rules, free to drift.
  */
 async function isPhiSitemapCandidateListed(bridge, context, path) {
-    const { siteKey, apiBaseUrl, internalToken } = context.bridgeRuntime;
     const { locale, requestContext } = context;
-    const scopeRuntime = buildPhiBlockRuntime({
-        requestContext,
-        areaMask: resolvePhiCmsAreaMask("public"),
-    });
-    const resolved = await runWithPhiRequestRuntime(scopeRuntime, () => resolvePhiCmsRequest({
-        siteKey,
-        locale,
+    const resolved = await resolvePhiCmsLookup({
+        bridge,
         area: "public",
+        locale,
         path,
         cookieHeader: "",
-        apiBaseUrl,
-        internalToken,
         requestContext,
-        runtimeModuleCatalog: bridge.runtimeModuleCatalog,
-        purpose: "lookup",
-        loadExactCmsArea: (requestPath, sourcePreset) => getPhiExactSiteArea({
-            path: requestPath,
-            siteKey,
-            apiBaseUrl,
-            internalToken,
-            locale,
-            cookieHeader: "",
-            sourcePreset,
-        }),
-        loadResolvedCmsPage: (requestPath, sourcePreset) => getPhiCmsPage({
-            path: requestPath,
-            siteKey,
-            apiBaseUrl,
-            internalToken,
-            locale,
-            cookieHeader: "",
-            sourcePreset,
-        }),
-    }));
+    });
     return resolved != null
         && resolvePhiCmsPageRedirect(resolved.page.page, locale) == null
         && resolved.runtime.page?.noindex !== true;