@phis/ui 0.2.1 → 0.3.0

package/plugins/runtime-modules/threads/trees/{phi-default-app-threads-page-tree.js → phi-default-threads-page-tree.js}

@@ -5,15 +5,20 @@ import { createPhiSignalAddress, createPhiSignalSubcontrolAddress, PHI_SIGNAL_VA
 import { PHI_THREAD_LIBRARY_DATA_PROVIDER_KEYS } from "../../../../constants/thread-library-provider-keys";
 import { PhisThreadKind, PhisThreadStatus } from "../../../../constants/threads";
 import { createPhiThreadsControllerAddress, PHI_THREADS_CONTROLLER_INSTANCE_KEY, PHI_THREADS_CONTROLLER_TYPE, } from "../controller/address";
-import { PHI_APP_THREADS_PAGE_LAYOUT_IDS, PHI_APP_THREADS_PAGE_OVERLAY_IDS, PHI_APP_THREADS_PAGE_WIDGET_IDS, } from "../addresses";
-import { createPhiRuntimeFormControllerAddress } from "../../../../components/forms/runtime-form-controller-address";
+import { createPhiThreadsPageIds } from "../addresses";
 import { PHI_THREADS_FORM_IDS } from "../forms";
-import { PHI_COLOR, PHI_SPACE } from "../../../../theme/antd-css-var-contract";
+import { PHI_SHARED_FORM_IDS } from "../../../../components/forms/shared-form-ids";
 import { buildPhiBasePageContentScaffold, PHI_BASE_PAGE_LAYOUT_NODE_ID } from "../../../../components/regions/presets/phi-base-page-layout";
-import { getPhiThreadPageLabels } from "../../../../components/widgets/label-sets/threads";
+import { getPhiThreadPageLabels } from "../labels";
 import { readPhiServerApiCredentials } from "../../../../helpers/phis-server-credentials";
-const SYNTHETIC_APP_THREADS_REGION_IDS = {
-    regionContent: -453,
+import { PHI_DIALOG_BODY_CONFIG, PHI_DIALOG_COMMANDS_CONFIG } from "../../../../helpers/cms-dialog";
+/** The content region of each Area's conversations Page. */
+const SYNTHETIC_THREADS_REGION_ID_BY_AREA = {
+    app: -453,
+    accounting: -454,
+    admin: -455,
+    editor: -456,
+    builder: -457,
 };
 /**
  * The three surfaces of a conversation, placed and wired.
@@ -32,7 +37,8 @@ const SYNTHETIC_APP_THREADS_REGION_IDS = {
  * route below could equally have been drawn in the Builder -- the Controller excepted, which still
  * names the Page's Widgets by id rather than by route (TODOS.md).
  */
-export async function buildPhiDefaultAppThreadsPageTree({ page, runtime, }) {
+export async function buildPhiDefaultThreadsPageTree({ page, runtime, area, }) {
+    const { widgets: widgetIds, overlays: overlayIds, layouts: layoutIds } = createPhiThreadsPageIds(area);
     const credentials = readPhiServerApiCredentials();
     const labels = await getPhiThreadPageLabels({
         apiBaseUrl: credentials.apiBaseUrl,
@@ -40,27 +46,95 @@ export async function buildPhiDefaultAppThreadsPageTree({ page, runtime, }) {
         locale: runtime.locale.current,
     });
     const controllerAddress = createPhiThreadsControllerAddress();
-    const inboxAddress = createPhiSignalAddress("cms", PHI_APP_THREADS_PAGE_WIDGET_IDS.widgetInbox);
-    const conversationAddress = createPhiSignalAddress("cms", PHI_APP_THREADS_PAGE_WIDGET_IDS.widgetConversation);
-    const composerAddress = createPhiSignalAddress("cms", PHI_APP_THREADS_PAGE_WIDGET_IDS.widgetComposer);
-    const composerEmptyAddress = createPhiSignalAddress("cms", PHI_APP_THREADS_PAGE_WIDGET_IDS.widgetComposerEmpty);
-    /*
-     * The reply Form is told its conversation through its own Form controller, not at its Widget address.
-     *
-     * That is the declared way into a mounted Form's values: the controller takes `field/change` and hands
-     * it to the Form it belongs to, which writes the field the route names
-     * ([FORMS.md](../../../FORMS.md#form-controller)).
-     */
-    const composerFormControllerAddress = createPhiRuntimeFormControllerAddress(`widget-${PHI_APP_THREADS_PAGE_WIDGET_IDS.widgetComposer}`);
-    const formAddress = createPhiSignalAddress("cms", PHI_APP_THREADS_PAGE_WIDGET_IDS.widgetNewForm);
-    const overlayAddress = createPhiSignalAddress("cms", PHI_APP_THREADS_PAGE_OVERLAY_IDS.overlayNew);
-    const saveButtonAddress = createPhiSignalSubcontrolAddress("cms", PHI_APP_THREADS_PAGE_WIDGET_IDS.widgetNewCommands, "save");
+    const inboxAddress = createPhiSignalAddress("cms", widgetIds.widgetInbox);
+    const conversationAddress = createPhiSignalAddress("cms", widgetIds.widgetConversation);
+    const replyOverlayAddress = createPhiSignalAddress("cms", overlayIds.overlayReply);
+    const replyFormAddress = createPhiSignalAddress("cms", widgetIds.widgetReplyForm);
+    const formAddress = createPhiSignalAddress("cms", widgetIds.widgetNewForm);
+    const overlayAddress = createPhiSignalAddress("cms", overlayIds.overlayNew);
+    const saveButtonAddress = createPhiSignalSubcontrolAddress("cms", widgetIds.widgetNewCommands, "save");
     const scaffold = buildPhiBasePageContentScaffold({
         page,
-        regionId: SYNTHETIC_APP_THREADS_REGION_IDS.regionContent,
-        regionConfig: { border: false },
+        regionId: SYNTHETIC_THREADS_REGION_ID_BY_AREA[area],
     });
     const nodes = createPhiCmsPresetNodes(page);
+    /*
+     * Answering the open conversation, in a dialog of Core's shape with Core's Reply Form.
+     *
+     * The conversation's Reply names the thread as its row; the dialog opens on it and the Form reads the
+     * thread from that row (`recordOpen`, the thread inbox as its `source`). Its success reaches the
+     * Controller, which makes the reader catch up and the listing reorder, and closes the dialog itself.
+     */
+    const replyDialog = nodes.dialog({
+        id: overlayIds.overlayReply,
+        bodyLayoutNodeId: layoutIds.layoutReply,
+        sortOrder: 1,
+        label: "app-threads-reply-modal",
+        config: {
+            title: labels.composerLabel,
+            mountPolicy: "remount",
+            closeMode: "immediate",
+            openActionKey: "reply",
+            signalRoutes: {
+                listens: [{
+                        routeKey: "app-threads-reply-open",
+                        capabilityId: "open",
+                        scope: "page",
+                        channel: "action",
+                        action: "activate",
+                        valueType: "json",
+                        valueSchema: PHI_SIGNAL_VALUE_SCHEMAS.tableAction,
+                        receiver: replyOverlayAddress,
+                    }, {
+                        routeKey: "app-threads-reply-close",
+                        capabilityId: "close",
+                        scope: "page",
+                        channel: "dialog",
+                        action: "close",
+                        valueType: "none",
+                        receiver: replyOverlayAddress,
+                    }],
+            },
+        },
+        commands: {
+            footerLayoutNodeId: layoutIds.layoutReplyFooter,
+            widgetId: widgetIds.widgetReplyCommands,
+            label: labels.composerLabel,
+            flags: PhiCmsFlags.NoTranslate,
+            config: {
+                key: "app-threads-reply-commands",
+                buttons: [
+                    { key: "cancel", emits: [{ capabilityId: "close", value: null }], action: "cancel", icon: "cancel" },
+                    {
+                        key: "submit",
+                        emits: [{ capabilityId: "submit", value: null }],
+                        label: labels.replySendLabel,
+                        variant: "primary",
+                        icon: "antd:send-outlined",
+                    },
+                ],
+                signalRoutes: {
+                    emits: [{
+                            routeKey: "app-threads-reply-cancel",
+                            capabilityId: "close",
+                            scope: "page",
+                            channel: "dialog",
+                            action: "close",
+                            valueType: "none",
+                            receiver: replyOverlayAddress,
+                        }, {
+                            routeKey: "app-threads-reply-commands-submit",
+                            capabilityId: "submit",
+                            scope: "page",
+                            channel: "submit",
+                            action: "activate",
+                            valueType: "none",
+                            receiver: replyFormAddress,
+                        }],
+                },
+            },
+        },
+    });
     return {
         page: nodes.page({ pageType: PhiCmsPageType.Standard }),
         pageMeta: {
@@ -100,25 +174,6 @@ export async function buildPhiDefaultAppThreadsPageTree({ page, runtime, }) {
                                 valueSchema: PHI_SIGNAL_VALUE_SCHEMAS.threadSelection,
                                 receiver: conversationAddress,
                             },
-                            /*
-                             * The same choice, as a value in the reply Form's hidden field.
-                             *
-                             * `fieldKey` is here and not in the Controller's code, which is the whole point: the
-                             * Controller says which conversation is open, and this Page says that the reply calls it
-                             * `threadId`. A Site that renames the field, or points the Controller at a Form of its own,
-                             * changes this line and nothing else.
-                             */
-                            {
-                                routeKey: "app-threads-controller-thread-field",
-                                capabilityId: "threadField",
-                                scope: "page",
-                                channel: "field",
-                                action: "change",
-                                valueType: "json",
-                                valueSchema: PHI_SIGNAL_VALUE_SCHEMAS.formField,
-                                fieldKey: "threadId",
-                                receiver: composerFormControllerAddress,
-                            },
                             /*
                              * A reply landed in the conversation that is already open: it catches up rather than
                              * switching, which is what keeps a half-written next message where it was.
@@ -133,43 +188,6 @@ export async function buildPhiDefaultAppThreadsPageTree({ page, runtime, }) {
                                 valueSchema: PHI_SIGNAL_VALUE_SCHEMAS.threadSelection,
                                 receiver: conversationAddress,
                             },
-                            // The reply is emptied once it has been sent. Cancelling the dialog must not do this.
-                            {
-                                routeKey: "app-threads-controller-reply-reset",
-                                capabilityId: "replyReset",
-                                scope: "page",
-                                channel: "reset",
-                                action: "activate",
-                                valueType: "none",
-                                receiver: composerAddress,
-                            },
-                            /*
-                             * Whether anything is open at all, to the two nodes that answer for it.
-                             *
-                             * The reply Form stands where a conversation is open, and the sentence stands where none is.
-                             * A visibility gate never asks -- it listens at the node's own address -- so the state is
-                             * pushed here, and each node reads the same fact with the opposite operator.
-                             */
-                            {
-                                routeKey: "app-threads-controller-composer-condition",
-                                capabilityId: "conditionStateChange",
-                                scope: "page",
-                                channel: "condition",
-                                action: "change",
-                                valueType: "json",
-                                valueSchema: PHI_SIGNAL_VALUE_SCHEMAS.runtimeConditionState,
-                                receiver: composerAddress,
-                            },
-                            {
-                                routeKey: "app-threads-controller-composer-empty-condition",
-                                capabilityId: "conditionStateChange",
-                                scope: "page",
-                                channel: "condition",
-                                action: "change",
-                                valueType: "json",
-                                valueSchema: PHI_SIGNAL_VALUE_SCHEMAS.runtimeConditionState,
-                                receiver: composerEmptyAddress,
-                            },
                             {
                                 routeKey: "app-threads-controller-reload-inbox",
                                 capabilityId: "reload",
@@ -236,11 +254,11 @@ export async function buildPhiDefaultAppThreadsPageTree({ page, runtime, }) {
          * opened with nobody watching -- the Controller decides, which is what "request" means.
          */
         overlays: [nodes.overlay({
-                id: PHI_APP_THREADS_PAGE_OVERLAY_IDS.overlayNew,
+                id: overlayIds.overlayNew,
                 overlayType: "modal",
-                bodyLayoutNodeId: PHI_APP_THREADS_PAGE_LAYOUT_IDS.layoutNew,
+                bodyLayoutNodeId: layoutIds.layoutNew,
                 footerPresentation: "actions",
-                footerLayoutNodeId: PHI_APP_THREADS_PAGE_LAYOUT_IDS.layoutNewFooter,
+                footerLayoutNodeId: layoutIds.layoutNewFooter,
                 sortOrder: 0,
                 label: "app-threads-new-modal",
                 config: {
@@ -286,12 +304,13 @@ export async function buildPhiDefaultAppThreadsPageTree({ page, runtime, }) {
                             }],
                     },
                 },
-            })],
+            }), replyDialog.overlay],
         regions: [scaffold.region],
         layoutNodes: [
             scaffold.layoutNode,
+            ...replyDialog.layouts,
             nodes.layout({
-                id: PHI_APP_THREADS_PAGE_LAYOUT_IDS.layoutNew,
+                id: layoutIds.layoutNew,
                 parentLayoutNodeId: null,
                 creationPreset: { layoutKind: "verticalflex", preset: "panel" },
                 typeKey: "flex-vertical",
@@ -299,16 +318,12 @@ export async function buildPhiDefaultAppThreadsPageTree({ page, runtime, }) {
                 sortOrder: 0,
                 label: "app threads new modal content",
                 config: {
+                    ...PHI_DIALOG_BODY_CONFIG,
                     anchor: { horizontal: "left", vertical: "top" },
-                    gap: PHI_SPACE.base,
-                    margin: 0,
-                    padding: PHI_SPACE.base,
-                    background: PHI_COLOR.bgLayout,
-                    border: false,
                 },
             }),
             nodes.layout({
-                id: PHI_APP_THREADS_PAGE_LAYOUT_IDS.layoutNewFooter,
+                id: layoutIds.layoutNewFooter,
                 parentLayoutNodeId: null,
                 creationPreset: { layoutKind: "flex", preset: "overlay-actions" },
                 typeKey: "flex",
@@ -320,7 +335,7 @@ export async function buildPhiDefaultAppThreadsPageTree({ page, runtime, }) {
         ],
         contentWidgets: [
             nodes.widget({
-                id: PHI_APP_THREADS_PAGE_WIDGET_IDS.widgetInbox,
+                id: widgetIds.widgetInbox,
                 parentLayoutNodeId: PHI_BASE_PAGE_LAYOUT_NODE_ID,
                 typeKey: "table",
                 /*
@@ -393,6 +408,15 @@ export async function buildPhiDefaultAppThreadsPageTree({ page, runtime, }) {
                             },
                         ],
                         emptyState: { title: labels.inboxEmpty, description: labels.inboxEmptyHint },
+                        // How many there are and how many wait to be read, across every page of the listing.
+                        footer: {
+                            template: labels.inboxFooter,
+                            values: [
+                                { key: "total", value: { source: "core", fieldKey: "totalRows" } },
+                                { key: "unread", value: { source: "provider", fieldKey: "unread" } },
+                            ],
+                            align: "start",
+                        },
                     },
                     features: {
                         // Choosing one is the whole point of the listing, and a conversation is read one at a time.
@@ -533,8 +557,8 @@ export async function buildPhiDefaultAppThreadsPageTree({ page, runtime, }) {
              * has one footer, and it is the dialog's.
              */
             nodes.widget({
-                id: PHI_APP_THREADS_PAGE_WIDGET_IDS.widgetNewForm,
-                parentLayoutNodeId: PHI_APP_THREADS_PAGE_LAYOUT_IDS.layoutNew,
+                id: widgetIds.widgetNewForm,
+                parentLayoutNodeId: layoutIds.layoutNew,
                 typeKey: "form",
                 slotIndex: PHI_CMS_DEFAULT_SLOT_INDEX,
                 sortOrder: 0,
@@ -584,21 +608,18 @@ export async function buildPhiDefaultAppThreadsPageTree({ page, runtime, }) {
                 },
             }),
             nodes.widget({
-                id: PHI_APP_THREADS_PAGE_WIDGET_IDS.widgetNewCommands,
-                parentLayoutNodeId: PHI_APP_THREADS_PAGE_LAYOUT_IDS.layoutNewFooter,
+                id: widgetIds.widgetNewCommands,
+                parentLayoutNodeId: layoutIds.layoutNewFooter,
                 typeKey: "command-toolbar",
                 slotIndex: PHI_CMS_DEFAULT_SLOT_INDEX,
                 sortOrder: 0,
                 label: labels.openConversationLabel,
                 config: {
                     key: "app-threads-new-commands",
-                    compact: false,
-                    wrap: true,
-                    showLabels: true,
-                    controlSize: "medium",
+                    ...PHI_DIALOG_COMMANDS_CONFIG,
                     buttons: [
-                        { key: "cancel", emits: [{ capabilityId: "command", value: "cancel" }], actionKey: "cancel", label: labels.cancelLabel },
-                        { key: "save", emits: [{ capabilityId: "command", value: "save" }], actionKey: "save", label: labels.openConversationLabel, variant: "primary" },
+                        { key: "cancel", emits: [{ capabilityId: "command", value: "cancel" }], label: labels.cancelLabel, icon: "cancel" },
+                        { key: "save", emits: [{ capabilityId: "command", value: "save" }], label: labels.openConversationLabel, variant: "primary", icon: "save" },
                     ],
                     signalRoutes: {
                         emits: [{
@@ -623,14 +644,45 @@ export async function buildPhiDefaultAppThreadsPageTree({ page, runtime, }) {
                 },
             }),
             nodes.widget({
-                id: PHI_APP_THREADS_PAGE_WIDGET_IDS.widgetConversation,
+                id: widgetIds.widgetConversation,
                 parentLayoutNodeId: PHI_BASE_PAGE_LAYOUT_NODE_ID,
                 typeKey: "thread-conversation",
                 slotIndex: PHI_CMS_DEFAULT_SLOT_INDEX + 1,
                 sortOrder: 1,
                 label: labels.title,
                 config: {
+                    reply: true,
                     signalRoutes: {
+                        // A conversation opened from `?thread=` reaches the Controller, which knows it is open.
+                        emits: [{
+                                routeKey: "app-threads-conversation-opened",
+                                capabilityId: "opened",
+                                scope: "page",
+                                channel: "opened",
+                                action: "change",
+                                valueType: "json",
+                                valueSchema: PHI_SIGNAL_VALUE_SCHEMAS.threadSelection,
+                                receiver: controllerAddress,
+                            }, {
+                                // Reply: one announcement, two listeners -- the dialog opens on it, the Form reads its row.
+                                routeKey: "app-threads-conversation-reply",
+                                capabilityId: "reply",
+                                scope: "page",
+                                channel: "action",
+                                action: "activate",
+                                valueType: "json",
+                                valueSchema: PHI_SIGNAL_VALUE_SCHEMAS.tableAction,
+                                receiver: replyOverlayAddress,
+                            }, {
+                                routeKey: "app-threads-conversation-reply-record",
+                                capabilityId: "reply",
+                                scope: "page",
+                                channel: "action",
+                                action: "activate",
+                                valueType: "json",
+                                valueSchema: PHI_SIGNAL_VALUE_SCHEMAS.tableAction,
+                                receiver: replyFormAddress,
+                            }],
                         listens: [{
                                 routeKey: "app-threads-conversation-select",
                                 capabilityId: "select",
@@ -654,60 +706,27 @@ export async function buildPhiDefaultAppThreadsPageTree({ page, runtime, }) {
                 },
             }),
             /*
-             * Writing into the open conversation: a declared Form, placed like any other.
-             *
-             * What stood here was a Widget of its own with its own text state, its own upload session and its
-             * own `fetch` to a REST path. Everything it did is declared now -- the message and the attachment
-             * are field descriptors, the send button is this placement's, the wording is a label set, and the
-             * submit is a handler Provider behind the Form gateway.
-             *
-             * The conversation it writes into arrives as a field value from the Controller, which is the one
-             * thing a descriptor cannot say: the route above names the field, and this node says nothing about
-             * where the value comes from.
+             * Writing into the open conversation: Core's Reply Form, in the dialog above.
              *
+             * It reads its thread from the row the conversation's Reply named, through the thread inbox as its
+             * `source` -- so it cannot be pointed at a conversation other than the one the Reply was pressed in.
              * It reports its success to the Controller, which is what makes the surfaces around it live: the
-             * conversation catches up, the listing reorders, the reply empties, and the conversation it was
-             * written into is asserted again -- an emptied Form has only its initial values, and this one was
-             * never among them.
+             * conversation catches up and the listing reorders; and to the dialog, which closes.
              */
             nodes.widget({
-                id: PHI_APP_THREADS_PAGE_WIDGET_IDS.widgetComposer,
-                parentLayoutNodeId: PHI_BASE_PAGE_LAYOUT_NODE_ID,
+                id: widgetIds.widgetReplyForm,
+                parentLayoutNodeId: layoutIds.layoutReply,
                 typeKey: "form",
-                slotIndex: PHI_CMS_DEFAULT_SLOT_INDEX + 2,
-                sortOrder: 2,
+                slotIndex: PHI_CMS_DEFAULT_SLOT_INDEX,
                 label: labels.composerLabel,
                 flags: PhiCmsFlags.NoTranslate,
                 config: {
-                    formId: PHI_THREADS_FORM_IDS.message,
+                    formId: PHI_SHARED_FORM_IDS.threadReply,
                     formConfig: {},
                     execution: { mode: "handler" },
-                    source: null,
-                    // The same box the conversation above it wears, so the two read as one panel.
-                    card: { presentation: "card" },
-                    /*
-                     * And the same width, which is why the house ceiling is lifted here.
-                     *
-                     * A Form is capped at the reading measure by default, because an input line nobody can read
-                     * along is the ordinary mistake. This one stands under a conversation that runs the page, and a
-                     * reply box two thirds as wide as the messages above it reads as something that fell out of
-                     * the panel rather than as its last row.
-                     */
-                    maxFormWidth: "100%",
-                    // Already translated, from this Page's own label set, so the Widget states it outright.
-                    submit: "inline",
-                    /*
-                     * Out of sight until there is something to write into.
-                     *
-                     * The hidden conversation field is `required`, so a Form shown without one would refuse its own
-                     * submit with a message on a field nobody can see. The sentence below stands in its place.
-                     */
-                    visibleWhen: {
-                        source: "controller",
-                        controllerAddress,
-                        valuePath: "threadOpen",
-                        operator: "truthy",
-                    },
+                    source: { providerKey: PHI_THREAD_LIBRARY_DATA_PROVIDER_KEYS.table, resourceKey: "inbox" },
+                    openActionKey: "reply",
+                    feedback: { mode: "message" },
                     signalRoutes: {
                         emits: [{
                                 routeKey: "app-threads-reply-success",
@@ -719,57 +738,36 @@ export async function buildPhiDefaultAppThreadsPageTree({ page, runtime, }) {
                                 valueSchema: PHI_SIGNAL_VALUE_SCHEMAS.formResult,
                                 receiver: controllerAddress,
                             }, {
-                                /*
-                                 * Emptied, and therefore no longer about any conversation. The Controller answers this by
-                                 * saying which one is open again -- after the emptying rather than beside it, because the
-                                 * two travel a different number of hops and the shorter one would be undone.
-                                 */
-                                routeKey: "app-threads-reply-reset-complete",
-                                capabilityId: "resetComplete",
+                                routeKey: "app-threads-reply-success-close",
+                                capabilityId: "submitSuccess",
                                 scope: "page",
-                                channel: "reset",
-                                action: "activate",
+                                channel: "dialog",
+                                action: "close",
                                 valueType: "none",
-                                receiver: controllerAddress,
+                                receiver: replyOverlayAddress,
                             }],
                         listens: [{
-                                routeKey: "app-threads-reply-reset",
-                                capabilityId: "reset",
+                                routeKey: "app-threads-reply-submit",
+                                capabilityId: "submit",
                                 scope: "page",
-                                channel: "reset",
+                                channel: "submit",
                                 action: "activate",
                                 valueType: "none",
-                                receiver: composerAddress,
+                                receiver: replyFormAddress,
+                            }, {
+                                routeKey: "app-threads-reply-record-open",
+                                capabilityId: "recordOpen",
+                                scope: "page",
+                                channel: "action",
+                                action: "activate",
+                                valueType: "json",
+                                valueSchema: PHI_SIGNAL_VALUE_SCHEMAS.tableAction,
+                                receiver: replyFormAddress,
                             }],
                     },
                 },
             }),
-            /*
-             * What stands where the reply would be, while nothing is chosen.
-             *
-             * `whenUnavailable: "matched"` because a Page that has just opened is the ordinary case: nobody has
-             * chosen a row yet, and waiting for the Controller to say so would leave the spot empty until then.
-             */
-            nodes.widget({
-                id: PHI_APP_THREADS_PAGE_WIDGET_IDS.widgetComposerEmpty,
-                parentLayoutNodeId: PHI_BASE_PAGE_LAYOUT_NODE_ID,
-                typeKey: "simple-text",
-                slotIndex: PHI_CMS_DEFAULT_SLOT_INDEX + 3,
-                sortOrder: 3,
-                label: labels.composerLabel,
-                flags: PhiCmsFlags.NoTranslate,
-                config: {
-                    text: labels.composerNoThreadText,
-                    color: PHI_COLOR.textSecondary,
-                    visibleWhen: {
-                        source: "controller",
-                        controllerAddress,
-                        valuePath: "threadOpen",
-                        operator: "falsy",
-                        whenUnavailable: "matched",
-                    },
-                },
-            }),
+            ...replyDialog.widgets,
         ],
     };
 }

package/plugins/runtime-modules/threads/widgets.js

@@ -1,14 +1,5 @@
-import { PHI_THREADS_RUNTIME_MODULE_ID } from "./ids";
-import { PHI_THREAD_CONVERSATION_WIDGET_DEFINITION } from "./widgets/thread-conversation/config";
-function defineFirstPartyWidget(options) {
-    return options;
-}
-export const PHI_THREADS_RUNTIME_MODULE_WIDGETS = [
-    defineFirstPartyWidget({
-        definition: PHI_THREAD_CONVERSATION_WIDGET_DEFINITION,
-        ownerModuleId: PHI_THREADS_RUNTIME_MODULE_ID,
-        renderPolicies: { runtime: "custom", preview: "custom", authoring: "custom" },
-        loadRuntime: () => import("./widgets/thread-conversation/plugin").then((module) => module.PHI_THREAD_CONVERSATION_WIDGET_PLUGIN),
-        loadPreview: () => import("./widgets/thread-conversation/plugin").then((module) => module.PHI_THREAD_CONVERSATION_WIDGET_PLUGIN),
-    }),
-];
+/*
+ * None of its own. The conversation it shows is Core's Widget (`core/widgets/thread-conversation`), placed
+ * by this Module's Page as by every other Module that runs conversations.
+ */
+export const PHI_THREADS_RUNTIME_MODULE_WIDGETS = [];

package/plugins/runtime-modules/tour/authoring-widgets.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("react").ComponentType<import("../client-authoring-widget-module").PhiAuthoringWidgetModuleProps>;
+export default _default;

package/plugins/runtime-modules/tour/authoring-widgets.js

@@ -0,0 +1,4 @@
+"use client";
+import { createPhiAuthoringWidgetModule } from "../client-authoring-widget-module";
+// The Tour button is Core's Widget; this Module authors none of its own.
+export default createPhiAuthoringWidgetModule([]);

package/plugins/runtime-modules/tour/authoring.d.ts

@@ -0,0 +1 @@
+export declare const PhiTourRuntimeModuleAuthoringClient: import("react").ComponentType<import("../contracts").PhiRuntimeModuleAuthoringClientProps>;

package/plugins/runtime-modules/tour/authoring.js

@@ -0,0 +1,8 @@
+"use client";
+import WidgetModule from "./authoring-widgets";
+import { createPhiRuntimeModuleAuthoringClient } from "../client-authoring-module";
+import { PHI_TOUR_RUNTIME_MODULE_ID } from "./ids";
+export const PhiTourRuntimeModuleAuthoringClient = createPhiRuntimeModuleAuthoringClient({
+    moduleId: PHI_TOUR_RUNTIME_MODULE_ID,
+    WidgetModule,
+});

package/plugins/runtime-modules/tour/client.d.ts

@@ -0,0 +1 @@
+export declare const PhiLazyTourRuntimeControllerClient: import("react").ComponentType<import("../contracts").PhiRuntimeModuleControllerClientProps>;

package/plugins/runtime-modules/{admin → tour}/client.js

@@ -4,4 +4,4 @@ import dynamic from "next/dynamic";
  * next/dynamic rather than a loader: rendered during the server render, it names its chunks in the
  * route's loadable manifest, and the HTML asks for them before hydration instead of after it.
  */
-export const PhiLazyAdminRuntimeControllerClient = dynamic(() => import("../../../plugins/runtime-modules/admin/controller/client").then((module) => module.PhiAdminRuntimeControllerClient));
+export const PhiLazyTourRuntimeControllerClient = dynamic(() => import("./controller/client").then((module) => module.PhiTourRuntimeControllerClient));

package/plugins/runtime-modules/tour/controller/address.d.ts

@@ -0,0 +1 @@
+export declare const PHI_TOUR_CONTROLLER_TYPE: "@phis/ui/modules/tour/controller/default";

package/plugins/runtime-modules/tour/controller/address.js

@@ -0,0 +1,3 @@
+import { PHI_TOUR_CONTROLLER_KEY, PHI_TOUR_CONTROLLER_PLUGIN_KEY } from "../../../../types/tours";
+// The Controller's address is the foundation's (`types/tours.ts`): the Tour button, which is Core's, asks it.
+export const PHI_TOUR_CONTROLLER_TYPE = `${PHI_TOUR_CONTROLLER_PLUGIN_KEY}/${PHI_TOUR_CONTROLLER_KEY}`;

package/plugins/runtime-modules/tour/controller/client.d.ts

@@ -0,0 +1,39 @@
+import type { PhiResolvedPageTour } from "../../../../types/tours";
+import { type PhiTourControllerConfig } from "./definition";
+export declare const PHI_TOUR_RUNTIME_CONTROLLER_PLUGIN: {
+    renderController: ({ key, address, config }: import("../../../../types").PhiRuntimeControllerRenderArgs<PhiTourControllerConfig, unknown>) => import("react").JSX.Element;
+    kind: "controller";
+    pluginKey: string;
+    key: string;
+    title: string;
+    description: string;
+    iconFamily: string;
+    flags: "pageTour"[];
+    allowedMountScopes: "area"[];
+    runtimeSignals: {
+        emits: {
+            id: string;
+            action: "change";
+            valueType: "json";
+            valueSchema: `${string}/signals/${string}`;
+        }[];
+        listens: ({
+            id: string;
+            channel: string;
+            action: "open";
+            valueType: "none";
+        } | {
+            id: string;
+            channel: string;
+            action: "reload";
+            valueType: "none";
+        })[];
+    };
+    defaultConfig: {
+        pageTour: null;
+    };
+    parseConfig: (raw: Record<string, unknown>) => {
+        pageTour: PhiResolvedPageTour | null;
+    };
+};
+export declare const PhiTourRuntimeControllerClient: (props: import("../../contracts").PhiRuntimeModuleControllerClientProps) => import("react").JSX.Element;