@phis/ui 0.1.0 → 0.2.1

package/plugins/runtime-modules/public/trees/phi-default-pub-terms-page-tree.js

@@ -0,0 +1,82 @@
+import { createPhiPresetCmsInstanceIdMap } from "../../../../types/cms-instance-id";
+import { PHI_PUBLIC_RUNTIME_MODULE_ID } from "../ids";
+import { PHI_CMS_DEFAULT_SLOT_INDEX } from "../../../../constants/cms-layout-types";
+import { PhiCmsPageType, PhiCmsRegionType } from "../../../../constants/phi-cms";
+import { createPhiCmsPresetNodes } from "../../../../helpers/cms-preset-nodes";
+/**
+ * Placeholder terms, carried inline. The page used to fetch `/terms-and-conditions.md` from the Site's
+ * `public/` directory, which a fresh Site had to be given first; inline copy needs nothing, and the
+ * Markdown Widget persists it through its content binding the moment the Site takes the page over.
+ * They are placeholders and say so: the first thing an operator does is replace them.
+ */
+const PHI_DEFAULT_PUB_TERMS_MARKDOWN = `# Terms and Conditions
+
+This software is provided as is, without any express or implied warranty.
+
+By using this site, you agree that the operators may change, suspend, or remove features at any time without prior notice.
+
+You are responsible for the accuracy of the information you submit and for keeping your account credentials secure.
+
+You must not use this service for unlawful activity, abuse, or attempts to interfere with the operation of the platform.
+
+To the maximum extent permitted by law, the operators are not liable for any direct, indirect, incidental, or consequential damages arising from the use of this software.
+
+If you do not agree to these terms, do not use this site.
+`;
+const SYNTHETIC_TERMS_REGION_IDS = {
+    regionContent: -320,
+};
+const SYNTHETIC_TERMS_LAYOUT_IDS = createPhiPresetCmsInstanceIdMap({
+    domain: "page",
+    ownerModuleId: PHI_PUBLIC_RUNTIME_MODULE_ID,
+    presetKey: "pub-terms-page",
+}, [
+    "layoutContent",
+]);
+const SYNTHETIC_TERMS_WIDGET_IDS = createPhiPresetCmsInstanceIdMap({
+    domain: "page",
+    ownerModuleId: PHI_PUBLIC_RUNTIME_MODULE_ID,
+    presetKey: "pub-terms-page",
+}, [
+    "widgetMarkdown",
+]);
+export async function buildPhiDefaultPubTermsPageTree({ page, }) {
+    const nodes = createPhiCmsPresetNodes(page);
+    return {
+        page: nodes.page({ pageType: PhiCmsPageType.Standard }),
+        overlays: [],
+        regions: [
+            nodes.region({
+                id: SYNTHETIC_TERMS_REGION_IDS.regionContent,
+                regionType: PhiCmsRegionType.Content,
+                rootLayoutNodeId: SYNTHETIC_TERMS_LAYOUT_IDS.layoutContent,
+                sortOrder: 30,
+            }),
+        ],
+        layoutNodes: [
+            nodes.layout({
+                typeKey: "content",
+                id: SYNTHETIC_TERMS_LAYOUT_IDS.layoutContent,
+                parentLayoutNodeId: null,
+                slotIndex: PHI_CMS_DEFAULT_SLOT_INDEX,
+                sortOrder: 0,
+                label: "pub terms and conditions page",
+                config: {},
+            }),
+        ],
+        contentWidgets: [
+            nodes.widget({
+                typeKey: "markdown",
+                id: SYNTHETIC_TERMS_WIDGET_IDS.widgetMarkdown,
+                parentLayoutNodeId: SYNTHETIC_TERMS_LAYOUT_IDS.layoutContent,
+                slotIndex: PHI_CMS_DEFAULT_SLOT_INDEX,
+                sortOrder: 0,
+                label: "pub terms and conditions markdown widget",
+                config: {
+                    sourceMode: "inline",
+                    markdown: PHI_DEFAULT_PUB_TERMS_MARKDOWN,
+                },
+            }),
+        ],
+    };
+}

package/plugins/runtime-modules/public/trees/phi-default-pub-unsubscribe-page-tree.d.ts

