@phis/ui 0.1.0 → 0.2.0

package/module.d.ts

@@ -1,5 +1,5 @@
-import { type PhiRuntimeModuleServerAreaContribution } from "./plugins/runtime-modules/area-contributions";
-import type { PhiRuntimeModuleDefinition } from "./types/cms-plugins";
+import type { PhiRuntimeModuleServerAreaContribution } from "./plugins/runtime-modules/area-contributions";
+import type { PhiRuntimeModule, PhiRuntimeModuleCatalogEntry, PhiRuntimeModuleDefinition } from "./types/cms-plugins";
 import { type PhiFontCatalogueEntry } from "./theme/phi-font-catalogue-contract";
 /**
  * What a Module package exports, and under which names.
@@ -17,27 +17,52 @@ import { type PhiFontCatalogueEntry } from "./theme/phi-font-catalogue-contract"
  *   ./authoring-client  phiModuleAuthoringContributions
  *   ./fonts             phiModuleFontContributions      (only a Module that declares typefaces)
  *
- * Each export is a list keyed by Module, because one package may carry several Modules. A Module never
- * names an Area: where its contributions belong follows from `eligibleAreas` on its own definition, which
- * is also what decides whether a Site may select it for an Area -- one statement, read in both places,
- * rather than a second list that can disagree with the first.
+ * Each export is a list keyed by Module, because one package may carry several Modules. A Module's code
+ * never names an Area: the package states its Modules' Areas once, in `package.json#phis`, where
+ * `phis module` can read them without running anything. The generated projection hands them to the
+ * definition, so the catalog and the Builder read `eligibleAreas` as they do for a first-party Module --
+ * one statement, rather than a second list in the code that can disagree with the first.
  *
  * These are what a Module author writes. What `phis-cli` generates from them is the per-Area projection
  * in `plugins/runtime-modules/site-modules.ts`, which is a different shape for a different reader.
  */
-export type PhiModuleServerContributions = readonly PhiRuntimeModuleServerAreaContribution[];
+type PhiOmitAreas<T> = T extends unknown ? Omit<T, "eligibleAreas"> : never;
+/** A Module's definition as its package writes it: all but the Areas, which `package.json` states. */
+export type PhiModuleDefinition = PhiOmitAreas<PhiRuntimeModuleDefinition>;
+/** What a package's runtime loader returns, without the Areas for the same reason. */
+export type PhiModuleRuntime = PhiOmitAreas<PhiRuntimeModule>;
+/** One Module's Server catalog contribution, as its package writes it. */
+export type PhiModuleServerContribution = {
+    moduleId: PhiRuntimeModuleServerAreaContribution["moduleId"];
+    catalogEntry: Omit<PhiRuntimeModuleCatalogEntry, "definition" | "load"> & {
+        definition: PhiModuleDefinition;
+        load: () => Promise<PhiModuleRuntime>;
+    };
+};
+export type PhiModuleServerContributions = readonly PhiModuleServerContribution[];
 export declare function definePhiModuleServerContributions(contributions: PhiModuleServerContributions): PhiModuleServerContributions;
 export type { PhiRuntimeModuleServerAreaContribution };
 /**
  * The Module definitions of a package, exported from its root entrypoint as `phiModuleDefinitions`.
  *
- * A definition is shared serializable contract, which MODULES.md allows every boundary to import, and it
- * is the only place a Module states its Areas. The generated Client projection needs those Areas and
- * must not reach into the Server boundary to get them, so it reads them here instead -- still one
- * statement, read from a place both sides may look at.
+ * A definition is shared serializable contract, which MODULES.md allows every boundary to import. It
+ * names no Area -- see `PhiModuleDefinition` -- and no generated file reads it: the projections take
+ * what they need from `package.json#phis` and from the Server, Client and Authoring doors. It stays the
+ * package's one list of its Modules, for the package's own tools and tests.
  */
-export type PhiModuleDefinitions = readonly PhiRuntimeModuleDefinition[];
+export type PhiModuleDefinitions = readonly PhiModuleDefinition[];
 export declare function definePhiModuleDefinitions(definitions: PhiModuleDefinitions): PhiModuleDefinitions;
+/**
+ * The Controller descriptor a definition carries, for a package whose Module has a Controller.
+ *
+ * The builder itself is Client-safe -- the contracts file behind it holds types and pure functions --
+ * but its usual door, `@phis/ui/cms/plugins`, is the Server boundary and brings `server-only` with it.
+ * A definition is shared contract that a package's root door exports, and that door is not Server-only,
+ * so a package that reached for the builder through the Server door would pull `server-only` into every
+ * graph that opens its root. First-party Modules import it from the contracts file directly; a package
+ * outside this one cannot, and this is the same door for it.
+ */
+export { buildPhiRuntimeModuleControllerDescriptor } from "./plugins/runtime-modules/contracts";
 /**
  * The typefaces a package declares, exported from `./fonts` as `phiModuleFontContributions`.
  *

package/module.js

@@ -1,9 +1,16 @@
-import { definePhiRuntimeModuleServerAreaContribution, } from "./plugins/runtime-modules/area-contributions";
 import { PHI_CORE_FONT_FAMILIES, PHI_MODULE_FONT_CSS_VARIABLE_PATTERN, } from "./theme/phi-font-catalogue-contract";
 export function definePhiModuleServerContributions(contributions) {
-    // Validating here rather than at Site assembly means a Module author sees the mismatch while building
-    // their own package, not the operator who installed it.
-    return contributions.map((contribution) => definePhiRuntimeModuleServerAreaContribution(contribution));
+    /*
+     * Only what can be said without the Areas. Whether a descriptor addresses an Area the Module serves is
+     * asked where the placement is known, when the projection completes the definition
+     * (`collectPhiSiteModuleServerAreaContributions`) -- at the Site's build, not the package's.
+     */
+    for (const contribution of contributions) {
+        if (contribution.catalogEntry.definition.moduleId !== contribution.moduleId) {
+            throw new Error(`Area contribution module id mismatch for "${contribution.moduleId}".`);
+        }
+    }
+    return contributions;
 }
 export function definePhiModuleDefinitions(definitions) {
     const seen = new Set();
@@ -11,13 +18,21 @@ export function definePhiModuleDefinitions(definitions) {
         if (seen.has(definition.moduleId)) {
             throw new Error(`Duplicate Module definition for "${definition.moduleId}".`);
         }
-        if (definition.eligibleAreas.length === 0) {
-            throw new Error(`Module "${definition.moduleId}" declares no eligible Area and could never be used.`);
-        }
         seen.add(definition.moduleId);
     }
     return definitions;
 }
