@phis/ui 0.1.0 → 0.2.0

package/types/draft-status.js

@@ -0,0 +1,20 @@
+function isPhiDraftStatus(value) {
+    return value === "unsaved" || value === "draft" || value === "published" || value === "error";
+}
+export function readPhiDraftStatusSignalValue(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    if (!isPhiDraftStatus(record.status)) {
+        return null;
+    }
+    return {
+        status: record.status,
+        revisionId: typeof record.revisionId === "number" && Number.isInteger(record.revisionId)
+            ? record.revisionId
+            : null,
+        subject: typeof record.subject === "string" ? record.subject : null,
+        error: typeof record.error === "string" ? record.error : null,
+    };
+}

package/types/form-descriptor.d.ts

@@ -1,146 +1,8 @@
 import type { PhiCmsConfigField } from "./cms-plugins";
 import type { PhiRuntimeModuleId } from "./cms-plugins";
-import type { PhiControlOption } from "../components/controls/phi-control-options";
-import type { PhiControlOptionsProviderConfig } from "../components/controls/phi-control-options";
-import type { PhiResponsiveValue } from "./responsive";
-import type { PhiRuntimeConditionExpression } from "./runtime-condition";
-import type { PhiSpacingToken } from "./spacing";
+import type { PhiFormProviderKey } from "@phis/contracts/forms";
 import type { PhiFormSubmitCategory, PhiFormSubmitMethod, PhiFormSubmitTransport } from "../gateway/form-submit";