@@ -0,0 +1,16 @@
+import type { PhiCmsPageNode, PhiResolvedCmsPageTree } from "../../../../types/cms";
+/**
+ * Where a circular's footer leads: one sentence and one button.
+ *
+ * Deliberately plain. This is not a page anybody came to read, and everything put in front of the button --
+ * a marketing column, an offer to stay, a confirmation step -- is something between a person and leaving.
+ *
+ * The token comes out of the address and is never shown, which is why the Form carries a hidden field and
+ * the placement maps the query into it. Pressing is a `POST`, and that is the whole reason this is a Form
+ * rather than a link: mail clients and scanners fetch the links in a message before anybody has seen them,
+ * so an address that acted on being fetched would unsubscribe people who never pressed anything.
+ */
+export declare function buildPhiDefaultPubUnsubscribePageTree({ page, presetKey, }: {
+    page: PhiCmsPageNode;
+    presetKey: string;
+}): Promise<PhiResolvedCmsPageTree>;

package/plugins/runtime-modules/public/trees/phi-default-pub-unsubscribe-page-tree.js

@@ -0,0 +1,110 @@
+import { createPhiPresetCmsInstanceIdMap } from "../../../../types/cms-instance-id";
+import { PHI_PUBLIC_RUNTIME_MODULE_ID } from "../ids";
+import { PHI_CMS_DEFAULT_SLOT_INDEX } from "../../../../constants/cms-layout-types";
+import { PhiCmsPageType, PhiCmsRegionType } from "../../../../constants/phi-cms";
+import { createPhiCmsPresetNodes } from "../../../../helpers/cms-preset-nodes";
+import { PHI_SHARED_FORM_IDS } from "../../../../components/forms/shared-form-ids";
+const SYNTHETIC_UNSUBSCRIBE_REGION_IDS = {
+    regionContent: -260,
+};
+/**
+ * Where a circular's footer leads: one sentence and one button.
+ *
+ * Deliberately plain. This is not a page anybody came to read, and everything put in front of the button --
+ * a marketing column, an offer to stay, a confirmation step -- is something between a person and leaving.
+ *
+ * The token comes out of the address and is never shown, which is why the Form carries a hidden field and
+ * the placement maps the query into it. Pressing is a `POST`, and that is the whole reason this is a Form
+ * rather than a link: mail clients and scanners fetch the links in a message before anybody has seen them,
+ * so an address that acted on being fetched would unsubscribe people who never pressed anything.
+ */
+export async function buildPhiDefaultPubUnsubscribePageTree({ page, presetKey, }) {
+    const layoutIds = createPhiPresetCmsInstanceIdMap({
+        domain: "page",
+        ownerModuleId: PHI_PUBLIC_RUNTIME_MODULE_ID,
+        presetKey,
+    }, ["layoutContent"]);
+    const widgetIds = createPhiPresetCmsInstanceIdMap({
+        domain: "page",
+        ownerModuleId: PHI_PUBLIC_RUNTIME_MODULE_ID,
+        presetKey,
+    }, ["widgetIntro", "widgetIncomplete", "widgetUnsubscribe"]);
+    /*
+     * Whether this visit carries a link at all, settled before anything renders -- so the two cases are two
+     * placements with a condition on them rather than a branch inside a component that would have to know
+     * about both. The same shape the password reset's two stages use.
+     */
+    const withToken = { source: "page", valuePath: "query.token", operator: "truthy" };
+    const withoutToken = { source: "page", valuePath: "query.token", operator: "falsy" };
+    const nodes = createPhiCmsPresetNodes(page);
+    return {
+        page: nodes.page({ pageType: PhiCmsPageType.Standard }),
+        overlays: [],
+        regions: [
+            nodes.region({
+                id: SYNTHETIC_UNSUBSCRIBE_REGION_IDS.regionContent,
+                regionType: PhiCmsRegionType.Content,
+                rootLayoutNodeId: layoutIds.layoutContent,
+                sortOrder: 30,
+            }),
+        ],
+        layoutNodes: [
+            nodes.layout({
+                creationPreset: { layoutKind: "verticalflex", preset: "panel" },
+                typeKey: "flex-vertical",
+                id: layoutIds.layoutContent,
+                parentLayoutNodeId: null,
+                slotIndex: PHI_CMS_DEFAULT_SLOT_INDEX,
+                label: "pub unsubscribe page",
+            }),
+        ],
+        contentWidgets: [
+            nodes.widget({
+                typeKey: "description",
+                id: widgetIds.widgetIntro,
+                parentLayoutNodeId: layoutIds.layoutContent,
+                slotIndex: 0,
+                sortOrder: 0,
+                label: "pub unsubscribe intro widget",
+                config: {
+                    title: "Stop receiving updates",
+                    description: "Press the button below and this site will send you no further updates.",
+                    visibleWhen: withToken,
+                },
+            }),
+            /*
+             * A link that arrived without its token is not an error to hide: somebody copied half an address out
+             * of a mail, and the honest answer says where the working one is.
+             */
+            nodes.widget({
+                typeKey: "description",
+                id: widgetIds.widgetIncomplete,
+                parentLayoutNodeId: layoutIds.layoutContent,
+                slotIndex: 1,
+                sortOrder: 0,
+                label: "pub unsubscribe incomplete widget",
+                config: {
+                    title: "This link is incomplete",
+                    description: "Open the unsubscribe link from the message itself, or use the most recent one you received.",
+                    tone: "secondary",
+                    visibleWhen: withoutToken,
+                },
+            }),
+            nodes.widget({
+                typeKey: "form",
+                id: widgetIds.widgetUnsubscribe,
+                parentLayoutNodeId: layoutIds.layoutContent,
+                slotIndex: 2,
+                sortOrder: 0,
+                label: "pub unsubscribe widget",
+                config: {
+                    formId: PHI_SHARED_FORM_IDS.unsubscribe,
+                    submit: "inline",
+                    submitOnEnter: false,
+                    formConfig: { initialValuesFromQuery: { token: "token" } },
+                    visibleWhen: withToken,
+                },
+            }),
+        ],
+    };
+}

