@phis/ui 0.2.1 → 0.4.0

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;

package/next/site-proxy.d.ts

@@ -1,4 +1,4 @@
 import { NextRequest, NextResponse } from "next/server";
-/** Where the static route tree lives. Only the proxy may send a request there; see below. */
-export declare const PHI_STATIC_RENDER_PREFIX = "/static-render";
+import { PHI_STATIC_RENDER_PREFIX } from "../helpers/static-render-path";
+export { PHI_STATIC_RENDER_PREFIX };
 export declare function proxyPhiNextSiteRequest(request: NextRequest): Promise<NextResponse<unknown>>;

package/next/site-proxy.js

@@ -1,5 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
 import { isPhiAssetOrBackendPath } from "./static-asset-path";
+import { PHI_SITE_SESSION_COOKIE } from "../constants/site-cookies";
 import { PHI_CMS_SPECIAL_ROOTS } from "../helpers/cms-routing";
 import { localizePath } from "../helpers/locale";
 import { extractLocalePrefix, } from "../helpers/site-locale-config";
@@ -10,9 +11,8 @@ import { peekPhiAreaRootDoor } from "../gateway/area-root-door";
 import { readPhiServerApiCredentials } from "../helpers/phis-server-credentials";
 import { getResolvedSiteConfig } from "../gateway/site-config";
 import { PHI_COLOR_SCHEME_COOKIE, PHI_THEME_MODE_COOKIE, normalizePhiColorSchemeHint, normalizePhiThemeModePreference, resolvePhiThemeMode, } from "../theme/phi-theme-mode";
-/** Where the static route tree lives. Only the proxy may send a request there; see below. */
-export const PHI_STATIC_RENDER_PREFIX = "/static-render";
-const PHI_SITE_SESSION_COOKIE = "phis_session";
+import { PHI_STATIC_RENDER_PREFIX } from "../helpers/static-render-path";
+export { PHI_STATIC_RENDER_PREFIX };
 /*
  * Query parameters a static render may ignore: campaign tags nobody's page reads, and `_rsc`, which Next
  * adds to a client navigation's own request. Any other parameter can change what a page shows -- a
@@ -149,7 +149,17 @@ export async function proxyPhiNextSiteRequest(request) {
             : new NextResponse(null, { status: 404 });
     }
     if (isPhiAssetOrBackendPath(pathname)) {
-        return NextResponse.next();
+        /*
+         * `x-locale` is this proxy's word, set below from the path. A backend route resolves its locale
+         * through the same request reader as a page, so a value the browser sent under that name must not
+         * reach it either.
+         */
+        if (!request.headers.has("x-locale")) {
+            return NextResponse.next();
+        }
+        const backendHeaders = new Headers(request.headers);
+        backendHeaders.delete("x-locale");
+        return NextResponse.next({ request: { headers: backendHeaders } });
     }
     const runtimeConfig = readSiteRuntime();
     const localeConfig = await readLocaleConfig(runtimeConfig);
@@ -165,8 +175,9 @@ export async function proxyPhiNextSiteRequest(request) {
     requestHeaders.set(PHIS_CLIENT_NAVIGATION_HEADER, isPhiClientNavigation(request) ? "1" : "0");
     const prefixedLocale = extractLocalePrefix(pathname, localeConfig);
     if (prefixedLocale) {
-        // The static tree names the locale by its own segment, so only an exact one goes there.
-        const localeSegment = pathname.split("/").filter(Boolean)[0]?.toLowerCase();
+        // The static tree names the locale by its own segment, so only an exact one goes there -- in the
+        // Site's own spelling, which is how `prefixedLocale` comes back; lowercasing kept `pt-BR` out.
+        const localeSegment = pathname.split("/").filter(Boolean)[0];
         if (localeSegment === prefixedLocale && isPhiStaticRenderRequest(request)) {
             const passHeaders = new Headers(request.headers);
             passHeaders.set(PHI_STATIC_RENDER_PASS_HEADER, readPhiStaticRenderPass());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phis/ui",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
@@ -112,6 +112,11 @@
       "import": "./next/cache-handler.mjs",
       "default": "./next/cache-handler.mjs"
     },
+    "./next/config": {
+      "types": "./next/config.d.mts",
+      "import": "./next/config.mjs",
+      "default": "./next/config.mjs"
+    },
     "./next/overlay-zones-client": {
       "types": "./components/overlays/phi-overlay-zones-loader.d.ts",
       "import": "./components/overlays/phi-overlay-zones-loader.js",
@@ -122,6 +127,11 @@
       "import": "./next/overlay-zones.js",
       "default": "./next/overlay-zones.js"
     },
+    "./next/root-error-page": {
+      "types": "./next/root-error-page.d.ts",
+      "import": "./next/root-error-page.js",
+      "default": "./next/root-error-page.js"
+    },
     "./next/route-handlers": {
       "types": "./next/route-handlers.d.ts",
       "import": "./next/route-handlers.js",
@@ -262,6 +272,16 @@
       "import": "./module-labels.js",
       "default": "./module-labels.js"
     },
+    "./module/dashboard-cards": {
+      "types": "./module-dashboard-cards.d.ts",
+      "import": "./module-dashboard-cards.js",
+      "default": "./module-dashboard-cards.js"
+    },
+    "./module/records": {
+      "types": "./module-records.d.ts",
+      "import": "./module-records.js",
+      "default": "./module-records.js"
+    },
     "./module/projection": {
       "types": "./module-projection.d.ts",
       "import": "./module-projection.js",
@@ -470,6 +490,7 @@
   "dependencies": {
     "@ant-design/colors": "^8.0.1",
     "@ant-design/cssinjs": "^2.1.2",
+    "@ant-design/icons-svg": "^4.6.0",
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
@@ -482,7 +503,7 @@
     "@lexical/rich-text": "0.50.0",
     "@lexical/selection": "0.50.0",
     "@lexical/utils": "0.50.0",
-    "@phis/contracts": "^0.5.0",
+    "@phis/contracts": "^0.6.0",
     "dayjs": "^1.11.23",
     "dom-serializer": "^2.0.0",
     "htmlparser2": "^10.1.0",

package/plugins/factories/widget-builder-plugin.js

@@ -1,9 +1,8 @@
 "use client";
 export function createPhiCmsBuilderWidgetPlugin(definition, renderEditor) {
-    const { contentBinding: _contentBinding, ...builderDefinition } = definition;
-    void _contentBinding;
+    // The definition whole: the Builder plugin is the declaration plus its editor, nothing taken away.
     return {
-        ...builderDefinition,
+        ...definition,
         renderEditor,
     };
 }