-export type PhiFormProviderKey = `${string}/${string}`;
-export type PhiFormLabelSetKey = `${string}/${string}`;
-export declare const PHI_FORM_DESCRIPTOR_SCHEMA_VERSION: 1;
-/**
- * Where a piece of a form's wording comes from.
- *
- * `literal` is the word itself. `label` is a key into the form's label set, which is how anything a
- * visitor reads gets translated. `config` is a value the Widget was placed with -- the target of a
- * consent link, say, which is a property of where the form stands rather than of the form: the same
- * registration form points at one site's terms in one Area and another's elsewhere, and only the
- * placement knows which, and in which language's path.
- */
-export type PhiFormTextDescriptor = {
-    kind: "literal";
-    value: string;
-} | {
-    kind: "label";
-    key: string;
-    fallback: string;
-} | {
-    kind: "config";
-    key: string;
-    fallback: string;
-};
-/** The number of tracks every form grid is divided into. */
-export declare const PHI_FORM_GRID_TRACKS: 24;
-/**
- * Where one element lies on the form grid, written the way CSS Grid writes it: `start` is the line the
- * element begins at and `end` is the line it stops before, both counted from 1, so the last line is 25.
- *
- * A range rather than a width, because a width can only say how much room something takes and never
- * where the room is. A label at 1-7 with an input at 7-19 leaves 19-25 empty, and a tool button can
- * then say 21-25 and stand in that gap on the same row -- neither of which a span can express. Ranges
- * also carry the responsive case without a second concept: a label at 1-25 above an input at 1-25 is
- * the stacked form, because two elements that both claim the whole width cannot share a row.
- */
-export type PhiFormGridRange = {
-    /** First line the element occupies, 1 to 24. */
-    start: number;
-    /** Line the element stops before, 2 to 25. Exclusive, as in CSS. */
-    end: number;
-};
-export type PhiFormResponsiveGridRange = PhiResponsiveValue<PhiFormGridRange>;
-export type PhiFormLogicalAlignment = "start" | "center" | "end";
-/**
- * What a form's rows look like where a field says nothing of its own.
- *
- * There is no `columns` and no `labelPlacement` here any more: a two-column form is fields whose
- * ranges lie in 1-13 and 13-25, and a stacked form is a label whose range is the full width. One
- * mechanism decides all of it, and the responsive sets decide it per measured width.
- */
-export type PhiFormLayoutDescriptor = {
-    gap?: PhiResponsiveValue<PhiSpacingToken>;
-    labelAlign?: Exclude<PhiFormLogicalAlignment, "center">;
-    label?: PhiFormResponsiveGridRange;
-    control?: PhiFormResponsiveGridRange;
-};
-/**
- * Where this one field's parts lie, overriding the layout's defaults.
- *
- * Elements are placed in declaration order and CSS Grid does not go back to fill a gap it has passed,
- * so a field meant to stand beside the one before it is declared after it and the row fills from the
- * inline start. That is the whole ordering rule.
- */
-export type PhiFormFieldPlacementDescriptor = {
-    label?: PhiFormResponsiveGridRange;
-    control?: PhiFormResponsiveGridRange;
-};
-export type PhiFormValidationRuleDescriptor = {
-    providerKey: PhiFormProviderKey;
-    message?: PhiFormTextDescriptor;
-    config?: Record<string, unknown>;
-};
-export type PhiFormOptionDescriptor = Omit<PhiControlOption, "label" | "description"> & {
-    label: PhiFormTextDescriptor;
-    description?: PhiFormTextDescriptor;
-};
-export type PhiFormFieldDescriptor = {
-    key: string;
-    fieldProviderKey: PhiFormProviderKey;
-    label?: PhiFormTextDescriptor;
-    controlLabel?: PhiFormTextDescriptor;
-    description?: PhiFormTextDescriptor;
-    placeholder?: PhiFormTextDescriptor;
-    autoComplete?: string;
-    initialValue?: unknown;
-    options?: readonly PhiFormOptionDescriptor[];
-    optionsProvider?: PhiControlOptionsProviderConfig | null;
-    validation?: readonly PhiFormValidationRuleDescriptor[];
-    visibleWhen?: PhiRuntimeConditionExpression;
-    disabledWhen?: PhiRuntimeConditionExpression;
-    placement?: PhiFormFieldPlacementDescriptor;
-    config?: Record<string, unknown>;
-};
-/**
- * What a form shows when a submit is accepted.
- *
- * Declared rather than coded, because every form that submits to a handler has this moment and each of
- * them used to answer it in its own component: the Contact form with a toast, the Registration with an
- * alert, each with its own wording and its own idea of whether the fields stay filled in.
- *
- * Absent means the form says nothing of its own. That is the right answer wherever something else is
- * listening -- a Controller that closes an Overlay on `submitSuccess`, a page that navigates away.
- */
-export type PhiFormSuccessDescriptor = {
-    title: PhiFormTextDescriptor;
-    text?: PhiFormTextDescriptor;
-    /** Whether the fields go back to their initial values, ready for another entry. */
-    reset?: boolean;
-};
-export type PhiFormDescriptor = {
-    schemaVersion: typeof PHI_FORM_DESCRIPTOR_SCHEMA_VERSION;
-    key: string;
-    labelSetKey?: PhiFormLabelSetKey;
-    fields: readonly PhiFormFieldDescriptor[];
-    layout?: PhiFormLayoutDescriptor;
-    success?: PhiFormSuccessDescriptor;
-    /**
-     * Whether what has been typed survives leaving the page, for as long as the tab is open.
-     *
-     * For the long form somebody fills in once and would have to fill in again after following a link to
-     * read the terms. Session storage, never local: a half-finished registration on a shared machine is
-     * not something to leave behind, and it is cleared the moment the form is accepted.
-     */
-    persistDraft?: boolean;
-    /**
-     * That the server accepts this form only with a guard token: `issuedAt` and `formToken`, signed by
-     * phis-server when the form was shown and refused if it comes back too fast or too late.
-     *
-     * The browser asks for the token when the form mounts (`/api/site/forms?phase=guard`) and adds it to
-     * what it submits. It is not rendered into the page, so a page with a guarded form is the same for
-     * every visitor and can be cached.
-     */
-    guard?: boolean;
-};
+export { PHI_FORM_DEFAULT_SUBMIT_LABEL, PHI_FORM_DESCRIPTOR_SCHEMA_VERSION, PHI_FORM_GRID_TRACKS, type PhiFormDescriptor, type PhiFormFieldDescriptor, type PhiFormFieldPlacementDescriptor, type PhiFormGridRange, type PhiFormLabelSetKey, type PhiFormLayoutDescriptor, type PhiFormLogicalAlignment, type PhiFormOptionDescriptor, type PhiFormProviderKey, type PhiFormResponsiveGridRange, type PhiFormSubmitDescriptor, type PhiFormSuccessDescriptor, type PhiFormTextDescriptor, type PhiFormValidationRuleDescriptor, } from "@phis/contracts/forms";
 export type PhiFormHandlerPhase = "submit" | "confirm" | "preview";
 export type PhiFormHandlerCredentialPolicy = "none" | "site-session" | "auth-link";
 export type PhiFormFieldTypeProviderDescriptor = {

package/types/form-descriptor.js

@@ -1,3 +1,6 @@
-export const PHI_FORM_DESCRIPTOR_SCHEMA_VERSION = 1;
-/** The number of tracks every form grid is divided into. */
-export const PHI_FORM_GRID_TRACKS = 24;
+/*
+ * The descriptor itself is stored by phis-server and written by Module presets and the Form Builder, so
+ * it is `@phis/contracts/forms`. What stays here is the Module registry around it: which field types,
+ * validation rules and handlers the active Modules provide.
+ */
+export { PHI_FORM_DEFAULT_SUBMIT_LABEL, PHI_FORM_DESCRIPTOR_SCHEMA_VERSION, PHI_FORM_GRID_TRACKS, } from "@phis/contracts/forms";

package/types/markdown.d.ts

@@ -0,0 +1,6 @@
+/** A heading the Markdown renderer found, as a table of contents lists it and links to it. */
+export type PhiMarkdownTocHeading = {
+    id: string;
+    level: 1 | 2 | 3 | 4 | 5;
+    text: string;
+};

package/types/markdown.js

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

package/types/media.d.ts

@@ -1,4 +1,7 @@
 import { PhiImageAssetVariantKey, PhiMediaKind } from "../constants/media";
+import type { PhiCmsWidgetConfigBase } from "../components/widgets/config/parser-primitives";
+import type { PhiProviderResourceSource } from "./runtime-data-provider";
+import type { PhiSignalRouteSet } from "./signals";
 export type PhiMediaKindValue = (typeof PhiMediaKind)[keyof typeof PhiMediaKind];
 export type PhiImageAssetVariantKeyValue = (typeof PhiImageAssetVariantKey)[keyof typeof PhiImageAssetVariantKey];
 type PhiMediaImageSourceUrlConfig = {
@@ -218,3 +221,28 @@ export type PhiPublicMediaAssetReference = {
     /** Present for a font, and the reason a Theme can build a fallback face without opening the file. */
     font: PhiFontMetrics | null;
 };
+export type PhiCmsAreaUploadWidgetConfig = PhiCmsWidgetConfigBase & {
+    allowDelete?: boolean;
+    multiple?: boolean;
+    accept?: string;
+    folderPath?: string;
+    presentationFlags?: number;
+};
+export type PhiCmsAssetFocalRectWidgetConfig = PhiCmsWidgetConfigBase & {
+    signalRoutes?: PhiSignalRouteSet | null;
+};
+export type PhiCmsAssetInspectorWidgetConfig = PhiCmsWidgetConfigBase & {
+    section: "preview" | "technical";
+    signalRoutes?: PhiSignalRouteSet | null;
+};
+export type PhiCmsMediaPickerWidgetConfig = PhiCmsWidgetConfigBase & {
+    mediaType?: PhiMediaKindValue | null;
+    presentationFlags?: number | null;
+    pageSize?: number;
+    minColumnWidth?: number;
+    showSearchBar?: boolean;
+    showFolderFilter?: boolean;
+    showPagination?: boolean;
+    signalRoutes?: PhiSignalRouteSet | null;
+    dataSource?: PhiProviderResourceSource | null;
+};

package/types/news.d.ts

@@ -0,0 +1,33 @@
+/**
+ * One published News entry, as `GET /api/v1/news` answers it.
+ *
+ * The shape is Core's: an entry lives in `site_content` as content type `news`, and what arrives here is
+ * already resolved for one locale and already filtered by publication date and expiry. Nothing in this
+ * package stores it -- the Module that renders it owns no data
+ * ([phis-server design/NEWS.md](../../phis-server/design/NEWS.md)).
+ */
+export type PhiSiteNewsEntry = {
+    /** The entry's public identity: its slug where it has one, its numeric id otherwise. */
+    id: string;
+    slug: string;
+    /** When the entry was published, or created where it never named a date. */
+    created: string;
+    /** When it stops being answered, or `null` where it does not. */
+    outdated: string | null;
+    title: string;
+    subtitle: string;
+    content: string;
+    /** Where the entry points, as the Site wrote it: its own path or an absolute address. */
+    link: string | null;
+    tags: readonly string[];
+    /**
+     * The language the body is written in, or `null` for the Site's own.
+     *
+     * Core answers `title` and `subtitle` already translated for the asked-for language, but not the body:
+     * Markdown is translated paragraph by paragraph where it is rendered, so its structure never reaches a
+     * provider. This is what the renderer needs to translate it the right way round.
+     */
+    sourceLocale: string | null;
+    /** Whether a reader in another language may be served a translation of this entry at all. */
+    translate: boolean;
+};

package/types/news.js

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

package/types/record-widget.d.ts

@@ -0,0 +1,49 @@
+import type { PhiSignalRouteSet } from "./signals";
+import type { PhiTableTagColor, PhiTableTagVariant, PhiTableValueRenderer } from "./table-widget";
+import type { PhiProviderResourceSource } from "./runtime-data-provider";
+/**
+ * One named value out of a record.
+ *
+ * **It is a table column without the table.** `PhiTableColumnDefinition` minus sorting, width, sticky,
+ * hiding and the editor -- everything a column needs because it stands in a grid of hundreds of rows,
+ * and nothing a value needs because it is being read. What is left is the part that was never about the
+ * table: which Provider field, what it is called, and how it is drawn.
+ *
+ * That is deliberate rather than convenient. A record of a table's rows is the same data read one at a
+ * time, so `datetime` has to mean there what it means in the column beside it, and `valueMap` has to
+ * turn a status code into the same word. `renderPhiValueContent` is the single answer to that; the only
+ * thing this type adds is `full`, because a record has lines and a cell does not.
+ */
+export type PhiRecordFieldDefinition = {
+    key: string;
+    /** The Provider field this reads, dotted for a nested one. */
+    fieldKey: string;
+    /** What the value is called. */
+    label: string;
+    renderer?: PhiTableValueRenderer;
+    valueMap?: Readonly<Record<string, string>>;
+    tagColorMap?: Readonly<Record<string, PhiTableTagColor>>;
+    tagVariant?: PhiTableTagVariant;
+    /** The rest of the line, for a value too long to share it -- a message, a stack, a JSON object. */
+    full?: boolean;
+};
+export type PhiRecordWidgetPresentation = {
+    /** A `grid` is a record read closely, with cells and rules; a `list` is a summary read once. */
+    appearance: "grid" | "list";
+    /** How many values stand side by side from `md` up. */
+    columns: number;
+    fields: readonly PhiRecordFieldDefinition[];
+};
+/**
+ * **Which record to show arrives as a signal.** The Widget does not know the table it belongs to and
+ * does not read a store: a row action carries a row identity onto the bus, and whoever listens on that
+ * route loads it. That is what lets the same Widget sit in an Overlay beside a table, on a page of its
+ * own driven by a selection elsewhere, or twice with two different sources.
+ */
+export type PhiRecordWidgetConfig = {
+    source: PhiProviderResourceSource | null;
+    /** The row action whose signal opens a record -- `view` in every first-party table so far. */
+    openActionKey: string;
+    presentation: PhiRecordWidgetPresentation;
+    signalRoutes?: PhiSignalRouteSet | null;
+};

package/types/record-widget.js

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

package/types/references.d.ts

@@ -1,30 +1,18 @@
-export declare const PHIS_INTERNAL_PAGE_SCHEME: "phis:page/";
-export declare const PHIS_INTERNAL_ASSET_SCHEME: "phis:asset/";
-export type PhiPageTarget = {
-    kind: "site";
-    pageScopeId: number;
-} | {
-    kind: "module";
-    ownerModuleId: string;
-    presetKey: string;
-};
-export type PhiPageReference = string & {
-    readonly __phiPageReference: unique symbol;
-};
-export type PhiInternalReference = {
-    kind: "page";
-    reference: PhiPageReference;
-    target: PhiPageTarget;
-    fragment: string | null;
-} | {
-    kind: "asset";
-    assetId: number;
-};
-export declare function createPhiPageReference(target: PhiPageTarget): PhiPageReference;
-export declare function readPhiPageReference(value: unknown): {
-    reference: PhiPageReference;
-    target: PhiPageTarget;
-} | null;
-export declare function createPhiPageUri(reference: PhiPageReference, fragment?: string | null): string;
-export declare function createPhiAssetUri(assetId: number): string;
-export declare function readPhiInternalReference(value: unknown): PhiInternalReference | null;
+/**
+ * Internal references, as this package uses them.
+ *
+ * The codec itself lives in `@phis/contracts/references`, because phi-server reads and writes the same
+ * values and the two must agree byte for byte -- it stood here and there in two copies until the short
+ * form landed, which is exactly the arrangement the CMS instance id was moved out of for the same
+ * reason. What stays here is the one type only the render side has a use for.
+ */
+export { PHIS_INTERNAL_ASSET_SCHEME, PHIS_INTERNAL_PAGE_SCHEME, PHI_LINK_TARGET_CONFIG_KEY, createPhiAssetUri, createPhiPageReference, createPhiPageUri, createPhiPresetCmsPageId, isPhiLinkTargetConfigKey, isPhiStorableExternalHref, readPhiInternalReference, readPhiLinkTarget, readPhiPageReference, type PhiInternalReference, type PhiLinkTarget, type PhiPageReference, type PhiPageTarget, type PhiPageTargetInput, } from "@phis/contracts/references";
+import type { PhiPageReference } from "@phis/contracts/references";
+/**
+ * The addresses this render's Page targets answer on, resolved once before anything draws.
+ *
+ * A Map rather than a resolver a Widget may call, because the batching is the contract: references are
+ * resolved per render, and a Widget that could ask would ask one at a time -- twelve Cards in a grid,
+ * twelve round trips. A reference that is absent here did not resolve, and the Control draws no link.
+ */
+export type PhiResolvedLinkTargets = ReadonlyMap<PhiPageReference, string>;

package/types/references.js

@@ -1,114 +1,9 @@
-export const PHIS_INTERNAL_PAGE_SCHEME = "phis:page/";
-export const PHIS_INTERNAL_ASSET_SCHEME = "phis:asset/";
-const PHI_PAGE_REFERENCE_PREFIX = "v1.";
-const PHI_MODULE_ID_PATTERN = /^@[^/]+\/[^/]+(?:\/[^/]+)*$/;
-function encodeBase64Url(value) {
-    const bytes = new TextEncoder().encode(value);
-    let binary = "";
-    for (let index = 0; index < bytes.length; index += 1) {
-        binary += String.fromCharCode(bytes[index]);
-    }
-    return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
-}
-function decodeBase64Url(value) {
-    if (!/^[A-Za-z0-9_-]+$/u.test(value)) {
-        return null;
-    }
-    const padded = value.replaceAll("-", "+").replaceAll("_", "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
-    try {
-        const binary = atob(padded);
-        const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
-        return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-    }
-    catch {
-        return null;
-    }
-}
-function isPositiveInteger(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
-}
-function parseSerializedPageTarget(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return null;
-    }
-    const record = value;
-    if (record.v !== 1) {
-        return null;
-    }
-    if (record.k === "s" && isPositiveInteger(record.i)) {
-        return { kind: "site", pageScopeId: record.i };
-    }
-    if (record.k === "m" &&
-        typeof record.m === "string" &&
-        PHI_MODULE_ID_PATTERN.test(record.m) &&
-        typeof record.p === "string" &&
-        record.p.trim().length > 0) {
-        return { kind: "module", ownerModuleId: record.m, presetKey: record.p };
-    }
-    return null;
-}
-export function createPhiPageReference(target) {
-    const serialized = target.kind === "site"
-        ? { v: 1, k: "s", i: target.pageScopeId }
-        : { v: 1, k: "m", m: target.ownerModuleId, p: target.presetKey };
-    const validated = parseSerializedPageTarget(serialized);
-    if (!validated) {
-        throw new Error("Invalid Phi Page target.");
-    }
-    return `${PHI_PAGE_REFERENCE_PREFIX}${encodeBase64Url(JSON.stringify(serialized))}`;
-}
-export function readPhiPageReference(value) {
-    if (typeof value !== "string" || !value.startsWith(PHI_PAGE_REFERENCE_PREFIX)) {
-        return null;
-    }
-    const decoded = decodeBase64Url(value.slice(PHI_PAGE_REFERENCE_PREFIX.length));
-    if (!decoded) {
-        return null;
-    }
-    try {
-        const target = parseSerializedPageTarget(JSON.parse(decoded));
-        return target ? { reference: value, target } : null;
-    }
-    catch {
-        return null;
-    }
-}
-export function createPhiPageUri(reference, fragment) {
-    if (!readPhiPageReference(reference)) {
-        throw new Error("Invalid Phi Page reference.");
-    }
-    const normalizedFragment = fragment?.replace(/^#/u, "").trim();
-    return `${PHIS_INTERNAL_PAGE_SCHEME}${reference}${normalizedFragment ? `#${encodeURIComponent(normalizedFragment)}` : ""}`;
-}
-export function createPhiAssetUri(assetId) {
-    if (!isPositiveInteger(assetId)) {
-        throw new Error("Phi Asset ids must be positive integers.");
-    }
-    return `${PHIS_INTERNAL_ASSET_SCHEME}${assetId}`;
-}
-export function readPhiInternalReference(value) {
-    if (typeof value !== "string") {
-        return null;
-    }
-    if (value.startsWith(PHIS_INTERNAL_ASSET_SCHEME)) {
-        const id = value.slice(PHIS_INTERNAL_ASSET_SCHEME.length);
-        return /^[1-9]\d*$/u.test(id) && Number.isSafeInteger(Number(id))
-            ? { kind: "asset", assetId: Number(id) }
-            : null;
-    }
-    if (!value.startsWith(PHIS_INTERNAL_PAGE_SCHEME)) {
-        return null;
-    }
-    const [encodedReference, ...fragmentParts] = value.slice(PHIS_INTERNAL_PAGE_SCHEME.length).split("#");
-    const parsed = readPhiPageReference(encodedReference);
-    if (!parsed) {
-        return null;
-    }
-    try {
-        const fragment = fragmentParts.length > 0 ? decodeURIComponent(fragmentParts.join("#")) : null;
-        return { kind: "page", ...parsed, fragment };
-    }
-    catch {
-        return null;
-    }
-}
+/**
+ * Internal references, as this package uses them.
+ *
+ * The codec itself lives in `@phis/contracts/references`, because phi-server reads and writes the same
+ * values and the two must agree byte for byte -- it stood here and there in two copies until the short
+ * form landed, which is exactly the arrangement the CMS instance id was moved out of for the same
+ * reason. What stays here is the one type only the render side has a use for.
+ */
+export { PHIS_INTERNAL_ASSET_SCHEME, PHIS_INTERNAL_PAGE_SCHEME, PHI_LINK_TARGET_CONFIG_KEY, createPhiAssetUri, createPhiPageReference, createPhiPageUri, createPhiPresetCmsPageId, isPhiLinkTargetConfigKey, isPhiStorableExternalHref, readPhiInternalReference, readPhiLinkTarget, readPhiPageReference, } from "@phis/contracts/references";

package/types/renderable-block-geometry.d.ts

@@ -0,0 +1,85 @@
+import type { PhiRenderableBlockResponsiveSize, PhiRenderableBlockSize, PhiRenderableBlockVisibility } from "./renderable-block";
+import { type PhiCssLengthPart } from "./length";
+/**
+ * A block's geometry, read once.
+ *
+ * `size`, `minSize` and `maxSize` used to be read wherever a box was drawn, and each reader interpreted
+ * them for itself: one appended `px`, one passed the value through and let React append it, one took
+ * `typeof value === "number"` for a type when it is a unit, and on an absent width there were as many
+ * answers as readers. A Layout in a slot drew its geometry twice, on two nested boxes, by two of those
+ * rules -- and they disagreed on the maximum.
+ *
+ * This is the one reader. It hands back CSS lengths decoded by unit, and it answers the question that
+ * `size` asks in the same breath as the measurement: an axis that states a size is an axis the block
+ * decides for itself, which is what flips a slot policy from `fill` to `fixed`. What a reader does with
+ * an absent value stays the reader's own fallback, stated at the call site rather than decided here a
+ * second time; what a reader never does again is look at the three fields.
+ *
+ * A collapsed block measures by its `collapsedSizeHint` where it has one, and that substitution lives
+ * here too, for the same reason: it was copied into six files, and a copy is a rule that has to be
+ * remembered.
+ */
+export type PhiResolvedBlockLength = {
+    /** What a stylesheet receives: `240px`, `50%`, or a keyword or expression passed through as written. */
+    css: string;
+    /**
+     * The length decoded by unit, or null for a keyword (`auto`, `fit-content`) or an expression (`calc()`)
+     * the vocabulary does not decode. A reader that has to know whether a maximum is absolute asks this,
+     * never `typeof`.
+     */
+    part: PhiCssLengthPart | null;
+};
+export type PhiResolvedBlockAxisGeometry = {
+    size: PhiResolvedBlockLength | null;
+    min: PhiResolvedBlockLength | null;
+    max: PhiResolvedBlockLength | null;
+};
+export type PhiResolvedBlockAxes = {
+    inline: PhiResolvedBlockAxisGeometry;
+    block: PhiResolvedBlockAxisGeometry;
+};
+export type PhiResolvedBlockGeometry = {
+    inline: PhiResolvedBlockAxisGeometry;
+    block: PhiResolvedBlockAxisGeometry;
+    /**
+     * The block decides its own inline axis: a width is stated, so the slot policy on that axis is
+     * `fixed`. Stated at *any* profile counts, because a slot policy and the data attribute that carries
+     * it are resolved once on the server and CSS can vary a width but not an attribute. "Explicit" is a
+     * property of the block as a whole; the profiles vary the value, not the policy.
+     */
+    explicitInline: boolean;
+    /** The block decides its own block axis. */
+    explicitBlock: boolean;
+    /**
+     * The other two answers, and only where a field names more than one.
+     *
+     * `inline` and `block` above are the base -- `compact`, what stands without a container query -- so
+     * every reader that existed before profiles keeps reading exactly what it read. The one emitter that
+     * writes the custom properties reads this.
+     */
+    profiles: {
+        medium: PhiResolvedBlockAxes;
+        wide: PhiResolvedBlockAxes;
+    } | null;
+};
+export type PhiRenderableBlockGeometryInput = {
+    visibility?: PhiRenderableBlockVisibility | null;
+    size?: PhiRenderableBlockResponsiveSize | null;
+    minSize?: PhiRenderableBlockResponsiveSize | null;
+    maxSize?: PhiRenderableBlockResponsiveSize | null;
+    collapsedSizeHint?: PhiRenderableBlockSize | null;
+};
+/** The three rooms a block may answer differently, smaller to larger. */
+export declare const PHI_BLOCK_PROFILES: readonly ["compact", "medium", "wide"];
+export type PhiBlockProfile = (typeof PHI_BLOCK_PROFILES)[number];
+export declare const PHI_EMPTY_BLOCK_GEOMETRY: PhiResolvedBlockGeometry;
+/**
+ * One stored length as a stylesheet receives it.
+ *
+ * A bare number is a pixel length, because that is how the vocabulary stores one (`serializePhiCssLength`);
+ * a string on the vocabulary is decoded and written back in canonical form; any other string is a
+ * keyword or an expression and goes through as written. A blank string states nothing, and neither does
+ * a number that is not finite.
+ */
+export declare function readPhiRenderableBlockLength(value: number | string | null | undefined): PhiResolvedBlockLength | null;
+export declare function resolvePhiRenderableBlockGeometry(config: PhiRenderableBlockGeometryInput | null | undefined): PhiResolvedBlockGeometry;