package/plugins/runtime-modules/public/trees/phi-default-pub-welcome-page-tree.d.ts

@@ -0,0 +1,15 @@
+import type { PhiCmsPageNode, PhiResolvedCmsPageTree } from "../../../../types/cms";
+import type { PhiBlockRuntime } from "../../../../types";
+/**
+ * The Public front door every Site has, and the one a Module's landing covers (MODULES.md, "Who owns an
+ * address").
+ *
+ * An Area root is drawn without the Shell around it, and that is the whole point of a landing page:
+ * the fonts and the root CSS arrive, nothing of the Area chrome does. So this tree brings the little
+ * frame it wants itself -- a bar with the light and dark switch and a greeting -- and a Content Region
+ * whose copy leads on to the home page that does wear the Shell.
+ */
+export declare function buildPhiDefaultPubWelcomePageTree({ page, runtime, }: {
+    page: PhiCmsPageNode;
+    runtime: PhiBlockRuntime;
+}): Promise<PhiResolvedCmsPageTree>;

package/plugins/runtime-modules/public/trees/phi-default-pub-welcome-page-tree.js

@@ -0,0 +1,194 @@
+import { createPhiPresetCmsInstanceIdMap } from "../../../../types/cms-instance-id";
+import { PHI_PUBLIC_RUNTIME_MODULE_ID } from "../ids";
+import { PHI_PUBLIC_BASE_PAGE_REFERENCES } from "../../public-base-page-references";
+import { PHI_CMS_DEFAULT_SLOT_INDEX, PHI_CMS_SEQUENTIAL_LAYOUT_SLOTS, PHI_CMS_THREE_COLUMN_LAYOUT_SLOT_INDEX, } from "../../../../constants/cms-layout-types";
+import { PhiCmsPageType, PhiCmsRegionType } from "../../../../constants/phi-cms";
+import { createPhiCmsPresetNodes } from "../../../../helpers/cms-preset-nodes";
+import { resolvePhiShellHeaderHeight } from "../../../../helpers/shell-region-style";
+/**
+ * Placeholder copy, carried inline for the reason the terms are: a Module cannot put a file into the
+ * Site's `public/` directory, and the Markdown Widget persists inline copy the moment the Site takes the
+ * page over.
+ */
+const PHI_DEFAULT_PUB_WELCOME_MARKDOWN = `# Welcome
+
+This Site runs on phis.
+
+This page is the front door every Site starts with. It stands at the root until a Module offers a
+landing of its own, or until the Site takes this page over in the Builder and makes it its own.
+`;
+/** How wide the welcome copy is allowed to get, in pixels. Roughly sixty characters at the base size. */
+const PHI_DEFAULT_PUB_WELCOME_MEASURE = 480;
+const SYNTHETIC_WELCOME_REGION_IDS = {
+    regionHeaderBottom: -301,
+    regionContent: -300,
+};
+const SYNTHETIC_WELCOME_LAYOUT_IDS = createPhiPresetCmsInstanceIdMap({
+    domain: "page",
+    ownerModuleId: PHI_PUBLIC_RUNTIME_MODULE_ID,
+    presetKey: "pub-welcome-page",
+}, [
+    "layoutHeaderBottom",
+    "layoutContent",
+    "layoutContentStack",
+]);
+const SYNTHETIC_WELCOME_WIDGET_IDS = createPhiPresetCmsInstanceIdMap({
+    domain: "page",
+    ownerModuleId: PHI_PUBLIC_RUNTIME_MODULE_ID,
+    presetKey: "pub-welcome-page",
+}, [
+    "widgetThemeModeSwitch",
+    "widgetGreeting",
+    "widgetMarkdown",
+    "widgetReadMore",
+]);
+/**
+ * The Public front door every Site has, and the one a Module's landing covers (MODULES.md, "Who owns an
+ * address").
+ *
+ * An Area root is drawn without the Shell around it, and that is the whole point of a landing page:
+ * the fonts and the root CSS arrive, nothing of the Area chrome does. So this tree brings the little
+ * frame it wants itself -- a bar with the light and dark switch and a greeting -- and a Content Region
+ * whose copy leads on to the home page that does wear the Shell.
+ */
+export async function buildPhiDefaultPubWelcomePageTree({ page, runtime, }) {
+    const nodes = createPhiCmsPresetNodes(page);
+    return {
+        page: nodes.page({ pageType: PhiCmsPageType.Landing }),
+        overlays: [],
+        regions: [
+            nodes.region({
+                id: SYNTHETIC_WELCOME_REGION_IDS.regionHeaderBottom,
+                regionType: PhiCmsRegionType.HeaderBottom,
+                rootLayoutNodeId: SYNTHETIC_WELCOME_LAYOUT_IDS.layoutHeaderBottom,
+                sortOrder: 25,
+                config: {
+                    size: { height: `${resolvePhiShellHeaderHeight(runtime.site.theme?.shell, "bottom")}px` },
+                },
+            }),
+            nodes.region({
+                id: SYNTHETIC_WELCOME_REGION_IDS.regionContent,
+                regionType: PhiCmsRegionType.Content,
+                rootLayoutNodeId: SYNTHETIC_WELCOME_LAYOUT_IDS.layoutContent,
+                sortOrder: 30,
+            }),
+        ],
+        layoutNodes: [
+            nodes.layout({
+                creationPreset: { layoutKind: "threecol", preset: "panel" },
+                typeKey: "three-column",
+                id: SYNTHETIC_WELCOME_LAYOUT_IDS.layoutHeaderBottom,
+                parentLayoutNodeId: null,
+                slotIndex: PHI_CMS_DEFAULT_SLOT_INDEX,
+                sortOrder: 0,
+                label: "pub welcome header bottom",
+                config: {
+                    balancedSides: true,
+                    contentAlign: "center",
+                    style: { height: "100%" },
+                },
+            }),
+            nodes.layout({
+                typeKey: "content",
+                id: SYNTHETIC_WELCOME_LAYOUT_IDS.layoutContent,
+                parentLayoutNodeId: null,
+                slotIndex: PHI_CMS_DEFAULT_SLOT_INDEX,
+                sortOrder: 0,
+                label: "pub welcome page",
+                config: {},
+            }),
+            nodes.layout({
+                creationPreset: { layoutKind: "verticalflex", preset: "panel" },
+                typeKey: "flex-vertical",
+                id: SYNTHETIC_WELCOME_LAYOUT_IDS.layoutContentStack,
+                parentLayoutNodeId: SYNTHETIC_WELCOME_LAYOUT_IDS.layoutContent,
+                slotIndex: PHI_CMS_DEFAULT_SLOT_INDEX,
+                sortOrder: 0,
+                label: "pub welcome copy and way on",
+                config: { anchor: { horizontal: "center", vertical: "middle" } },
+            }),
+        ],
+        contentWidgets: [
+            nodes.widget({
+                typeKey: "theme-mode-switch",
+                id: SYNTHETIC_WELCOME_WIDGET_IDS.widgetThemeModeSwitch,
+                parentLayoutNodeId: SYNTHETIC_WELCOME_LAYOUT_IDS.layoutHeaderBottom,
+                slotIndex: PHI_CMS_THREE_COLUMN_LAYOUT_SLOT_INDEX.Right,
+                sortOrder: 0,
+                label: "pub welcome theme mode switch",
+                config: {},
+            }),
+            nodes.widget({
+                typeKey: "simple-text",
+                id: SYNTHETIC_WELCOME_WIDGET_IDS.widgetGreeting,
+                parentLayoutNodeId: SYNTHETIC_WELCOME_LAYOUT_IDS.layoutHeaderBottom,
+                slotIndex: PHI_CMS_THREE_COLUMN_LAYOUT_SLOT_INDEX.Middle,
+                sortOrder: 0,
+                label: "pub welcome greeting",
+                // English source, like every Preset sentence: the Site translator makes it "Herzlich willkommen".
+                config: { text: "A warm welcome" },
+            }),
+            nodes.widget({
+                typeKey: "markdown",
+                id: SYNTHETIC_WELCOME_WIDGET_IDS.widgetMarkdown,
+                parentLayoutNodeId: SYNTHETIC_WELCOME_LAYOUT_IDS.layoutContentStack,
+                slotIndex: PHI_CMS_SEQUENTIAL_LAYOUT_SLOTS[0].slotIndex,
+                sortOrder: 0,
+                label: "pub welcome markdown widget",
+                config: {
+                    sourceMode: "inline",
+                    markdown: PHI_DEFAULT_PUB_WELCOME_MARKDOWN,
+                    textAlign: "center",
+                    /*
+                     * A measure, not a column: the copy stops at 480 so a line stays readable on a wide screen,
+                     * and `min(100%, 480px)` on the frame lets it shrink to a phone.
+                     */
+                    maxSize: { width: PHI_DEFAULT_PUB_WELCOME_MEASURE },
+                    effects: {
+                        /*
+                         * Held until the page has arrived: this Widget's own copy is streamed, and the button below
+                         * it would otherwise stand in the gap and be pushed down when the copy lands.
+                         */
+                        transitionTrigger: "on_ready",
+                        transitions: [
+                            { type: "fade", mode: "in", durationMs: 900, easing: "ease-out" },
+                            { type: "slide", mode: "in", direction: "top", distance: 48, durationMs: 900, easing: "ease-out" },
+                        ],
+                    },
+                },
+            }),
+            nodes.widget({
+                typeKey: "button",
+                id: SYNTHETIC_WELCOME_WIDGET_IDS.widgetReadMore,
+                parentLayoutNodeId: SYNTHETIC_WELCOME_LAYOUT_IDS.layoutContentStack,
+                slotIndex: PHI_CMS_SEQUENTIAL_LAYOUT_SLOTS[1].slotIndex,
+                sortOrder: 0,
+                label: "pub welcome read more button",
+                config: {
+                    key: "read-more",
+                    label: "Read more...",
+                    variant: "primary",
+                    /*
+                     * A link, not a command: it renders a real anchor, which works before hydration.
+                     *
+                     * Named by reference, so the address it resolves to is whatever that Page answers on -- and
+                     * whichever Module holds it. A path typed here pointed at the base Page even where a Site
+                     * package had covered it, and went nowhere the day somebody moved it.
+                     */
+                    linkTarget: {
+                        kind: "page",
+                        reference: PHI_PUBLIC_BASE_PAGE_REFERENCES.home,
+                    },
+                    /* A beat behind the copy, so the page reads before it offers the way on. */
+                    effects: {
+                        transitionTrigger: "on_ready",
+                        transitions: [
+                            { type: "fade", mode: "in", durationMs: 700, delayMs: 450, easing: "ease-out" },
+                            { type: "slide", mode: "in", direction: "bottom", distance: 24, durationMs: 700, delayMs: 450, easing: "ease-out" },
+                        ],
+                    },
+                },
+            }),
+        ],
+    };
+}