+/**
+ * The Controller descriptor a definition carries, for a package whose Module has a Controller.
+ *
+ * The builder itself is Client-safe -- the contracts file behind it holds types and pure functions --
+ * but its usual door, `@phis/ui/cms/plugins`, is the Server boundary and brings `server-only` with it.
+ * A definition is shared contract that a package's root door exports, and that door is not Server-only,
+ * so a package that reached for the builder through the Server door would pull `server-only` into every
+ * graph that opens its root. First-party Modules import it from the contracts file directly; a package
+ * outside this one cannot, and this is the same door for it.
+ */
+export { buildPhiRuntimeModuleControllerDescriptor } from "./plugins/runtime-modules/contracts";
 export function definePhiModuleFontContributions(contributions) {
     const seen = new Set();
     for (const contribution of contributions) {

package/net/log.d.ts

@@ -1,5 +1,4 @@
 export type { PhiLogEvent, PhiLogLevel, PhiLogService, PhiLogger, PhiLoggerContext, } from "@phis/contracts/logging";
 import type { PhiLogEvent, PhiLogLevel, PhiLoggerContext, PhiLogger } from "@phis/contracts/logging";
 export declare function createLogger(context: Partial<PhiLoggerContext>): PhiLogger;
-export declare const phisUiLogger: PhiLogger;
 export declare function logRuntimeEvent(level: PhiLogLevel, event: string, input?: PhiLogEvent & Partial<PhiLoggerContext>): void;

package/net/log.js

@@ -98,7 +98,6 @@ function createLoggerFromContext(context) {
 export function createLogger(context) {
     return createLoggerFromContext(normalizeContext(context));
 }
-export const phisUiLogger = createLogger({ service: "ui" });
 export function logRuntimeEvent(level, event, input = {}) {
     const logger = createLogger({
         service: "ui",

package/net/phi-next-proxy.d.ts

@@ -30,5 +30,30 @@ export type PhiNextProxyHandlers = {
     DELETE: PhiNextProxyHandler;
     OPTIONS: PhiNextProxyHandler;
 };
+/**
+ * The catch-all's segments as a path again, each one encoded on its own.
+ *
+ * Next hands the segments over decoded, so joining them as they come turns an encoded `%2F` back into a
+ * separator and `..` into a step upwards: `/api/site/x%2F..%2F..%2Fv1%2Fx` reached `/api/v1/*` on the
+ * Server, carrying the internal token this door adds. A decoded `?` or `#` cut the path short. Encoding
+ * each segment keeps it one segment; a segment that is only dots is refused, because URL parsing
+ * resolves it -- percent-encoded or not -- however it is written.
+ */
+export declare function encodePhiProxyPathSegments(path: readonly string[] | undefined): string;
+export declare class PhiProxyPathError extends Error {
+    constructor(segment: string);
+}
+/**
+ * The upstream response's headers as the browser may see them.
+ *
+ * `fetch` hands over a body it has already decoded: undici asks for gzip, deflate and br on its own and
+ * undoes whatever the Server applied. Passing the Server's `content-encoding` on then tells the browser
+ * to decode plain bytes a second time (`ERR_CONTENT_DECODING_FAILED`), and its `content-length` counts
+ * the compressed bytes. Both go for a decoded body; the runtime frames the body it actually sends.
+ * Asking upstream for `identity` instead would rest on the Server honouring it -- this holds either way.
+ */
+export declare function buildPhiProxyResponseHeaders(upstream: Headers, options: {
+    bodyDecoded: boolean;
+}): Headers;
 export declare function PhiNextProxy(config: PhiNextProxyConfig): PhiNextProxyHandlers;
 export {};

package/net/phi-next-proxy.js

@@ -3,10 +3,35 @@ import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
 import { Readable } from "node:stream";
 import { logRuntimeEvent } from "./log";
+/**
+ * The catch-all's segments as a path again, each one encoded on its own.
+ *
+ * Next hands the segments over decoded, so joining them as they come turns an encoded `%2F` back into a
+ * separator and `..` into a step upwards: `/api/site/x%2F..%2F..%2Fv1%2Fx` reached `/api/v1/*` on the
+ * Server, carrying the internal token this door adds. A decoded `?` or `#` cut the path short. Encoding
+ * each segment keeps it one segment; a segment that is only dots is refused, because URL parsing
+ * resolves it -- percent-encoded or not -- however it is written.
+ */
+export function encodePhiProxyPathSegments(path) {
+    if (!path?.length)
+        return "";
+    for (const segment of path) {
+        if (segment === "." || segment === ".." || segment === "") {
+            throw new PhiProxyPathError(segment);
+        }
+    }
+    return `/${path.map((segment) => encodeURIComponent(segment)).join("/")}`;
+}
+export class PhiProxyPathError extends Error {
+    constructor(segment) {
+        super(`The proxy path holds a segment it cannot forward: "${segment}".`);
+        this.name = "PhiProxyPathError";
+    }
+}
 function buildTargetUrl(upstreamBaseUrl, upstreamPrefix, request, path) {
     const normalizedBase = upstreamBaseUrl.replace(/\/$/, "");
     const normalizedPrefix = upstreamPrefix.startsWith("/") ? upstreamPrefix : `/${upstreamPrefix}`;
-    const pathSuffix = path?.length ? `/${path.join("/")}` : "";
+    const pathSuffix = encodePhiProxyPathSegments(path);
     const targetUrl = new URL(`${normalizedBase}${normalizedPrefix}${pathSuffix}`);
     targetUrl.search = request.nextUrl.search;
     return targetUrl;
@@ -14,9 +39,33 @@ function buildTargetUrl(upstreamBaseUrl, upstreamPrefix, request, path) {
 function toHeadersObject(headers) {
     return Object.fromEntries(headers.entries());
 }
+/** Headers that describe one connection, not the response: the runtime writes its own on the way out. */
+const HOP_BY_HOP_RESPONSE_HEADERS = ["connection", "keep-alive", "transfer-encoding"];
+/**
+ * The upstream response's headers as the browser may see them.
+ *
+ * `fetch` hands over a body it has already decoded: undici asks for gzip, deflate and br on its own and
+ * undoes whatever the Server applied. Passing the Server's `content-encoding` on then tells the browser
+ * to decode plain bytes a second time (`ERR_CONTENT_DECODING_FAILED`), and its `content-length` counts
+ * the compressed bytes. Both go for a decoded body; the runtime frames the body it actually sends.
+ * Asking upstream for `identity` instead would rest on the Server honouring it -- this holds either way.
+ */
+export function buildPhiProxyResponseHeaders(upstream, options) {
+    const headers = new Headers(upstream);
+    for (const name of HOP_BY_HOP_RESPONSE_HEADERS)
+        headers.delete(name);
+    if (options.bodyDecoded) {
+        headers.delete("content-encoding");
+        headers.delete("content-length");
+    }
+    return headers;
+}
 function buildResponseHeaders(headers) {
     const responseHeaders = new Headers();
     for (const [key, value] of Object.entries(headers)) {
+        if (HOP_BY_HOP_RESPONSE_HEADERS.includes(key.toLowerCase())) {
+            continue;
+        }
         if (typeof value === "string") {
             responseHeaders.set(key, value);
             continue;
@@ -69,7 +118,16 @@ async function proxyRequest(request, path, config) {
     if (!config.upstreamBaseUrl) {
         return Response.json({ message: config.missingBaseUrlMessage }, { status: 500 });
     }
-    const targetUrl = buildTargetUrl(config.upstreamBaseUrl, config.upstreamPrefix, request, path);
+    let targetUrl;
+    try {
+        targetUrl = buildTargetUrl(config.upstreamBaseUrl, config.upstreamPrefix, request, path);
+    }
+    catch (error) {
+        if (error instanceof PhiProxyPathError) {
+            return Response.json({ message: "Invalid path." }, { status: 400 });
+        }
+        throw error;
+    }
     const startedAt = Date.now();
     try {
         const hasBody = request.method !== "GET" && request.method !== "HEAD";
@@ -111,9 +169,12 @@ async function proxyRequest(request, path, config) {
                 },
             });
         }
+        // The Node path hands over the Server's bytes as they came, still encoded; `fetch` decoded them.
         return new Response(targetResponse.body, {
             status: targetResponse.status,
-            headers: targetResponse.headers,
+            headers: hasBody
+                ? targetResponse.headers
+                : buildPhiProxyResponseHeaders(targetResponse.headers, { bodyDecoded: true }),
         });
     }
     catch (error) {

package/next/area-route.d.ts

@@ -1,7 +1,6 @@
 import "server-only";
 import type { Metadata } from "next";
 import type { PhiCmsErrorPageProps } from "../components/cms/phi-cms-error-page";
-import type { PhiCmsAreaKey } from "../constants/cms-areas";
 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";
@@ -48,17 +47,24 @@ export declare function createPhiNextStaticAreaPage(root: string, cmsBridge: Phi
     Page: ({ params }: PhiNextStaticAreaPageProps) => Promise<import("react").JSX.Element>;
     generateMetadata: ({ params }: PhiNextStaticAreaPageProps) => Promise<Metadata>;
 };
-export declare function createPhiNextStaticAreaSlotPage(root: string, cmsBridge: PhiCmsSiteBridge, regionType: PhiNextStaticAreaRegionType): ({ params }: PhiNextStaticAreaPageProps) => Promise<import("react").JSX.Element>;
 /**
- * An Area's own refusal page: `not-found.tsx`, `unauthorized.tsx`, `forbidden.tsx`.
+ * What a Page-owned slot shows for an address its own branch does not answer.
+ *
+ * Next keeps each slot's active segment beside the children segment, and a client navigation that
+ * leaves the branch -- Area root to a Page below it, or one Area to the next -- moves children while
+ * the slots have nothing to move to. Without this file Next has no state to put there: it keeps the
+ * leaving branch's slot and asks it to serve an address it was never resolved for, and the arriving
+ * Layout answers with a tree that disagrees with the one the client holds. That disagreement is what
+ * the client tries to settle by navigating again.
  *
- * Next resolves these from the refusing segment upwards, so as long as the Area itself is reachable they
- * render in that Area's children slot: the shell stays, the error tree fills the content region, and the
- * Client boundary the layout mounted is already in place. Only a refusal by the layout itself walks past
- * them to the root, where there is no Area left to render into.
+ * Nothing is the right answer and not a placeholder. A slot draws one Region of one Page; an address
+ * that does not reach that Page has no Region for it, and the Layout beside it already decided
+ * existence, access and forwarding with a status line. So this neither resolves the request nor
+ * refuses it -- both are answered once, above, and a slot that answered a second time would only
+ * multiply what the client has to unwind.
  */
-export declare function createPhiNextStaticAreaErrorPage(code: PhiCmsErrorPageProps["code"], cmsBridge: PhiCmsSiteBridge, area: PhiCmsAreaKey): () => import("react").JSX.Element;
-export declare function createPhiNextStaticAreaNotFound(cmsBridge: PhiCmsSiteBridge, area: PhiCmsAreaKey): () => import("react").JSX.Element;
+export declare function createPhiNextAreaSlotDefault(): () => null;
+export declare function createPhiNextStaticAreaSlotPage(root: string, cmsBridge: PhiCmsSiteBridge, regionType: PhiNextStaticAreaRegionType): ({ params }: PhiNextStaticAreaPageProps) => Promise<import("react").JSX.Element>;
 /**
  * What a root error route rebuilds before it renders.
  *
@@ -81,10 +87,15 @@ export type PhiNextRootErrorArea = {
  * layout, so neither the Area's shell nor the Client boundary it mounts exist any more -- which is why
  * this rebuilds both rather than rendering the error tree bare.
  *
- * It answers as Public whichever Area was asked for, and every Area is welcome to answer for itself
- * first: an Area that carries its own `not-found.tsx`, `unauthorized.tsx` or `forbidden.tsx` catches
- * the refusal inside its own shell and never reaches here. What is left for this route are refusals
- * raised above an Area segment, and paths that name no Area at all.
+ * It answers as Public for every Area, and it is the only route that answers: an Area carries no
+ * refusal routes of its own, because one placed inside an Area could never catch anything. Existence
+ * is decided by `PhiCmsAreaShell` rather than by the Page, so that the status line can still say 404
+ * -- decided below the shell it arrives after the flush, and Next can then only swap the body, which
+ * answers 200. The shell is therefore the thrower, and a refusal is always caught above it. A
+ * boundary beside the shell's own Layout is skipped; this was measured, at 404 with no navigation.
+ *
+ * So the shell is not lost here, it was never reachable: an Area keeping its navigation on an error
+ * page and an Area answering 404 are the same choice made two ways, and the status line wins.
  *
  * Rebuilding the refused Area here instead was measured and dropped: one registry naming all six put
  * 22 further Client modules into every route, the Builder's workspace among them, and roughly half of

package/next/area-route.js

@@ -71,27 +71,32 @@ export function createPhiNextStaticAreaPage(root, cmsBridge) {
     }
     return { Page: PhiNextStaticAreaPage, generateMetadata };
 }
-export function createPhiNextStaticAreaSlotPage(root, cmsBridge, regionType) {
-    return async function PhiNextStaticAreaSlotPage({ params }) {
-        const { path } = await params;
-        return (_jsx(PhiCmsRootSlotPage, { root: root, path: path, cmsBridge: cmsBridge, regionType: regionType }));
-    };
-}
 /**
- * An Area's own refusal page: `not-found.tsx`, `unauthorized.tsx`, `forbidden.tsx`.
+ * What a Page-owned slot shows for an address its own branch does not answer.
+ *
+ * Next keeps each slot's active segment beside the children segment, and a client navigation that
+ * leaves the branch -- Area root to a Page below it, or one Area to the next -- moves children while
+ * the slots have nothing to move to. Without this file Next has no state to put there: it keeps the
+ * leaving branch's slot and asks it to serve an address it was never resolved for, and the arriving
+ * Layout answers with a tree that disagrees with the one the client holds. That disagreement is what
+ * the client tries to settle by navigating again.
  *
- * Next resolves these from the refusing segment upwards, so as long as the Area itself is reachable they
- * render in that Area's children slot: the shell stays, the error tree fills the content region, and the
- * Client boundary the layout mounted is already in place. Only a refusal by the layout itself walks past
- * them to the root, where there is no Area left to render into.
+ * Nothing is the right answer and not a placeholder. A slot draws one Region of one Page; an address
+ * that does not reach that Page has no Region for it, and the Layout beside it already decided
+ * existence, access and forwarding with a status line. So this neither resolves the request nor
+ * refuses it -- both are answered once, above, and a slot that answered a second time would only
+ * multiply what the client has to unwind.
  */
-export function createPhiNextStaticAreaErrorPage(code, cmsBridge, area) {
-    return function PhiNextStaticAreaErrorPage() {
-        return _jsx(PhiCmsErrorPage, { code: code, cmsBridge: cmsBridge, area: area });
+export function createPhiNextAreaSlotDefault() {
+    return function PhiNextAreaSlotDefault() {
+        return null;
     };
 }
-export function createPhiNextStaticAreaNotFound(cmsBridge, area) {
-    return createPhiNextStaticAreaErrorPage(404, cmsBridge, area);
+export function createPhiNextStaticAreaSlotPage(root, cmsBridge, regionType) {
+    return async function PhiNextStaticAreaSlotPage({ params }) {
+        const { path } = await params;
+        return (_jsx(PhiCmsRootSlotPage, { root: root, path: path, cmsBridge: cmsBridge, regionType: regionType }));
+    };
 }
 /**
  * A root-level error route: `not-found.tsx`, `unauthorized.tsx` and `forbidden.tsx`.
@@ -100,10 +105,15 @@ export function createPhiNextStaticAreaNotFound(cmsBridge, area) {
  * layout, so neither the Area's shell nor the Client boundary it mounts exist any more -- which is why
  * this rebuilds both rather than rendering the error tree bare.
  *
- * It answers as Public whichever Area was asked for, and every Area is welcome to answer for itself
- * first: an Area that carries its own `not-found.tsx`, `unauthorized.tsx` or `forbidden.tsx` catches
- * the refusal inside its own shell and never reaches here. What is left for this route are refusals
- * raised above an Area segment, and paths that name no Area at all.
+ * It answers as Public for every Area, and it is the only route that answers: an Area carries no
+ * refusal routes of its own, because one placed inside an Area could never catch anything. Existence
+ * is decided by `PhiCmsAreaShell` rather than by the Page, so that the status line can still say 404
+ * -- decided below the shell it arrives after the flush, and Next can then only swap the body, which
+ * answers 200. The shell is therefore the thrower, and a refusal is always caught above it. A
+ * boundary beside the shell's own Layout is skipped; this was measured, at 404 with no navigation.
+ *
+ * So the shell is not lost here, it was never reachable: an Area keeping its navigation on an error
+ * page and an Area answering 404 are the same choice made two ways, and the status line wins.
  *
  * Rebuilding the refused Area here instead was measured and dropped: one registry naming all six put
  * 22 further Client modules into every route, the Builder's workspace among them, and roughly half of

package/next/areas/accounting-client.js

@@ -1,6 +1,6 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
-import { PHI_ACCOUNTING_RUNTIME_MODULE_CONTROLLER_CLIENT_MANIFEST, PHI_ACCOUNTING_RUNTIME_MODULE_CALENDAR_ADAPTER_CLIENT_MANIFEST, PHI_ACCOUNTING_RUNTIME_MODULE_DATA_PROVIDER_CLIENT_MANIFEST, PHI_ACCOUNTING_RUNTIME_MODULE_RENDER_CLIENT_MANIFEST, } from "../../plugins/runtime-modules/client-manifests/accounting";
+import { PHI_ACCOUNTING_RUNTIME_MODULE_CONTROLLER_CLIENT_MANIFEST, PHI_ACCOUNTING_RUNTIME_MODULE_CALENDAR_ADAPTER_CLIENT_MANIFEST, PHI_ACCOUNTING_RUNTIME_MODULE_UI_PROVIDER_CLIENT_MANIFEST, PHI_ACCOUNTING_RUNTIME_MODULE_DATA_PROVIDER_CLIENT_MANIFEST, PHI_ACCOUNTING_RUNTIME_MODULE_RENDER_CLIENT_MANIFEST, } from "../../plugins/runtime-modules/client-manifests/accounting";
 import { PhiNextRuntimeModuleClientBoundary } from "../runtime-module-client-boundary";
 import { extendWithPhiSiteModuleClientManifests, } from "../../plugins/runtime-modules/site-module-client-manifests";
 import { PHI_NO_SITE_MODULE_CLIENT_CONTRIBUTIONS, } from "../../plugins/runtime-modules/site-modules-client";
@@ -16,9 +16,10 @@ export function createPhiAccountingRuntimeModuleClientBoundary(siteModules = PHI
         render: PHI_ACCOUNTING_RUNTIME_MODULE_RENDER_CLIENT_MANIFEST,
         dataProvider: PHI_ACCOUNTING_RUNTIME_MODULE_DATA_PROVIDER_CLIENT_MANIFEST,
         calendarAdapter: PHI_ACCOUNTING_RUNTIME_MODULE_CALENDAR_ADAPTER_CLIENT_MANIFEST,
+        uiProvider: PHI_ACCOUNTING_RUNTIME_MODULE_UI_PROVIDER_CLIENT_MANIFEST,
     });
     return function PhiAccountingRuntimeModuleClientBoundary({ children, }) {
-        return (_jsx(PhiNextRuntimeModuleClientBoundary, { calendarAdapterManifest: manifests.calendarAdapter, controllerManifest: manifests.controller, dataProviderManifest: manifests.dataProvider, renderManifest: manifests.render, children: children }));
+        return (_jsx(PhiNextRuntimeModuleClientBoundary, { calendarAdapterManifest: manifests.calendarAdapter, controllerManifest: manifests.controller, dataProviderManifest: manifests.dataProvider, renderManifest: manifests.render, uiProviderManifest: manifests.uiProvider, children: children }));
     };
 }
 export const PhiAccountingRuntimeModuleClientBoundary = createPhiAccountingRuntimeModuleClientBoundary();

package/next/areas/admin-client.js

@@ -1,6 +1,6 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
-import { PHI_ADMIN_RUNTIME_MODULE_CONTROLLER_CLIENT_MANIFEST, PHI_ADMIN_RUNTIME_MODULE_CALENDAR_ADAPTER_CLIENT_MANIFEST, PHI_ADMIN_RUNTIME_MODULE_DATA_PROVIDER_CLIENT_MANIFEST, PHI_ADMIN_RUNTIME_MODULE_RENDER_CLIENT_MANIFEST, } from "../../plugins/runtime-modules/client-manifests/admin";
+import { PHI_ADMIN_RUNTIME_MODULE_CONTROLLER_CLIENT_MANIFEST, PHI_ADMIN_RUNTIME_MODULE_CALENDAR_ADAPTER_CLIENT_MANIFEST, PHI_ADMIN_RUNTIME_MODULE_UI_PROVIDER_CLIENT_MANIFEST, PHI_ADMIN_RUNTIME_MODULE_DATA_PROVIDER_CLIENT_MANIFEST, PHI_ADMIN_RUNTIME_MODULE_RENDER_CLIENT_MANIFEST, } from "../../plugins/runtime-modules/client-manifests/admin";
 import { PhiNextRuntimeModuleClientBoundary } from "../runtime-module-client-boundary";
 import { extendWithPhiSiteModuleClientManifests, } from "../../plugins/runtime-modules/site-module-client-manifests";
 import { PHI_NO_SITE_MODULE_CLIENT_CONTRIBUTIONS, } from "../../plugins/runtime-modules/site-modules-client";
@@ -16,9 +16,10 @@ export function createPhiAdminRuntimeModuleClientBoundary(siteModules = PHI_NO_S
         render: PHI_ADMIN_RUNTIME_MODULE_RENDER_CLIENT_MANIFEST,
         dataProvider: PHI_ADMIN_RUNTIME_MODULE_DATA_PROVIDER_CLIENT_MANIFEST,
         calendarAdapter: PHI_ADMIN_RUNTIME_MODULE_CALENDAR_ADAPTER_CLIENT_MANIFEST,
+        uiProvider: PHI_ADMIN_RUNTIME_MODULE_UI_PROVIDER_CLIENT_MANIFEST,
     });
     return function PhiAdminRuntimeModuleClientBoundary({ children, }) {
-        return (_jsx(PhiNextRuntimeModuleClientBoundary, { calendarAdapterManifest: manifests.calendarAdapter, controllerManifest: manifests.controller, dataProviderManifest: manifests.dataProvider, renderManifest: manifests.render, children: children }));
+        return (_jsx(PhiNextRuntimeModuleClientBoundary, { calendarAdapterManifest: manifests.calendarAdapter, controllerManifest: manifests.controller, dataProviderManifest: manifests.dataProvider, renderManifest: manifests.render, uiProviderManifest: manifests.uiProvider, children: children }));
     };
 }
 export const PhiAdminRuntimeModuleClientBoundary = createPhiAdminRuntimeModuleClientBoundary();

package/next/areas/app-client.js

@@ -1,6 +1,6 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
-import { PHI_APP_RUNTIME_MODULE_CONTROLLER_CLIENT_MANIFEST, PHI_APP_RUNTIME_MODULE_CALENDAR_ADAPTER_CLIENT_MANIFEST, PHI_APP_RUNTIME_MODULE_DATA_PROVIDER_CLIENT_MANIFEST, PHI_APP_RUNTIME_MODULE_RENDER_CLIENT_MANIFEST, } from "../../plugins/runtime-modules/client-manifests/app";
+import { PHI_APP_RUNTIME_MODULE_CONTROLLER_CLIENT_MANIFEST, PHI_APP_RUNTIME_MODULE_CALENDAR_ADAPTER_CLIENT_MANIFEST, PHI_APP_RUNTIME_MODULE_UI_PROVIDER_CLIENT_MANIFEST, PHI_APP_RUNTIME_MODULE_DATA_PROVIDER_CLIENT_MANIFEST, PHI_APP_RUNTIME_MODULE_RENDER_CLIENT_MANIFEST, } from "../../plugins/runtime-modules/client-manifests/app";
 import { PhiNextRuntimeModuleClientBoundary } from "../runtime-module-client-boundary";
 import { extendWithPhiSiteModuleClientManifests, } from "../../plugins/runtime-modules/site-module-client-manifests";
 import { PHI_NO_SITE_MODULE_CLIENT_CONTRIBUTIONS, } from "../../plugins/runtime-modules/site-modules-client";
@@ -16,9 +16,10 @@ export function createPhiAppRuntimeModuleClientBoundary(siteModules = PHI_NO_SIT
         render: PHI_APP_RUNTIME_MODULE_RENDER_CLIENT_MANIFEST,
         dataProvider: PHI_APP_RUNTIME_MODULE_DATA_PROVIDER_CLIENT_MANIFEST,
         calendarAdapter: PHI_APP_RUNTIME_MODULE_CALENDAR_ADAPTER_CLIENT_MANIFEST,
+        uiProvider: PHI_APP_RUNTIME_MODULE_UI_PROVIDER_CLIENT_MANIFEST,
     });
     return function PhiAppRuntimeModuleClientBoundary({ children, }) {
-        return (_jsx(PhiNextRuntimeModuleClientBoundary, { calendarAdapterManifest: manifests.calendarAdapter, controllerManifest: manifests.controller, dataProviderManifest: manifests.dataProvider, renderManifest: manifests.render, children: children }));
+        return (_jsx(PhiNextRuntimeModuleClientBoundary, { calendarAdapterManifest: manifests.calendarAdapter, controllerManifest: manifests.controller, dataProviderManifest: manifests.dataProvider, renderManifest: manifests.render, uiProviderManifest: manifests.uiProvider, children: children }));
     };
 }
 export const PhiAppRuntimeModuleClientBoundary = createPhiAppRuntimeModuleClientBoundary();

package/next/areas/builder-client.js

@@ -1,6 +1,6 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
-import { PHI_BUILDER_RUNTIME_MODULE_CONTROLLER_CLIENT_MANIFEST, PHI_BUILDER_RUNTIME_MODULE_CALENDAR_ADAPTER_CLIENT_MANIFEST, PHI_BUILDER_RUNTIME_MODULE_DATA_PROVIDER_CLIENT_MANIFEST, PHI_BUILDER_RUNTIME_MODULE_RENDER_CLIENT_MANIFEST, } from "../../plugins/runtime-modules/client-manifests/builder";
+import { PHI_BUILDER_RUNTIME_MODULE_CONTROLLER_CLIENT_MANIFEST, PHI_BUILDER_RUNTIME_MODULE_CALENDAR_ADAPTER_CLIENT_MANIFEST, PHI_BUILDER_RUNTIME_MODULE_UI_PROVIDER_CLIENT_MANIFEST, PHI_BUILDER_RUNTIME_MODULE_DATA_PROVIDER_CLIENT_MANIFEST, PHI_BUILDER_RUNTIME_MODULE_RENDER_CLIENT_MANIFEST, } from "../../plugins/runtime-modules/client-manifests/builder";
 import { PHI_BUILDER_TARGET_RUNTIME_MODULE_AUTHORING_CLIENT_MANIFEST } from "../../plugins/runtime-modules/client-manifests/builder-authoring";
 import { PhiNextRuntimeModuleClientBoundary } from "../runtime-module-client-boundary";
 import { extendWithPhiSiteModuleClientManifests, readAllPhiSiteModuleAuthoringClientContributions, } from "../../plugins/runtime-modules/site-module-client-manifests";
@@ -23,11 +23,12 @@ export function createPhiBuilderRuntimeModuleClientBoundary(siteModules = PHI_NO
         render: PHI_BUILDER_RUNTIME_MODULE_RENDER_CLIENT_MANIFEST,
         dataProvider: PHI_BUILDER_RUNTIME_MODULE_DATA_PROVIDER_CLIENT_MANIFEST,
         calendarAdapter: PHI_BUILDER_RUNTIME_MODULE_CALENDAR_ADAPTER_CLIENT_MANIFEST,
+        uiProvider: PHI_BUILDER_RUNTIME_MODULE_UI_PROVIDER_CLIENT_MANIFEST,
     });
     // The Builder authors every Area, so it receives the complete installed Authoring union.
     const authoringManifest = extendPhiRuntimeModuleAuthoringClientManifest(PHI_BUILDER_TARGET_RUNTIME_MODULE_AUTHORING_CLIENT_MANIFEST, readAllPhiSiteModuleAuthoringClientContributions(siteModuleAuthoring));
     return function PhiBuilderRuntimeModuleClientBoundary({ children, }) {
-        return (_jsx(PhiNextRuntimeModuleClientBoundary, { authoringManifest: authoringManifest, calendarAdapterManifest: manifests.calendarAdapter, controllerManifest: manifests.controller, dataProviderManifest: manifests.dataProvider, renderManifest: manifests.render, children: children }));
+        return (_jsx(PhiNextRuntimeModuleClientBoundary, { authoringManifest: authoringManifest, calendarAdapterManifest: manifests.calendarAdapter, controllerManifest: manifests.controller, dataProviderManifest: manifests.dataProvider, renderManifest: manifests.render, uiProviderManifest: manifests.uiProvider, children: children }));
     };
 }
 export const PhiBuilderRuntimeModuleClientBoundary = createPhiBuilderRuntimeModuleClientBoundary();

package/next/areas/builder.js

@@ -1,7 +1,7 @@
 import "server-only";
 import { createPhiBuilderRuntimeModuleCatalog } from "../../plugins/runtime-modules/catalog";
 import { loadPhiThemeBlockCatalog } from "../../plugins/runtime-modules/theme/block-catalog";
-import { collectPhiThemeDescriptorContributions } from "../../plugins/runtime-modules/theme/theme-descriptors";
+import { collectPhiThemeDescriptorContributions } from "../../plugins/runtime-modules/theme-descriptors";
 import { createPhiNextCmsSiteBridge } from "../site-bridge";
 /**
  * The Area host, given what this Site installed.

package/next/areas/editor-client.js

@@ -1,6 +1,6 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
-import { PHI_EDITOR_RUNTIME_MODULE_CONTROLLER_CLIENT_MANIFEST, PHI_EDITOR_RUNTIME_MODULE_CALENDAR_ADAPTER_CLIENT_MANIFEST, PHI_EDITOR_RUNTIME_MODULE_DATA_PROVIDER_CLIENT_MANIFEST, PHI_EDITOR_RUNTIME_MODULE_RENDER_CLIENT_MANIFEST, } from "../../plugins/runtime-modules/client-manifests/editor";
+import { PHI_EDITOR_RUNTIME_MODULE_CONTROLLER_CLIENT_MANIFEST, PHI_EDITOR_RUNTIME_MODULE_CALENDAR_ADAPTER_CLIENT_MANIFEST, PHI_EDITOR_RUNTIME_MODULE_UI_PROVIDER_CLIENT_MANIFEST, PHI_EDITOR_RUNTIME_MODULE_DATA_PROVIDER_CLIENT_MANIFEST, PHI_EDITOR_RUNTIME_MODULE_RENDER_CLIENT_MANIFEST, } from "../../plugins/runtime-modules/client-manifests/editor";
 import { PhiNextRuntimeModuleClientBoundary } from "../runtime-module-client-boundary";
 import { extendWithPhiSiteModuleClientManifests, } from "../../plugins/runtime-modules/site-module-client-manifests";
 import { PHI_NO_SITE_MODULE_CLIENT_CONTRIBUTIONS, } from "../../plugins/runtime-modules/site-modules-client";
@@ -16,9 +16,10 @@ export function createPhiEditorRuntimeModuleClientBoundary(siteModules = PHI_NO_
         render: PHI_EDITOR_RUNTIME_MODULE_RENDER_CLIENT_MANIFEST,
         dataProvider: PHI_EDITOR_RUNTIME_MODULE_DATA_PROVIDER_CLIENT_MANIFEST,
         calendarAdapter: PHI_EDITOR_RUNTIME_MODULE_CALENDAR_ADAPTER_CLIENT_MANIFEST,
+        uiProvider: PHI_EDITOR_RUNTIME_MODULE_UI_PROVIDER_CLIENT_MANIFEST,
     });
     return function PhiEditorRuntimeModuleClientBoundary({ children, }) {
-        return (_jsx(PhiNextRuntimeModuleClientBoundary, { calendarAdapterManifest: manifests.calendarAdapter, controllerManifest: manifests.controller, dataProviderManifest: manifests.dataProvider, renderManifest: manifests.render, children: children }));
+        return (_jsx(PhiNextRuntimeModuleClientBoundary, { calendarAdapterManifest: manifests.calendarAdapter, controllerManifest: manifests.controller, dataProviderManifest: manifests.dataProvider, renderManifest: manifests.render, uiProviderManifest: manifests.uiProvider, children: children }));
     };
 }
 export const PhiEditorRuntimeModuleClientBoundary = createPhiEditorRuntimeModuleClientBoundary();

package/next/areas/public-client.js

@@ -1,6 +1,6 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
-import { PHI_PUBLIC_RUNTIME_MODULE_CONTROLLER_CLIENT_MANIFEST, PHI_PUBLIC_RUNTIME_MODULE_CALENDAR_ADAPTER_CLIENT_MANIFEST, PHI_PUBLIC_RUNTIME_MODULE_DATA_PROVIDER_CLIENT_MANIFEST, PHI_PUBLIC_RUNTIME_MODULE_RENDER_CLIENT_MANIFEST, } from "../../plugins/runtime-modules/client-manifests/public";
+import { PHI_PUBLIC_RUNTIME_MODULE_CONTROLLER_CLIENT_MANIFEST, PHI_PUBLIC_RUNTIME_MODULE_CALENDAR_ADAPTER_CLIENT_MANIFEST, PHI_PUBLIC_RUNTIME_MODULE_UI_PROVIDER_CLIENT_MANIFEST, PHI_PUBLIC_RUNTIME_MODULE_DATA_PROVIDER_CLIENT_MANIFEST, PHI_PUBLIC_RUNTIME_MODULE_RENDER_CLIENT_MANIFEST, } from "../../plugins/runtime-modules/client-manifests/public";
 import { PhiNextRuntimeModuleClientBoundary } from "../runtime-module-client-boundary";
 import { extendWithPhiSiteModuleClientManifests, } from "../../plugins/runtime-modules/site-module-client-manifests";
 import { PHI_NO_SITE_MODULE_CLIENT_CONTRIBUTIONS, } from "../../plugins/runtime-modules/site-modules-client";
@@ -16,9 +16,10 @@ export function createPhiPublicRuntimeModuleClientBoundary(siteModules = PHI_NO_
         render: PHI_PUBLIC_RUNTIME_MODULE_RENDER_CLIENT_MANIFEST,
         dataProvider: PHI_PUBLIC_RUNTIME_MODULE_DATA_PROVIDER_CLIENT_MANIFEST,
         calendarAdapter: PHI_PUBLIC_RUNTIME_MODULE_CALENDAR_ADAPTER_CLIENT_MANIFEST,
+        uiProvider: PHI_PUBLIC_RUNTIME_MODULE_UI_PROVIDER_CLIENT_MANIFEST,
     });
     return function PhiPublicRuntimeModuleClientBoundary({ children, }) {
-        return (_jsx(PhiNextRuntimeModuleClientBoundary, { calendarAdapterManifest: manifests.calendarAdapter, controllerManifest: manifests.controller, dataProviderManifest: manifests.dataProvider, renderManifest: manifests.render, children: children }));
+        return (_jsx(PhiNextRuntimeModuleClientBoundary, { calendarAdapterManifest: manifests.calendarAdapter, controllerManifest: manifests.controller, dataProviderManifest: manifests.dataProvider, renderManifest: manifests.render, uiProviderManifest: manifests.uiProvider, children: children }));
     };
 }
 export const PhiPublicRuntimeModuleClientBoundary = createPhiPublicRuntimeModuleClientBoundary();

package/next/global-error.d.ts

@@ -0,0 +1,33 @@
+/**
+ * What is left when there is nothing left.
+ *
+ * Every other refusal this Site answers is a Page: `/error/401`, `/error/403` and `/error/404` are
+ * Public route presets, they resolve a CMS tree, and a Site may edit what they say. A 500 cannot be
+ * one of them. It is the answer given when rendering failed, and the first thing a failed render
+ * takes away is the ability to render -- the Site config, the Theme, the locale and the Module
+ * registry all arrive through the same machinery that just broke, so a 500 that asked the CMS for its
+ * own text would be asking the thing that failed to explain the failure.
+ *
+ * So this is a fixed page, and the preset for `/error/500` was removed rather than left standing: a
+ * Page in the Builder that is never the one shown is worse than no Page at all, because somebody
+ * edits it and waits for a change that cannot come.
+ *
+ * It sits at `global-error` rather than at an `error` boundary further down because the root Layout is
+ * itself a plausible thrower -- it fetches the Site, folds in the Theme blocks and resolves the font
+ * Assets -- and an error boundary below a Layout does not catch that Layout. Being the outermost
+ * boundary means it replaces the document, which is why it renders `<html>` and `<body>` itself and
+ * why nothing here may reach for a provider: at this point in a failed render there are none.
+ *
+ * It is light for every viewer, and that is a decision rather than an oversight. The browser's own
+ * `Canvas`/`CanvasText` pair would follow a dark preference for free, and did -- but the Result below
+ * draws in antd's light seed, because the tokens that would say otherwise come from the provider this
+ * page replaced. A dark viewer got antd's near-black title on a near-black ground. The Result's
+ * illustration is drawn light whatever the Theme says, so a light page is what this content is
+ * anyway; `color-scheme: light` keeps the browser from darkening the button underneath it.
+ */
+export declare function PhiNextGlobalErrorPage({ error, reset, }: {
+    error: Error & {
+        digest?: string;
+    };
+    reset: () => void;
+}): import("react").JSX.Element;