@phis/ui 0.1.0 → 0.2.0

package/types/signals.d.ts

@@ -2,8 +2,8 @@ import type { PhiRenderableBlockSize, PhiRenderableBlockVisibility } from "./ren
 import type { PhiCmsGridLayoutSlotPlacementConfig } from "./cms-config";
 import { type PhiCmsInstanceId } from "./cms-instance-id";
 export { PHI_SHARED_PACKAGE_NAME } from "../constants/package";
-export { PHI_SIGNAL_ACTIONS, PHI_SIGNAL_SCOPES, PHI_SIGNAL_VALUE_SCHEMA_NAMESPACE, PHI_SIGNAL_VALUE_SCHEMA_SEPARATOR, PHI_SIGNAL_VALUE_TYPES, isPhiSignalAction, isPhiSignalScope, isPhiSignalValueType, type PhiSignalAction, type PhiSignalScope, type PhiSignalValueSchema, type PhiSignalValueType, } from "@phis/contracts/signals";
-export { isPhiControllerSignalAddress, isPhiSignalAddress, isPhiSignalReceiver, readPhiSignalAddress, type PhiControllerSignalAddress, type PhiSignalAddress, type PhiSignalAddressFamily, type PhiSignalReceiver, type PhiSignalSender, } from "@phis/contracts/signals";
+export { PHI_SIGNAL_ACTIONS, PHI_SIGNAL_SCOPES, PHI_SIGNAL_VALUE_SCHEMA_NAMESPACE, PHI_SIGNAL_VALUE_SCHEMA_SEPARATOR, PHI_SIGNAL_VALUE_TYPES, isPhiSignalAction, isPhiSignalScope, isPhiSignalValueSchemaShape, isPhiSignalValueType, type PhiSignalAction, type PhiSignalScope, type PhiSignalValueSchema, type PhiSignalValueType, } from "@phis/contracts/signals";
+export { isPhiControllerSignalAddress, isPhiSignalAddress, isPhiSignalReceiver, readPhiControllerSignalAddress, readPhiSignalAddress, type PhiControllerSignalAddress, type PhiSignalAddress, type PhiSignalAddressFamily, type PhiSignalReceiver, type PhiSignalSender, } from "@phis/contracts/signals";
 import { type PhiControllerSignalAddress, type PhiSignalAddress, type PhiSignalAddressFamily, type PhiSignalReceiver, type PhiSignalSender } from "@phis/contracts/signals";
 import { type PhiSignalAction, type PhiSignalScope, type PhiSignalValueSchema, type PhiSignalValueType } from "@phis/contracts/signals";
 export type PhiSignalRuntimeContext = {
@@ -13,7 +13,6 @@ export type PhiSignalRuntimeContext = {
     regionKey?: string | null;
     slotKey?: string | null;
 };
-export declare const PHI_SIGNAL_CHANNELS: readonly ["text", "path", "select", "toggle", "number", "color", "command", "visibility", "enabled", "background", "border", "selection", "stack", "layout", "content", "style", "meta", "drag", "drop", "flush", "inspector"];
 export type PhiSignalChannel = string;
 export declare function createPhiSignalValueSchema(packageName: string, schemaKey: string): PhiSignalValueSchema;
 export declare function createPhiSharedSignalValueSchema(schemaKey: string): PhiSignalValueSchema;
@@ -49,6 +48,7 @@ export declare const PHI_SIGNAL_VALUE_SCHEMAS: {
     readonly runtimeConditionState: `${string}/signals/${string}`;
     readonly runtimeNavigation: `${string}/signals/${string}`;
     readonly runtimeTheme: `${string}/signals/${string}`;
+    readonly authWorkflowState: `${string}/signals/${string}`;
     readonly stackMeta: `${string}/signals/${string}`;
     readonly tableAction: `${string}/signals/${string}`;
     readonly tableBindingParams: `${string}/signals/${string}`;
@@ -59,6 +59,7 @@ export declare const PHI_SIGNAL_VALUE_SCHEMAS: {
     readonly tableSelection: `${string}/signals/${string}`;
     readonly tableState: `${string}/signals/${string}`;
     readonly tableMutation: `${string}/signals/${string}`;
+    readonly threadSelection: `${string}/signals/${string}`;
     readonly treeAction: `${string}/signals/${string}`;
     readonly treeBindingParams: `${string}/signals/${string}`;
     readonly treeState: `${string}/signals/${string}`;
@@ -74,7 +75,6 @@ export type PhiSignalMeta = {
 export declare function createPhiSignalAddress(family: PhiSignalAddressFamily, instanceIdOrKey: string | number): PhiSignalAddress;
 export declare function createPhiSignalSubcontrolAddress(family: "cms", instanceIdOrKey: PhiCmsInstanceId, controlKey: string | number): PhiSignalAddress;
 export declare function createPhiControllerSignalAddress(pluginKey: string | number, controllerKey: string | number, instanceKey: string | number): PhiControllerSignalAddress;
-export declare function readPhiControllerSignalAddress(value: unknown): PhiControllerSignalAddress | undefined;
 export declare function readPhiControllerSignalAddressParts(value: unknown): {
     pluginKey: string;
     controllerKey: string;
@@ -102,11 +102,29 @@ export type PhiSignalFilter = {
     actions?: readonly PhiSignalAction[];
     valueSchemas?: readonly PhiSignalValueSchema[];
 };
+/**
+ * Where a sender's `json` schema comes from, when the Widget itself cannot know it.
+ *
+ * A Widget bound to a data provider shows whatever the bound resource holds, so what a selection *is* is
+ * the resource's answer and not the Widget's. Naming a schema in the capability freezes one provider's
+ * vocabulary into a generic Widget -- which is how `collection-view` came to announce every selection as
+ * a media asset, whichever provider was bound, and why a package from another repository could bind its
+ * own collection but not its own meaning.
+ *
+ * `data-source` defers the answer to the bound resource's descriptor. The Builder resolves it before the
+ * capability is offered for wiring, so the route that gets written carries a concrete schema and the
+ * runtime emits it like any other. Core never has to spell the name out.
+ *
+ * Only a sender may defer. A receiver has to know what it listens for before anything arrives, and it has
+ * no source to ask.
+ */
+export type PhiSignalValueSchemaOrigin = "data-source";
 export type PhiSignalOutputCapability = {
     id: string;
     action: PhiSignalAction;
     valueType: PhiSignalValueType;
     valueSchema?: PhiSignalValueSchema | null;
+    valueSchemaFrom?: PhiSignalValueSchemaOrigin | null;
     enumValues?: string[] | null;
     required?: boolean;
     target?: PhiSignalCapabilityTarget | null;
@@ -124,6 +142,20 @@ export type PhiSignalRoute = {
     valueType: PhiSignalValueType;
     valueSchema?: PhiSignalValueSchema | null;
     receiver: PhiSignalReceiver;
+    /**
+     * Which Form field this route writes, for a route that carries a `form-field` value and only for one.
+     *
+     * A `form-field` payload is `{ fieldKey, value }`, and the field name is an addressing fact about this
+     * wire, not something the sender knows: the sender holds a value -- a chosen conversation, a dragged
+     * rectangle -- and a Site decides which Form field it lands in. Written into the sender's code, as the
+     * focal rectangle had it, the same Widget can never feed a second Form, and a Site that renames the
+     * field has to change a package to follow. So the route names it and the emitting side reads it from
+     * there, which is what every other fact on this object already is.
+     *
+     * Required wherever `valueSchema` is `form-field`, and refused everywhere else: a field name on a route
+     * that carries something else would be read by nobody, which is worse than absent.
+     */
+    fieldKey?: string | null;
 };
 export type PhiSignalRouteSet = {
     emits?: PhiSignalRoute[] | null;
@@ -131,6 +163,13 @@ export type PhiSignalRouteSet = {
 };
 export type PhiSignalDragDropPayloadType = string;
 export type PhiSignalDropMode = "before" | "after" | "child" | "replace" | "append" | "swap";
+/** Where a Table row or Tree node takes a drop: every signal drop mode but a swap. */
+export type PhiProviderDropMode = Exclude<PhiSignalDropMode, "swap">;
+/** What a Table or Tree provider resource declares it accepts as a drop. */
+export type PhiProviderDropTargetCapability = {
+    payloadType: `${string}/${string}`;
+    modes?: readonly PhiProviderDropMode[];
+};
 export type PhiSignalDragSourceMeta = {
     key: string;
     types: PhiSignalDragDropPayloadType[];
@@ -154,6 +193,7 @@ export type PhiSignalPluginMeta = {
     dragDrop?: PhiSignalDragDropPluginMeta | null;
 };
 export declare function assertPhiSignalPluginMetaContract(runtimeSignals: PhiSignalPluginMeta | null | undefined, context?: string): void;
+export declare function isPhiSignalValueSchemaOrigin(value: unknown): value is PhiSignalValueSchemaOrigin;
 export declare function isPhiSignalCapabilityTarget(value: unknown): value is PhiSignalCapabilityTarget;
 export declare function isPhiSignalChannel(value: unknown): value is PhiSignalChannel;
 /**
@@ -164,7 +204,15 @@ export declare function isPhiSignalChannel(value: unknown): value is PhiSignalCh
 export declare function isPhiSignalValueSchema(value: unknown): value is PhiSignalValueSchema;
 export declare function readPhiSignalValueSchema(value: unknown): PhiSignalValueSchema | null;
 export declare function readPhiSignalRouteSet(value: unknown): PhiSignalRouteSet | null;
-export declare function findPhiSignalRouteByKey(routes: readonly PhiSignalRoute[] | null | undefined, routeKey: string): PhiSignalRoute | null;
+/**
+ * What this route actually carries, once the route has had its say about the payload.
+ *
+ * A sender holds a value and nothing more. Where the route names a Form field, the value is wrapped into
+ * the `form-field` shape the Core Form controller reads (`{ fieldKey, value }`), so the same Widget can
+ * feed a different field on the next page without a line of its code changing. Every emitter goes through
+ * here, because a second place that wraps would be a second answer to the same question.
+ */
+export declare function resolvePhiSignalRouteValue(route: PhiSignalRoute, value: PhiSignalValue): PhiSignalValue;
 export declare function findPhiSignalRoutesByCapabilityId(routes: readonly PhiSignalRoute[] | null | undefined, capabilityId: string): PhiSignalRoute[];
 export declare function createPhiSignalRouteKey(): string;
 export type PhiRenderableBlockSignalPayload = PhiRenderableBlockVisibility | boolean | string | number | PhiRenderableBlockSize | PhiCmsGridLayoutSlotPlacementConfig[] | Record<string, unknown> | null;

package/types/signals.js

@@ -8,7 +8,7 @@ export { PHI_SHARED_PACKAGE_NAME } from "../constants/package";
  * this side had `date`, `time` and `length`, the server had not, and a length control's change signal
  * was refused on save.
  */
-export { PHI_SIGNAL_ACTIONS, PHI_SIGNAL_SCOPES, PHI_SIGNAL_VALUE_SCHEMA_NAMESPACE, PHI_SIGNAL_VALUE_SCHEMA_SEPARATOR, PHI_SIGNAL_VALUE_TYPES, isPhiSignalAction, isPhiSignalScope, isPhiSignalValueType, } from "@phis/contracts/signals";
+export { PHI_SIGNAL_ACTIONS, PHI_SIGNAL_SCOPES, PHI_SIGNAL_VALUE_SCHEMA_NAMESPACE, PHI_SIGNAL_VALUE_SCHEMA_SEPARATOR, PHI_SIGNAL_VALUE_TYPES, isPhiSignalAction, isPhiSignalScope, isPhiSignalValueSchemaShape, isPhiSignalValueType, } from "@phis/contracts/signals";
 /*
  * The address families come from there too, and for a sharper reason.
  *
@@ -17,32 +17,10 @@ export { PHI_SIGNAL_ACTIONS, PHI_SIGNAL_SCOPES, PHI_SIGNAL_VALUE_SCHEMA_NAMESPAC
  * server's said in its own comment that it "mirrors the grammar in @phis/ui", because it could not
  * import it.
  */
-export { isPhiControllerSignalAddress, isPhiSignalAddress, isPhiSignalReceiver, readPhiSignalAddress, } from "@phis/contracts/signals";
-import { isPhiControllerPluginKey, isPhiControllerSignalAddress, isPhiSignalAddressSegment, isPhiSignalReceiver, } from "@phis/contracts/signals";
+export { isPhiControllerSignalAddress, isPhiSignalAddress, isPhiSignalReceiver, readPhiControllerSignalAddress, readPhiSignalAddress, } from "@phis/contracts/signals";
+import { isPhiControllerPluginKey, isPhiSignalAddressSegment, isPhiSignalReceiver, readPhiControllerSignalAddress, } from "@phis/contracts/signals";
 import { PHI_SIGNAL_VALUE_SCHEMA_NAMESPACE, PHI_SIGNAL_VALUE_SCHEMA_SEPARATOR, isPhiSignalAction, isPhiSignalScope, isPhiSignalValueType, } from "@phis/contracts/signals";
-export const PHI_SIGNAL_CHANNELS = [
-    "text",
-    "path",
-    "select",
-    "toggle",
-    "number",
-    "color",
-    "command",
-    "visibility",
-    "enabled",
-    "background",
-    "border",
-    "selection",
-    "stack",
-    "layout",
-    "content",
-    "style",
-    "meta",
-    "drag",
-    "drop",
-    "flush",
-    "inspector",
-];
+import { isPhiRecord } from "../helpers/is-record";
 export function createPhiSignalValueSchema(packageName, schemaKey) {
     const normalizedPackageName = packageName.trim();
     const normalizedSchemaKey = schemaKey.trim();
@@ -87,6 +65,7 @@ export const PHI_SIGNAL_VALUE_SCHEMAS = {
     runtimeConditionState: createPhiSharedSignalValueSchema("runtime-condition-state"),
     runtimeNavigation: createPhiSharedSignalValueSchema("runtime-navigation"),
     runtimeTheme: createPhiSharedSignalValueSchema("runtime-theme"),
+    authWorkflowState: createPhiSharedSignalValueSchema("auth-workflow-state"),
     stackMeta: createPhiSharedSignalValueSchema("stack-meta"),
     tableAction: createPhiSharedSignalValueSchema("table-action"),
     tableBindingParams: createPhiSharedSignalValueSchema("table-binding-params"),
@@ -97,6 +76,7 @@ export const PHI_SIGNAL_VALUE_SCHEMAS = {
     tableSelection: createPhiSharedSignalValueSchema("table-selection"),
     tableState: createPhiSharedSignalValueSchema("table-state"),
     tableMutation: createPhiSharedSignalValueSchema("table-mutation"),
+    threadSelection: createPhiSharedSignalValueSchema("thread-selection"),
     treeAction: createPhiSharedSignalValueSchema("tree-action"),
     treeBindingParams: createPhiSharedSignalValueSchema("tree-binding-params"),
     treeState: createPhiSharedSignalValueSchema("tree-state"),
@@ -135,9 +115,6 @@ export function createPhiControllerSignalAddress(pluginKey, controllerKey, insta
     }
     return `controller:${plugin}/${controller}:${instance}`;
 }
-export function readPhiControllerSignalAddress(value) {
-    return isPhiControllerSignalAddress(value) ? value.trim() : undefined;
-}
 export function readPhiControllerSignalAddressParts(value) {
     const address = readPhiControllerSignalAddress(value);
     if (!address) {
@@ -171,8 +148,18 @@ export function assertPhiSignalPluginMetaContract(runtimeSignals, context = "run
         if (!isPhiSignalValueType(capability.valueType)) {
             throw new Error(`${context}: sender output "${capability.id}" declares an invalid valueType.`);
         }
-        if (capability.valueType === "json" && !isPhiSignalValueSchema(capability.valueSchema)) {
-            throw new Error(`${context}: sender output "${capability.id}" with valueType "json" must declare valueSchema.`);
+        if (capability.valueSchemaFrom != null && !isPhiSignalValueSchemaOrigin(capability.valueSchemaFrom)) {
+            throw new Error(`${context}: sender output "${capability.id}" declares an invalid valueSchemaFrom.`);
+        }
+        if (capability.valueSchemaFrom != null && capability.valueType !== "json") {
+            throw new Error(`${context}: sender output "${capability.id}" may only defer a valueSchema with valueType "json".`);
+        }
+        if (capability.valueSchemaFrom != null && capability.valueSchema != null) {
+            throw new Error(`${context}: sender output "${capability.id}" declares a valueSchema and where to read one.`);
+        }
+        if (capability.valueType === "json" && capability.valueSchemaFrom == null &&
+            !isPhiSignalValueSchema(capability.valueSchema)) {
+            throw new Error(`${context}: sender output "${capability.id}" with valueType "json" must declare valueSchema or valueSchemaFrom.`);
         }
         if (capability.target != null && !isPhiSignalCapabilityTarget(capability.target)) {
             throw new Error(`${context}: sender output "${capability.id}" declares an invalid target.`);
@@ -189,6 +176,9 @@ export function assertPhiSignalPluginMetaContract(runtimeSignals, context = "run
         if (!isPhiSignalValueType(capability.valueType)) {
             throw new Error(`${context}: receiver input "${capability.id}" declares an invalid valueType.`);
         }
+        if (capability.valueSchemaFrom != null) {
+            throw new Error(`${context}: receiver input "${capability.id}" must not defer its valueSchema -- a receiver has no data source to read one from.`);
+        }
         if (capability.valueType === "json" && !isPhiSignalValueSchema(capability.valueSchema)) {
             throw new Error(`${context}: receiver input "${capability.id}" with valueType "json" must declare valueSchema.`);
         }
@@ -207,6 +197,9 @@ export function assertPhiSignalPluginMetaContract(runtimeSignals, context = "run
         receiverInputKeys.add(key);
     }
 }
+export function isPhiSignalValueSchemaOrigin(value) {
+    return value === "data-source";
+}
 export function isPhiSignalCapabilityTarget(value) {
     return value === "self" || value === "subcontrol" || value === "both";
 }
@@ -225,11 +218,8 @@ export function isPhiSignalValueSchema(value) {
 export function readPhiSignalValueSchema(value) {
     return isPhiSignalValueSchema(value) ? value.trim() : null;
 }
-function isRecord(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
 function readPhiSignalRoute(value) {
-    if (!isRecord(value)) {
+    if (!isPhiRecord(value)) {
         return null;
     }
     const routeKey = typeof value.routeKey === "string" && value.routeKey.trim() ? value.routeKey.trim() : null;
@@ -253,6 +243,18 @@ function readPhiSignalRoute(value) {
     if (!isPhiSignalReceiver(value.receiver)) {
         return null;
     }
+    /*
+     * The field a `form-field` route writes, and nothing else may carry one.
+     *
+     * A route that promises a `form-field` value without naming a field cannot be delivered -- the Form
+     * would be told to write a field called `undefined` -- so it is refused here rather than dropped
+     * quietly, which is how every other incomplete route is treated in this parser.
+     */
+    const fieldKey = typeof value.fieldKey === "string" && value.fieldKey.trim() ? value.fieldKey.trim() : null;
+    const wantsFieldKey = valueSchema === PHI_SIGNAL_VALUE_SCHEMAS.formField;
+    if (wantsFieldKey ? !fieldKey : fieldKey != null) {
+        return null;
+    }
     return {
         routeKey,
         capabilityId,
@@ -262,6 +264,7 @@ function readPhiSignalRoute(value) {
         valueType,
         valueSchema,
         receiver: value.receiver,
+        ...(fieldKey ? { fieldKey } : {}),
     };
 }
 function readPhiSignalRouteList(value) {
@@ -275,7 +278,7 @@ function readPhiSignalRouteList(value) {
     return routes.length > 0 ? routes : null;
 }
 export function readPhiSignalRouteSet(value) {
-    if (!isRecord(value)) {
+    if (!isPhiRecord(value)) {
         return null;
     }
     const emits = readPhiSignalRouteList(value.emits);
@@ -290,8 +293,19 @@ export function readPhiSignalRouteSet(value) {
     }
     return emits || listens ? { emits, listens } : null;
 }
-export function findPhiSignalRouteByKey(routes, routeKey) {
-    return routes?.find((route) => route.routeKey === routeKey) ?? null;
+/**
+ * What this route actually carries, once the route has had its say about the payload.
+ *
+ * A sender holds a value and nothing more. Where the route names a Form field, the value is wrapped into
+ * the `form-field` shape the Core Form controller reads (`{ fieldKey, value }`), so the same Widget can
+ * feed a different field on the next page without a line of its code changing. Every emitter goes through
+ * here, because a second place that wraps would be a second answer to the same question.
+ */
+export function resolvePhiSignalRouteValue(route, value) {
+    if (route.valueType === "none") {
+        return null;
+    }
+    return route.fieldKey ? { fieldKey: route.fieldKey, value } : value;
 }
 export function findPhiSignalRoutesByCapabilityId(routes, capabilityId) {
     return routes?.filter((route) => route.capabilityId === capabilityId) ?? [];

package/types/site-config.d.ts

@@ -0,0 +1,83 @@
+import type { PhiShellTheme } from "../components/shell/shell-types";
+import type { PhiSiteFontSlots, PhiSiteRemSettings, PhiSiteThemeBrand, PhiSiteThemeContact, PhiSiteThemeRoot } from "./site-theme";
+import type { PhiThemePalette } from "../theme/phi-theme-presets";
+import type { PhiThemeBlockSelection } from "../theme/phi-theme-composition";
+import type { PhiControlShapeCorners } from "../theme/phi-control-shape";
+import type { PhiThemeButtons } from "../theme/phi-button-shadow";
+import type { PhiThemeTypography } from "../theme/phi-theme-typography";
+export type PhiSiteTheme = {
+    mode?: "light" | "dark" | null;
+    /**
+     * Which Theme blocks this Site follows (theme/phi-theme-blocks.ts). Absent on a Theme written before
+     * a Theme had three parts, where `preset` alone named the palette and still does.
+     */
+    blocks?: PhiThemeBlockSelection | null;
+    preset?: string | null;
+    presetVersion?: number | null;
+    shape?: {
+        controls?: PhiControlShapeCorners | null;
+    } | null;
+    fonts?: PhiSiteFontSlots;
+    contact?: PhiSiteThemeContact | null;
+    brand?: PhiSiteThemeBrand | null;
+    widgets?: {
+        locale?: {
+            mode?: "label-list" | "compact-pill" | null;
+            showText?: boolean | null;
+        } | null;
+        account?: {
+            variant?: "full" | "compact" | "icon-only" | null;
+            showLabel?: boolean | null;
+            showChevron?: boolean | null;
+        } | null;
+    } | null;
+    shell?: PhiShellTheme;
+    root?: PhiSiteThemeRoot | null;
+    rem?: PhiSiteRemSettings | null;
+    /**
+     * The colour the Site owns: a palette in the shape a Module ships one (theme/phi-theme-presets.ts),
+     * laid over the palette block the Site follows. Seeds shared by both modes under `seed`; the base
+     * seeds, explicit colour tokens and custom colours per mode under `modes`. Absent while the Site only
+     * follows a core palette; filled when a Module palette is taken over on save or an author changes a
+     * colour.
+     */
+    palette?: PhiThemePalette | null;
+    /** The proportions the Site owns, laid over the style block it follows. */
+    style?: {
+        token?: Record<string, unknown>;
+    } | null;
+    /** The shadow under each kind of Button, as a step the root theme turns into CSS per mode. */
+    buttons?: PhiThemeButtons | null;
+    /** Which font slot the page's headings take; body unless stated (theme/phi-theme-typography.ts). */
+    typography?: PhiThemeTypography | null;
+    /** Site-level component overrides, merged per component over the shared component defaults. */
+    components?: Record<string, Record<string, unknown>> | null;
+};
+export type PhiSiteLocaleOption = {
+    code: string;
+    label: string;
+};
+export type PhiSiteConfig = {
+    id: number;
+    key: string;
+    publicUrl: string;
+    name: string;
+    hostname: string;
+    defaultLocale: string;
+    availableLocales: PhiSiteLocaleOption[];
+    store?: {
+        enabled: boolean;
+    };
+    theme: PhiSiteTheme;
+    themeRevision: {
+        publishedRevisionId: number | null;
+        workingDraftRevisionId: number | null;
+    };
+    /** Change markers of the global and this Site's translation store; opaque, compared for equality. */
+    translationMarkers: {
+        global: string;
+        site: string;
+    };
+    /** Moves with every published change a Site's read caches hold; opaque, compared for equality. */
+    readMarker: string;
+};

package/types/site-config.js

@@ -0,0 +1 @@
+export {};

package/types/site-request-context.d.ts

@@ -0,0 +1,167 @@
+import type { PhiCapabilitySnapshot } from "./server-capabilities";
+import type { PhiSiteFontSlots, PhiSiteRemSettings } from "./site-theme";
+import type { PhiBlockRuntime, PhiWidgetThemeMode } from "./widget-runtime";
+export type PhiSiteRequestContext = {
+    serverCapabilities: PhiCapabilitySnapshot;
+    site: {
+        id: number;
+        key: string;
+        publicUrl?: string;
+        name: string;
+        hostname: string;
+        availableLocales: Array<{
+            code: string;
+            label: string;
+        }>;
+        defaultLocale: string;
+        themeRevision: {
+            publishedRevisionId: number | null;
+            workingDraftRevisionId: number | null;
+        };
+        theme: {
+            mode: PhiWidgetThemeMode;
+            fonts?: PhiSiteFontSlots | null;
+            rem?: PhiSiteRemSettings | null;
+            brand?: {
+                slogan?: {
+                    label?: string | null;
+                    icon?: string | null;
+                } | null;
+                location?: {
+                    label?: string | null;
+                    icon?: string | null;
+                } | null;
+                wordmark?: {
+                    parts?: Array<{
+                        text: string;
+                        color?: string | null;
+                        fontWeight?: number | string | null;
+                    }> | null;
+                } | null;
+            };
+            contact?: {
+                label?: string | null;
+                href?: string | null;
+                icon?: string | null;
+            };
+            shell?: {
+                light?: {
+                    background?: string | null;
+                    color?: string | null;
+                } | null;
+                dark?: {
+                    background?: string | null;
+                    color?: string | null;
+                } | null;
+                header?: {
+                    light?: {
+                        background?: string | null;
+                        color?: string | null;
+                    } | null;
+                    dark?: {
+                        background?: string | null;
+                        color?: string | null;
+                    } | null;
+                    top?: {
+                        light?: {
+                            background?: string | null;
+                            color?: string | null;
+                        } | null;
+                        dark?: {
+                            background?: string | null;
+                            color?: string | null;
+                        } | null;
+                    } | null;
+                    main?: {
+                        light?: {
+                            background?: string | null;
+                            color?: string | null;
+                        } | null;
+                        dark?: {
+                            background?: string | null;
+                            color?: string | null;
+                        } | null;
+                    } | null;
+                    bottom?: {
+                        light?: {
+                            background?: string | null;
+                            color?: string | null;
+                        } | null;
+                        dark?: {
+                            background?: string | null;
+                            color?: string | null;
+                        } | null;
+                    } | null;
+                } | null;
+                sider?: {
+                    light?: {
+                        background?: string | null;
+                        color?: string | null;
+                    } | null;
+                    dark?: {
+                        background?: string | null;
+                        color?: string | null;
+                    } | null;
+                    left?: {
+                        light?: {
+                            background?: string | null;
+                            color?: string | null;
+                        } | null;
+                        dark?: {
+                            background?: string | null;
+                            color?: string | null;
+                        } | null;
+                        sticky?: boolean | null;
+                        width?: number | null;
+                    } | null;
+                    right?: {
+                        light?: {
+                            background?: string | null;
+                            color?: string | null;
+                        } | null;
+                        dark?: {
+                            background?: string | null;
+                            color?: string | null;
+                        } | null;
+                        sticky?: boolean | null;
+                        width?: number | null;
+                    } | null;
+                } | null;
+                footer?: {
+                    light?: {
+                        background?: string | null;
+                        color?: string | null;
+                    } | null;
+                    dark?: {
+                        background?: string | null;
+                        color?: string | null;
+                    } | null;
+                    main?: {
+                        light?: {
+                            background?: string | null;
+                            color?: string | null;
+                        } | null;
+                        dark?: {
+                            background?: string | null;
+                            color?: string | null;
+                        } | null;
+                    } | null;
+                    bottom?: {
+                        light?: {
+                            background?: string | null;
+                            color?: string | null;
+                        } | null;
+                        dark?: {
+                            background?: string | null;
+                            color?: string | null;
+                        } | null;
+                    } | null;
+                } | null;
+            };
+        };
+    };
+    locale: {
+        current: string;
+    };
+    viewer: PhiBlockRuntime["viewer"];
+};

package/types/site-request-context.js

@@ -0,0 +1 @@
+export {};

package/types/site-theme.d.ts

@@ -66,6 +66,15 @@ export type PhiSiteThemeWordmark = {
     /** Slanting, which is its own axis: a name is regularly both bold and italic. */
     fontStyle?: "normal" | "italic" | null;
     letterSpacing?: string | null;
+    /**
+     * Whether the name is drawn at all, said outright the way a Logo says it has none.
+     *
+     * Writing no parts cannot mean it: an empty Wordmark falls back to the Site's own name, which is
+     * what a Site that has not got around to setting one should show. A brand whose Logo already
+     * contains its name needs the opposite -- nothing beside the picture -- and that is a decision,
+     * not an omission. Absent means the name is drawn, so every Site that never stated it is unchanged.
+     */
+    shows?: "name" | "none" | null;
     parts?: PhiSiteThemeWordmarkPart[] | null;
 };
 /**
@@ -115,6 +124,14 @@ export type PhiSiteThemeBrand = {
     logo?: PhiSiteThemeBrandLogos | null;
     /** What the Logo says to somebody who cannot see it. Falls back to the asset's own alt text. */
     logoAlt?: string | null;
+    /**
+     * How far the Logo is nudged against the Wordmark, in pixels, to correct its own artwork.
+     *
+     * A picture rarely sits on the baseline its file claims; what it needs is one correction, true of the
+     * Logo itself and therefore stated once here. It applied per Widget instance until now, which meant
+     * the same artwork was aligned by hand in the header and again in the footer.
+     */
+    logoYOffset?: number | null;
     slogan?: PhiSiteThemeBrandLine | null;
     location?: PhiSiteThemeBrandLine | null;
     wordmark?: PhiSiteThemeWordmark | null;

package/types/spacing.d.ts

@@ -1,3 +1 @@
-export declare const PHI_SPACING_TOKENS: readonly ["none", "xxs", "xs", "sm", "base", "md", "lg", "xl", "xxl"];
-export type PhiSpacingToken = (typeof PHI_SPACING_TOKENS)[number];
-export declare function isPhiSpacingToken(value: unknown): value is PhiSpacingToken;
+export { PHI_SPACING_TOKENS, isPhiSpacingToken, type PhiSpacingToken, } from "@phis/contracts/layout";

package/types/spacing.js

@@ -1,14 +1,5 @@
-export const PHI_SPACING_TOKENS = [
-    "none",
-    "xxs",
-    "xs",
-    "sm",
-    "base",
-    "md",
-    "lg",
-    "xl",
-    "xxl",
-];
-export function isPhiSpacingToken(value) {
-    return typeof value === "string" && PHI_SPACING_TOKENS.includes(value);
-}
+/*
+ * The spacing steps are named in stored descriptors, so the list lives in `@phis/contracts/layout` and
+ * a token the server accepts is one this side can draw.
+ */
+export { PHI_SPACING_TOKENS, isPhiSpacingToken, } from "@phis/contracts/layout";