package/plugins/runtime-modules/public-base-page-references.d.ts

@@ -0,0 +1,32 @@
+import { createPhiPageReference } from "../../types/references";
+/**
+ * The Public base Pages a package may link to, named once.
+ *
+ * A Module that points at one of them has to say which, and a string typed at the call site is the same
+ * fragility as a path: nothing checks it, and a preset key that is renamed leaves a reference resolving
+ * to nothing. The base descriptors in `area-base-presets.ts` read their keys from here, so the two
+ * cannot drift.
+ *
+ * Kept apart from those descriptors on purpose. They import every base Page tree, and
+ * `@phis/ui/references` hands these keys to package Modules: importing them from beside the trees made
+ * every Module that linked to a base Page compile the whole first-party catalog with it.
+ */
+export declare const PHI_PUBLIC_BASE_PAGE_PRESET_KEYS: {
+    readonly welcome: "public-welcome-page";
+    readonly home: "public-home-page";
+    readonly terms: "public-terms-page";
+    readonly contact: "public-contact-page";
+    readonly unsubscribe: "public-unsubscribe-page";
+};
+/**
+ * Ready-made references to the Pages every Site has, for a Module that links to one.
+ *
+ * The Public base brings a welcome, a home, terms and a contact Page, and a package Module may
+ * reasonably point at any of them -- phis.dev's closing line does exactly that. Without this it would
+ * either type a path, which goes stale and cannot say which Module's Page it means where one covers
+ * another, or assemble a reference from a preset key it copied, which nothing checks.
+ *
+ * Computed rather than stored: a Module Page reference is a function of its identity alone, so these
+ * cost nothing and can never disagree with the descriptors they are derived from.
+ */
+export declare const PHI_PUBLIC_BASE_PAGE_REFERENCES: Readonly<Record<keyof typeof PHI_PUBLIC_BASE_PAGE_PRESET_KEYS, ReturnType<typeof createPhiPageReference>>>;

package/plugins/runtime-modules/public-base-page-references.js

@@ -0,0 +1,43 @@
+import { createPhiPageReference } from "../../types/references";
+import { PHI_SHARED_PACKAGE_NAME } from "../../constants/package";
+import { createPhiRuntimeModuleId } from "../../constants/module-identity";
+/**
+ * The Public base Pages a package may link to, named once.
+ *
+ * A Module that points at one of them has to say which, and a string typed at the call site is the same
+ * fragility as a path: nothing checks it, and a preset key that is renamed leaves a reference resolving
+ * to nothing. The base descriptors in `area-base-presets.ts` read their keys from here, so the two
+ * cannot drift.
+ *
+ * Kept apart from those descriptors on purpose. They import every base Page tree, and
+ * `@phis/ui/references` hands these keys to package Modules: importing them from beside the trees made
+ * every Module that linked to a base Page compile the whole first-party catalog with it.
+ */
+export const PHI_PUBLIC_BASE_PAGE_PRESET_KEYS = {
+    welcome: "public-welcome-page",
+    home: "public-home-page",
+    terms: "public-terms-page",
+    contact: "public-contact-page",
+    unsubscribe: "public-unsubscribe-page",
+};
+// Named by id, as data, for the same reason: `public/ids` would bind the door to the Module folder.
+const PHI_PUBLIC_RUNTIME_MODULE_ID = createPhiRuntimeModuleId(PHI_SHARED_PACKAGE_NAME, "public");
+/**
+ * Ready-made references to the Pages every Site has, for a Module that links to one.
+ *
+ * The Public base brings a welcome, a home, terms and a contact Page, and a package Module may
+ * reasonably point at any of them -- phis.dev's closing line does exactly that. Without this it would
+ * either type a path, which goes stale and cannot say which Module's Page it means where one covers
+ * another, or assemble a reference from a preset key it copied, which nothing checks.
+ *
+ * Computed rather than stored: a Module Page reference is a function of its identity alone, so these
+ * cost nothing and can never disagree with the descriptors they are derived from.
+ */
+export const PHI_PUBLIC_BASE_PAGE_REFERENCES = Object.freeze(Object.fromEntries(Object.entries(PHI_PUBLIC_BASE_PAGE_PRESET_KEYS).map(([name, presetKey]) => [
+    name,
+    createPhiPageReference({
+        kind: "module",
+        ownerModuleId: PHI_PUBLIC_RUNTIME_MODULE_ID,
+        presetKey,
+    }),
+])));

package/plugins/runtime-modules/resolver.js

@@ -5,8 +5,9 @@ import { assertPhiRuntimeModule, buildPhiRuntimeModuleLayoutType, buildPhiRuntim
 import { readPhiRuntimeTreeRenderMode, resolvePhiRuntimeWidgetImplementationMode, } from "./render-mode";
 import { resolvePhiRuntimeModuleServerBinding } from "./server-capabilities";
 import { PHI_VIEWER_ACCESS_ANYONE, } from "../../types/access";
+import { stripRenderableBlockDefaults } from "../../helpers/renderable-block-serialization";
 import { PhiCmsWidgetType } from "../../constants/cms-widget-types";
-import { parsePhiFormWidgetConfig } from "./core/widgets/form/config";
+import { parsePhiFormWidgetConfig } from "../../components/forms/form-widget-config";
 function loadRuntimeWidgetPlugin(entry) {
     return entry.loadRuntime();
 }
@@ -16,13 +17,6 @@ function loadPreviewWidgetPlugin(entry) {
 function loadLayoutPlugin(entry) {
     return entry.loadRuntime();
 }
-function loadUiProvider(catalogEntry) {
-    const loader = catalogEntry.loadUiProvider;
-    if (!loader) {
-        return null;
-    }
-    return loader();
-}
 function loadModule(catalog, moduleId) {
     const catalogEntry = catalog.get(moduleId);
     if (!catalogEntry) {
@@ -63,6 +57,10 @@ function loadModule(catalog, moduleId) {
             JSON.stringify(catalogEntry.definition.calendarAdapters ?? [])) {
             throw new Error(`Runtime module "${moduleId}" Calendar adapter descriptors do not match its catalog definition.`);
         }
+        if (JSON.stringify(runtimeModule.videoProviders ?? []) !==
+            JSON.stringify(catalogEntry.definition.videoProviders ?? [])) {
+            throw new Error(`Runtime module "${moduleId}" video provider descriptors do not match its catalog definition.`);
+        }
         return runtimeModule;
     });
 }
@@ -120,6 +118,7 @@ export async function resolvePhiRuntimeModuleSet({ catalog, moduleIds, area, ser
     const layoutDefinitionsByType = new Map();
     const dataProviderDescriptorsByKey = new Map();
     const calendarAdapterDescriptorsByKey = new Map();
+    const videoProviderDescriptorsByKey = new Map();
     const formFieldTypeProviderDescriptorsByKey = new Map();
     const formValidationProviderDescriptorsByKey = new Map();
     const formHandlerProviderDescriptorsByKey = new Map();
@@ -172,6 +171,12 @@ export async function resolvePhiRuntimeModuleSet({ catalog, moduleIds, area, ser
             }
             calendarAdapterDescriptorsByKey.set(descriptor.key, descriptor);
         }
+        for (const descriptor of definition.videoProviders ?? []) {
+            if (videoProviderDescriptorsByKey.has(descriptor.key)) {
+                throw new Error(`Video provider "${descriptor.key}" is owned by more than one runtime module.`);
+            }
+            videoProviderDescriptorsByKey.set(descriptor.key, descriptor);
+        }
         for (const descriptor of definition.formProviders?.fieldTypes ?? []) {
             if (formFieldTypeProviderDescriptorsByKey.has(descriptor.key)) {
                 throw new Error(`Form field type provider "${descriptor.key}" is owned by more than one runtime module.`);
@@ -230,6 +235,7 @@ export async function resolvePhiRuntimeModuleSet({ catalog, moduleIds, area, ser
         layoutDefinitionsByType,
         dataProviderDescriptorsByKey,
         calendarAdapterDescriptorsByKey,
+        videoProviderDescriptorsByKey,
         formFieldTypeProviderDescriptorsByKey,
         formValidationProviderDescriptorsByKey,
         formHandlerProviderDescriptorsByKey,
@@ -509,7 +515,7 @@ export async function resolvePhiRuntimeRenderRegistry({ catalog, moduleSet, tree
             return null;
         }
     }));
-    const [runtimeWidgetPluginResults, previewWidgetPluginResults, layoutPluginResults, uiProviderResults] = await Promise.all([
+    const [runtimeWidgetPluginResults, previewWidgetPluginResults, layoutPluginResults] = await Promise.all([
         loadRuntimeWidgetEntries(runtimeWidgetEntries, runtimeWidgetRenderIssuesByType),
         loadPreviewWidgetEntries(previewWidgetEntries, previewWidgetRenderIssuesByType),
         Promise.all(layoutEntries.map(async ([type, entry]) => {
@@ -532,60 +538,11 @@ export async function resolvePhiRuntimeRenderRegistry({ catalog, moduleSet, tree
                 return null;
             }
         })),
-        Promise.all([...usedModuleIds].flatMap((moduleId) => {
-            const catalogEntry = catalog.get(moduleId);
-            return catalogEntry?.loadUiProvider ? [[moduleId, catalogEntry]] : [];
-        }).map(async ([moduleId, catalogEntry]) => {
-            try {
-                const provider = await loadUiProvider(catalogEntry);
-                return { moduleId, provider, error: null };
-            }
-            catch (error) {
-                return { moduleId, provider: null, error };
-            }
-        })),
     ]);
     const runtimeWidgetPluginsByType = new Map(runtimeWidgetPluginResults.filter((entry) => entry != null));
     const previewWidgetPluginsByType = new Map(previewWidgetPluginResults.filter((entry) => entry != null));
     const layoutPluginsByType = new Map(layoutPluginResults.filter((entry) => entry != null));
-    const uiProvidersByModuleId = new Map();
-    for (const result of uiProviderResults) {
-        if (result.error) {
-            for (const [type, entry] of widgetEntries) {
-                if (entry.ownerModuleId !== result.moduleId) {
-                    continue;
-                }
-                runtimeWidgetPluginsByType.delete(type);
-                previewWidgetPluginsByType.delete(type);
-                const issue = reportRenderIssue({
-                    code: "renderer-load-failed",
-                    kind: "widget",
-                    type,
-                    moduleId: result.moduleId,
-                    detail: `Module UI provider failed: ${readRenderIssueDetail(result.error)}`,
-                }, result.error);
-                runtimeWidgetRenderIssuesByType.set(type, issue);
-                previewWidgetRenderIssuesByType.set(type, issue);
-            }
-            for (const [type, entry] of layoutEntries) {
-                if (entry.ownerModuleId !== result.moduleId) {
-                    continue;
-                }
-                layoutPluginsByType.delete(type);
-                renderIssuesByLayoutType.set(type, reportRenderIssue({
-                    code: "renderer-load-failed",
-                    kind: "layout",
-                    type,
-                    moduleId: result.moduleId,
-                    detail: `Module UI provider failed: ${readRenderIssueDetail(result.error)}`,
-                }, result.error));
-            }
-            continue;
-        }
-        if (result.provider) {
-            uiProvidersByModuleId.set(result.moduleId, result.provider);
-        }
-    }
+    const uiProviderModuleIds = new Set([...usedModuleIds].filter((moduleId) => catalog.get(moduleId)?.uiProvider === true));
     return {
         runtimeModuleCatalog: catalog,
         serverCapabilities,
@@ -616,8 +573,26 @@ export async function resolvePhiRuntimeRenderRegistry({ catalog, moduleSet, tree
         renderIssuesByLayoutType,
         ownerModuleIdByWidgetType: new Map(widgetEntries.map(([type, entry]) => [type, entry.ownerModuleId])),
         widgetSlotSizePoliciesByType: new Map(widgetEntries.map(([type, entry]) => [type, entry.definition.slotSizePolicy])),
+        /*
+         * What a Widget states about its own block, for the nodes that state nothing.
+         *
+         * A Widget's `defaultConfig` reaches a node two ways today: the Builder writes it into the node it
+         * creates, and the Inspector reads it under the node it edits. A Preset tree reaches it neither way
+         * -- its nodes are written by hand -- so a Form placed by a Preset rendered without the reading
+         * measure its Widget declares, while the same Form dropped in the Builder carried it. The third
+         * reader is the slot frame, and this is what it reads.
+         *
+         * Only the block base, taken with `stripRenderableBlockDefaults`, which is exactly "what this block
+         * says beyond the house answer": a size, a cap, a ground, a border. A Widget's own fields stay out
+         * -- a Segmented's field key, an Icon's glyph, a Table's source are answered by its parser where a
+         * node is silent, and inheriting those would change what a Preset means rather than how wide it is.
+         */
+        widgetBlockDefaultsByType: new Map(widgetEntries.flatMap(([type, entry]) => {
+            const defaults = stripRenderableBlockDefaults(entry.definition.defaultConfig);
+            return Object.keys(defaults).length > 0 ? [[type, defaults]] : [];
+        })),
         ownerModuleIdByLayoutType: new Map(layoutEntries.map(([type, entry]) => [type, entry.ownerModuleId])),
-        uiProvidersByModuleId,
+        uiProviderModuleIds,
         /*
          * Every active Module's published facts, whether or not its Widgets happen to be on this page.
          *