@nanisoft/prism-ui 0.10.2 → 0.15.0

package/dist/blocks/ops-checklist-01/ops-checklist-01.js

@@ -0,0 +1,165 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Metric } from '../../components/ui/metric.js';
+import { Section, SectionHeading, childLevel, } from '../../components/ui/section.js';
+import { Status } from '../../components/ui/status.js';
+import { cn } from '../../lib/utils.js';
+/** The tone each of the four verdicts is drawn in, from the semantic contract. */
+const VERDICT_TONE = {
+    pass: 'success',
+    fail: 'destructive',
+    warn: 'warning',
+    skipped: 'neutral',
+};
+/**
+ * The refusal, checked before anything is drawn so a caller's mistake is one
+ * diagnostic in a console rather than a coloured dot with no sentence beside it on a
+ * runbook somebody reads at three in the morning.
+ *
+ * One, and it is the same refusal `StatusLedger01`, `inbox-01` and every other mark
+ * in this package makes: a verdict is a colour and the words are the information. The
+ * message names the check and the group, because a runbook has one check called
+ * "Certificates" in three groups and a caller needs to know which.
+ */
+function assertChecks(groups) {
+    for (const group of groups) {
+        for (const check of group.checks) {
+            if (check.verdict !== undefined && check.verdictLabel === undefined) {
+                throw new Error(`OpsChecklist01: the check "${check.name}" in the group "${group.title}" has a verdict and no ` +
+                    'verdictLabel, so the mark would be a coloured dot with nothing to read beside it, in the document ' +
+                    'a person reads at three in the morning and quotes to somebody else afterwards. Pass the words ' +
+                    'for the verdict in your own language, or drop the verdict.');
+            }
+        }
+    }
+}
+/**
+ * A runbook: a set of checks a person performs on an estate, each with a state, an
+ * expected reading, the reading that was taken, and a verdict.
+ *
+ * **It must not decide a verdict, and that is the most important sentence in this
+ * file.** A design system that computed pass or fail would be making a claim about an
+ * estate it cannot see, on thresholds it does not have. What counts as a warning is a
+ * decision about an estate's risk appetite, and four NaniSoft estates have four of
+ * them: one calls a certificate at 89 days a pass, one calls it a warning, and one has
+ * no certificates at all. The threshold belongs to the caller who owns the estate, and
+ * so does the reading that was taken. So the verdict is a prop, the tones are this
+ * system's, and the words are the caller's, and a Block that inferred a verdict from
+ * a comparison between two cells would be a design system asserting an infrastructure
+ * fact. The cost of the refusal is real and it is the right one: a caller with three
+ * checks whose verdicts are all derivable writes three calls, and a caller who wanted
+ * the arithmetic done for them reaches for their own data layer, which is the only
+ * place that can see the estate.
+ *
+  * **`expected` and `actual` are two cells rather than one, because a runbook is about
+  * the difference between what should be and what is.** A Block that rendered one of
+  * them was rendering half the check: a column of expected readings tells a reader what
+  * the runbook believes, a column of actual readings tells them what happened, and
+  * neither one alone answers the only question a person opening a runbook has, which
+  * is whether the estate is well. So the two are separate fields, in that order, with
+  * the expected reading in the muted ink and the actual reading in the foreground,
+  * which is the order a person says them in, and the two cells are the same shape so
+  * the eye compares them without either one being the odd one out. A caller who passes
+  * one and not the other gets one cell filled and one empty, and the empty one is the
+  * fact: a check nobody has run yet is worth showing rather than hiding behind a
+  * placeholder.
+  *
+  * **No column name is drawn above either cell, and that is a refusal with a real
+  * cost.** "Expected" and "Actual" are this system's reading of the word, and every
+  * estate that reads a runbook aloud says something else: "Wanted" and "Found", "Should
+  * be" and "Is", "Configured" and "Running". A Block that named them would be
+  * publishing one estate's vocabulary into every product that installs it, inside a
+  * design system rather than inside a product's copy, which is where a translation
+  * tool is least likely to look. So the two are told apart by ink and by position, the
+  * expected one always first, and a caller who wants the words composes them into the
+  * node, which is what a `ReactNode` is for. The cost is the honest one: a caller who
+  * does not compose them is left with two columns a reader tells apart by shade rather
+  * than by word, and the answer for a runbook that needs a real header row is
+  * `DataTable01`, which is that table with the caller's own cells and column names.
+  *
+
+ * **The four verdicts are mapped here and the words are the caller's, and the
+ * `skipped` tone is the decision worth naming.** `pass` is `success` because it is
+ * the only verdict that means the estate is as it should be. `fail` is `destructive`
+ * because it is the one a reader must not miss. `warn` is `warning` because it is the
+ * verdict a reader has to act on without stopping work, which is what the warning
+ * tone has always meant here, and giving it a fifth state would be a colour a reader
+ * must learn and a word a maintainer must keep true. And `skipped` is `neutral`, not
+ * `destructive`, because a check a person could not run is not a check that failed,
+ * and drawing it in the tone that means a reader must not miss would train a reader to
+ * ignore that tone on the next run. The cost is that a runbook with forty skipped
+ * checks looks calm, and the words beside the dot are the only thing that says
+ * otherwise, which is the trade this design makes everywhere.
+ *
+ * **`verdictLabel` is a function of the verdict and is required, for the reason
+ * every mark in this package states and the reason a runbook is the worst case of
+ * them.** A coloured dot is invisible to a reader who cannot separate the tones and
+ * unreadable to a screen reader whatever the tones are, and the document being read is
+ * the one a person quotes to somebody else afterwards. Four estates between them use
+ * nine words for these four states, so the prop is a function and there is no default
+ * to fall back on. A check with a verdict and no label throws rather than rendering a
+ * dot, and the message names the check and the group.
+ *
+ * **The summary is `Metric` composed and not redrawn, and the Block passes no
+ * `delta`.** A runbook's figures are read first and named under, which is the
+ * arrangement `Metric` owns along with the type-scale decision and the rule that a
+ * string figure is set in the mono face. What this Block declines to pass is a delta,
+ * because a runbook is a snapshot of one run and a change against the previous run is
+ * a claim about a runbook the caller may not keep. The `label` is a `string` and the
+ * `value` a `node`, which is the same split `About01`'s figures make: a label is
+ * scanned and a value is composed.
+ *
+ * **The group title is a heading one step below the section and the check names are
+ * headings one step below that, because a runbook has two levels of outline and both
+ * of them are used.** A person reading a rota aloud goes group by group and check by
+ * check, and a reader who has learned the outline on one group has learned it for all
+ * of them. So the groups are headings at `childLevel(headingLevel)` and the checks are
+ * headings at `childLevel(childLevel(headingLevel))`, both derived, so a runbook
+ * embedded one level deeper carries its whole outline with it. The cost is a
+ * five-level outline on a deeply nested page, and `childLevel` holds at `h6` rather
+ * than wrapping for exactly that reason.
+ *
+ * **It is a server Component: no hook, no state, no effect, no client code and no
+ * router.** A runbook is a document a person reads, not a surface they work, so
+ * there is nothing here for a reader to press. The cost of that choice is that the
+ * Block cannot record that a check was performed; whether a runbook is a document or a
+ * checklist a person ticks off in the page is a decision about the caller's product,
+ * and a caller who wants the ticking composes their own control in `note` or their own
+ * region beside this Block.
+ */
+export function OpsChecklist01({ eyebrow, title, description, groups, summary, empty, headingLevel = 'h2', className, }) {
+    // A group's title is a heading one step below the section, and a check's name is a
+    // step below that, so a runbook embedded one level deeper than it was written for
+    // carries its whole outline with it rather than announcing a set of siblings of the
+    // section.
+    const GroupTitle = childLevel(headingLevel);
+    const CheckTitle = childLevel(GroupTitle);
+    assertChecks(groups);
+    const drawn = groups.reduce((total, group) => total + group.checks.length, 0);
+    return (_jsx(Section, { "data-slot": "ops-checklist-01", className: cn(className), children: _jsxs("div", { "data-slot": "ops-checklist-01-body", className: "flex flex-col gap-10", children: [_jsx(SectionHeading, { eyebrow: eyebrow, title: title, description: description, align: "left", as: headingLevel }), summary === undefined || summary.length === 0 ? null : (
+                /*
+                 * The figures, read first and named under, which is `Metric`'s arrangement
+                 * and the reason this Block composes it rather than drawing a figure row of
+                 * its own. A rule between them and the groups below, because a figure and a
+                 * check list are two different readings of the same page and a gap alone
+                 * stops being visible at the zoom levels where a figure gets small.
+                 */
+                _jsx("div", { "data-slot": "ops-checklist-01-summary", className: "border-border grid grid-cols-2 gap-6 border-t pt-6 sm:grid-cols-3 lg:grid-cols-4", children: summary.map((figure) => (_jsx(Metric, { label: figure.label, value: figure.value }, figure.label))) })), drawn === 0 ? (
+                /*
+                 * The caller's own sentence, drawn where the groups would have been rather
+                 * than above them. A `text-pretty` wrapper is here because the honest
+                 * sentence is sometimes a paragraph and `text-balance` would leave a
+                 * one-word last line in it.
+                 */
+                _jsx("p", { "data-slot": "ops-checklist-01-empty", className: "text-muted-foreground max-w-measure-narrow text-pretty", children: empty })) : (_jsx("div", { "data-slot": "ops-checklist-01-groups", className: "flex flex-col gap-10", children: groups.map((group) => group.checks.length === 0 ? null : (_jsxs("section", { "data-slot": "ops-checklist-01-group", "data-group": group.id, "aria-labelledby": `${group.id}-heading`, className: "flex flex-col gap-4", children: [_jsxs("div", { "data-slot": "ops-checklist-01-group-head", className: "flex flex-col gap-1.5", children: [_jsx(GroupTitle, { id: `${group.id}-heading`, "data-slot": "ops-checklist-01-group-title", className: "text-lg font-semibold tracking-tight", children: group.title }), group.description === undefined ? null : (_jsx("p", { "data-slot": "ops-checklist-01-group-description", className: "text-muted-foreground text-pretty text-sm", children: group.description }))] }), _jsx("ul", { "data-slot": "ops-checklist-01-checks", className: "border-border flex flex-col border-t", children: group.checks.map((check) => (_jsxs("li", { "data-slot": "ops-checklist-01-check", "data-check": check.id, "data-verdict": check.verdict, className: "border-border flex flex-col gap-3 border-b py-5 sm:flex-row sm:items-start sm:gap-6", children: [_jsxs("div", { "data-slot": "ops-checklist-01-identity", className: "flex min-w-0 flex-1 flex-col gap-3", children: [_jsx(CheckTitle, { "data-slot": "ops-checklist-01-name", className: "text-sm font-semibold", children: check.name }), _jsxs("div", { "data-slot": "ops-checklist-01-readings", className: "grid gap-3 sm:grid-cols-2 sm:gap-6", children: [_jsx("div", { "data-slot": "ops-checklist-01-expected", "data-taken": check.expected !== undefined, className: "text-muted-foreground flex min-w-0 flex-col text-pretty text-sm", children: check.expected }), _jsx("div", { "data-slot": "ops-checklist-01-actual", "data-taken": check.actual !== undefined, className: "border-border flex min-w-0 flex-col border-t pt-3 text-pretty text-sm sm:border-t-0 sm:border-l sm:pt-0 sm:pl-6", children: check.actual })] }), check.note === undefined ? null : (_jsx("p", { "data-slot": "ops-checklist-01-note", className: "text-muted-foreground text-pretty text-sm", children: check.note }))] }), check.verdict === undefined || check.verdictLabel === undefined ? null : (
+                                        /*
+                                          * The mark, with the caller's words beside it. It sits at the
+                                          * trailing edge of the row and after the two readings,
+                                          * never inside either, because a verdict a reader has to
+                                          * reach past the expected reading to find is a verdict they
+                                          * will not find. The dot inside `Status` is `aria-hidden`
+                                          * and the words are not, so a reader who cannot separate
+                                          * `warning` from `destructive` still reads which is which.
+                                          */
+                                        _jsx(Status, { "data-slot": "ops-checklist-01-verdict", size: "sm", tone: VERDICT_TONE[check.verdict], label: check.verdictLabel(check.verdict), className: "shrink-0" }))] }, check.id))) })] }, group.id))) }))] }) }));
+}
+export default OpsChecklist01;

package/dist/blocks/page-header-01/index.d.ts

@@ -1,3 +1,3 @@
-export { PageHeader01, default } from './page-header';
-export type { PageHeader01Props, PageHeaderAction, PageHeaderCrumb } from './page-header';
+export { PageHeader01, default } from './page-header.js';
+export type { PageHeader01Props, PageHeaderAction, PageHeaderLinkAction, PageHeaderSlotAction, PageHeaderCrumb, } from './page-header.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/blocks/page-header-01/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/blocks/page-header-01/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AACrD,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/blocks/page-header-01/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAIrD,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,GAChB,MAAM,eAAe,CAAA"}

package/dist/blocks/page-header-01/index.js

@@ -1 +1 @@
-export { PageHeader01, default } from './page-header';
+export { PageHeader01, default } from './page-header.js';

package/dist/blocks/page-header-01/page-header.d.ts

@@ -1,15 +1,120 @@
 import { type ReactNode } from 'react';
-import { type HeadingElement } from '../../components/ui/typography';
+import { type HeadingElement } from '../../components/ui/typography.js';
 export type PageHeaderCrumb = {
     label: ReactNode;
     /** Renders a native anchor. Omit on the current, final step. */
     href?: string;
 };
-export type PageHeaderAction = {
+/**
+ * One action in a page header's action row that names a destination.
+ *
+ * One of the two arms of `PageHeaderAction`, and named rather than left as an inline
+ * member of the union so a caller assembling a row from its own data can say which
+ * arm it is building. `href` is required and that is the whole of the arm.
+ */
+export type PageHeaderLinkAction = {
+    /** The words on the control. Every string a page header renders is the caller's. */
     label: string;
+    /**
+     * Where the action goes. Rendered as a native anchor's `href`.
+     *
+     * **Required rather than optional, and this Block is where the omission was
+     * worst.** The action type had no `href` member at all, so every declared action
+     * rendered a bare `<Button>`: focusable, announced as a button, and activating to
+     * nothing. A page header is the top of a screen, so those were the first controls
+     * a reader met on every page of a consumer's product and the first ones they
+     * reached by Tab.
+     */
+    href: string;
+    /** Opens the destination in a new browsing context, with the matching `rel`. */
+    newTab?: boolean;
+    /**
+     * Which weight this action draws at, when the caller does not say.
+     *
+     * Defaults to `default` for the first action in the row and `outline` for the
+     * rest. A slot carries its own weight, so it does not take one from here.
+     */
     variant?: 'default' | 'outline' | 'secondary' | 'ghost';
+    /**
+     * Which size this action draws at, when the caller does not say. `default` here
+     * means the Component's own, which is `default`.
+     */
     size?: 'default' | 'sm' | 'lg';
+    /**
+     * Forbidden, so that an action cannot be both a destination and a caller's own
+     * control. The two are rendered by different code on different elements, and a
+     * value carrying both would have to pick one silently.
+     */
+    slot?: never;
+};
+/**
+ * One action in a page header's action row that is the caller's own control.
+ *
+ * **This is the arm that replaced a rendered button, and the reason it is a slot
+ * rather than an `onClick` is that a Block cannot receive one.** This is a server
+ * Component, so a handler is not a prop it can be given, and every declared action
+ * used to render a bare `<Button>`. A page header is the one place on a screen where
+ * a dead control is worst, because a reader arriving at a new page looks at the top
+ * of it first.
+ *
+ * What belongs here is what a header actually carries: a control that opens a menu,
+ * a router's own `Link` for a client-side transition, a share sheet. What does not
+ * belong here is a plain anchor; that is the other arm.
+ */
+export type PageHeaderSlotAction = {
+    /**
+     * The caller's own control, placed in the row where this action sits.
+     *
+     * The whole control, including its own label, its own weight and any icon. The
+     * Block draws no frame around it and adds no class to it, because a class it adds
+     * is a style the caller cannot see and cannot remove, and this package has no
+     * override path.
+     */
+    slot: ReactNode;
+    /**
+     * Forbidden on this arm, and for a reason rather than by tidiness: the Block
+     * renders `slot` and nothing else, so a `label` beside it would be a word no
+     * reader ever sees and a caller would reasonably believe had been rendered.
+     */
+    label?: never;
+    /** Forbidden: an anchor belongs on the other arm, where Prism renders it. */
+    href?: never;
+    /** Forbidden with `href`, for the same reason. */
+    newTab?: never;
+    /**
+     * Forbidden, because the Block cannot style a node it does not render. A weight
+     * accepted here and dropped would be the one prop in this Block that a reader of
+     * the type could believe was in effect when it is not.
+     */
+    variant?: never;
+    /** Forbidden, for the same reason. */
+    size?: never;
 };
+/**
+ * One action in a page header's action row, as a union of the two things an action
+ * in this position can honestly be.
+ *
+ * **This replaces a single shape with no destination member at all**, which is a
+ * worse starting point than the one a hero had: there was no optional `href` to
+ * tighten, there was no `href` at all, so `{ label: 'New deployment' }` was the only
+ * value the type could express and every value produced a dead button. The union is
+ * what gives the caller a second thing to say, and the required `href` on the first
+ * arm is what makes the mistake loud rather than silent.
+ *
+ * **The slot is an arm of the row rather than the sibling prop `actionsSlot` was,
+ * and that is the one structural change here.** A sibling slot renders before the
+ * row's own actions and cannot say which position it fills, so a caller who wanted
+ * a primary menu trigger at the front and a link behind it had to put the link first
+ * and accept the order, or pass the trigger in `actions` where it was a dead button.
+ * As an arm, position and element are the same value. `actionsSlot` is therefore
+ * gone, and a consumer who passed one moves the node it holds into `actions`.
+ *
+ * It is declared here rather than imported from `hero-01`, following
+ * `ProcessFlow01`'s note on the same point: a page header and a hero are different
+ * sections making different claims, and a consumer composing one has no reason to
+ * take the other's type. `scripts/check-block-controls.mjs` holds the shape itself.
+ */
+export type PageHeaderAction = PageHeaderLinkAction | PageHeaderSlotAction;
 export type PageHeader01Props = {
     /**
      * The trail above the title. The final item always renders as the current
@@ -21,12 +126,14 @@ export type PageHeader01Props = {
     /** One supporting line under the title. */
     description?: ReactNode;
     /**
-     * Declarative actions rendered as Prism Buttons. Use `actionsSlot` for a
-     * control that needs its own behaviour, such as a router link or a menu.
+     * Declarative actions rendered in the header's action row.
+     *
+     * Every action Prism renders here is a link with a required `href`, so it is a
+     * native anchor announced as a link rather than a button announced as a command.
+     * A control that cannot be a link takes a `slot`, and the Block places it where
+     * this action sits.
      */
     actions?: PageHeaderAction[];
-    /** A slot for consumer-provided controls on the action row. */
-    actionsSlot?: ReactNode;
     /**
      * The heading element for the title. Defaults to `h2` because a block is
      * composed; a page whose own document outline this header opens passes
@@ -37,12 +144,18 @@ export type PageHeader01Props = {
 /**
  * A page title band.
  *
- * It places a breadcrumb trail and a row of actions above the title, then a
- * rule below the header. The trail is passed in as props and renders native
- * anchors, so the consumer owns navigation and can substitute their own
- * router by passing `actionsSlot` and breadcrumb labels. Every string and
- * every step is a prop; the block ships none of its own.
+ * It places a breadcrumb trail and a row of actions above the title, then a rule
+ * below the header. The trail is passed in as props and renders native anchors, so
+ * the consumer owns navigation and can substitute their own router by passing
+ * breadcrumb labels without an `href` on the steps it does not want to link. Every
+ * string and every step is a prop; the block ships none of its own.
+ *
+ * **The action row is links and slots, and never buttons of its own.** It used to
+ * declare `actions` as a list of `{ label, variant, size }` with no destination
+ * member and render each one as a `Button`, which is a focusable control announced
+ * as a button that activates to nothing, at the top of a screen. See
+ * `PageHeaderAction`.
  */
-export declare function PageHeader01({ breadcrumbs, title, description, actions, actionsSlot, headingLevel, }: PageHeader01Props): import("react").JSX.Element;
+export declare function PageHeader01({ breadcrumbs, title, description, actions, headingLevel, }: PageHeader01Props): import("react").JSX.Element;
 export default PageHeader01;
 //# sourceMappingURL=page-header.d.ts.map

package/dist/blocks/page-header-01/page-header.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"page-header.d.ts","sourceRoot":"","sources":["../../../src/blocks/page-header-01/page-header.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAYhD,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAEnF,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,SAAS,CAAA;IAChB,gEAAgE;IAChE,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,OAAO,CAAA;IACvD,IAAI,CAAC,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAAA;CAC/B,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;OAGG;IACH,WAAW,CAAC,EAAE,eAAe,EAAE,CAAA;IAC/B,sBAAsB;IACtB,KAAK,EAAE,SAAS,CAAA;IAChB,2CAA2C;IAC3C,WAAW,CAAC,EAAE,SAAS,CAAA;IACvB;;;OAGG;IACH,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAA;IAC5B,+DAA+D;IAC/D,WAAW,CAAC,EAAE,SAAS,CAAA;IACvB;;;;OAIG;IACH,YAAY,CAAC,EAAE,cAAc,CAAA;CAC9B,CAAA;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,EAC3B,WAAW,EACX,KAAK,EACL,WAAW,EACX,OAAY,EACZ,WAAW,EACX,YAAmB,GACpB,EAAE,iBAAiB,+BAiEnB;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"page-header.d.ts","sourceRoot":"","sources":["../../../src/blocks/page-header-01/page-header.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAYhD,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAEnF,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,SAAS,CAAA;IAChB,gEAAgE;IAChE,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;GAMG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,oFAAoF;IACpF,KAAK,EAAE,MAAM,CAAA;IACb;;;;;;;;;OASG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ,gFAAgF;IAChF,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,OAAO,CAAA;IACvD;;;OAGG;IACH,IAAI,CAAC,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAAA;IAC9B;;;;OAIG;IACH,IAAI,CAAC,EAAE,KAAK,CAAA;CACb,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC;;;;;;;OAOG;IACH,IAAI,EAAE,SAAS,CAAA;IACf;;;;OAIG;IACH,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,6EAA6E;IAC7E,IAAI,CAAC,EAAE,KAAK,CAAA;IACZ,kDAAkD;IAClD,MAAM,CAAC,EAAE,KAAK,CAAA;IACd;;;;OAIG;IACH,OAAO,CAAC,EAAE,KAAK,CAAA;IACf,sCAAsC;IACtC,IAAI,CAAC,EAAE,KAAK,CAAA;CACb,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,gBAAgB,GAAG,oBAAoB,GAAG,oBAAoB,CAAA;AAE1E,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;OAGG;IACH,WAAW,CAAC,EAAE,eAAe,EAAE,CAAA;IAC/B,sBAAsB;IACtB,KAAK,EAAE,SAAS,CAAA;IAChB,2CAA2C;IAC3C,WAAW,CAAC,EAAE,SAAS,CAAA;IACvB;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAA;IAC5B;;;;OAIG;IACH,YAAY,CAAC,EAAE,cAAc,CAAA;CAC9B,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,EAC3B,WAAW,EACX,KAAK,EACL,WAAW,EACX,OAAY,EACZ,YAAmB,GACpB,EAAE,iBAAiB,+BA6EnB;AAED,eAAe,YAAY,CAAA"}

package/dist/blocks/page-header-01/page-header.js

@@ -1,27 +1,43 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Fragment } from 'react';
-import { Breadcrumb, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, } from '../../components/ui/breadcrumb';
-import { Button } from '../../components/ui/button';
-import { Separator } from '../../components/ui/separator';
-import { Heading, Text } from '../../components/ui/typography';
+import { Breadcrumb, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, } from '../../components/ui/breadcrumb.js';
+import { CtaLink } from '../../components/ui/cta-link.js';
+import { Separator } from '../../components/ui/separator.js';
+import { Heading, Text } from '../../components/ui/typography.js';
 /**
  * A page title band.
  *
- * It places a breadcrumb trail and a row of actions above the title, then a
- * rule below the header. The trail is passed in as props and renders native
- * anchors, so the consumer owns navigation and can substitute their own
- * router by passing `actionsSlot` and breadcrumb labels. Every string and
- * every step is a prop; the block ships none of its own.
+ * It places a breadcrumb trail and a row of actions above the title, then a rule
+ * below the header. The trail is passed in as props and renders native anchors, so
+ * the consumer owns navigation and can substitute their own router by passing
+ * breadcrumb labels without an `href` on the steps it does not want to link. Every
+ * string and every step is a prop; the block ships none of its own.
+ *
+ * **The action row is links and slots, and never buttons of its own.** It used to
+ * declare `actions` as a list of `{ label, variant, size }` with no destination
+ * member and render each one as a `Button`, which is a focusable control announced
+ * as a button that activates to nothing, at the top of a screen. See
+ * `PageHeaderAction`.
  */
-export function PageHeader01({ breadcrumbs, title, description, actions = [], actionsSlot, headingLevel = 'h2', }) {
+export function PageHeader01({ breadcrumbs, title, description, actions = [], headingLevel = 'h2', }) {
     const hasTrail = Boolean(breadcrumbs?.length);
-    const hasActions = actions.length > 0 || Boolean(actionsSlot);
+    const hasActions = actions.length > 0;
     return (_jsxs("header", { className: "flex flex-col gap-4", children: [hasTrail || hasActions ? (_jsxs("div", { className: "flex flex-wrap items-center justify-between gap-4", children: [hasTrail ? (_jsx(Breadcrumb, { children: _jsx(BreadcrumbList, { children: breadcrumbs?.map((crumb, index) => {
                                 const last = index === breadcrumbs.length - 1;
                                 return (
                                 // Positional, for the same reason as the other blocks: the
                                 // label is display content and two steps may share one.
                                 _jsxs(Fragment, { children: [index > 0 ? _jsx(BreadcrumbSeparator, {}) : null, _jsx(BreadcrumbItem, { children: last || !crumb.href ? (_jsx(BreadcrumbPage, { children: crumb.label })) : (_jsx(BreadcrumbLink, { href: crumb.href, children: crumb.label })) })] }, index));
-                            }) }) })) : (_jsx("span", {})), hasActions ? (_jsxs("div", { className: "flex items-center gap-2", children: [actionsSlot, actions.map((action, index) => (_jsx(Button, { variant: action.variant ?? (index === 0 ? 'default' : 'outline'), size: action.size, children: action.label }, index)))] })) : null] })) : null, _jsxs("div", { className: "flex flex-col gap-1.5", children: [_jsx(Heading, { as: headingLevel, size: "3xl", children: title }), description ? (_jsx(Text, { size: "lg", tone: "muted", children: description })) : null] }), _jsx(Separator, {})] }));
+                            }) }) })) : (_jsx("span", {})), hasActions ? (_jsx("div", { className: "flex items-center gap-2", children: actions.map((action, index) => {
+                            // A slot is the caller's own control, placed where it asked to be and
+                            // otherwise untouched. Keyed positionally for the reason the other
+                            // keyed lists in this package state: two actions may share a label,
+                            // and a row keyed on a localised label remounts when the reader
+                            // changes language.
+                            if ('slot' in action) {
+                                return _jsx(Fragment, { children: action.slot }, index);
+                            }
+                            return (_jsx(CtaLink, { href: action.href, newTab: action.newTab, variant: action.variant ?? (index === 0 ? 'default' : 'outline'), size: action.size, children: action.label }, index));
+                        }) })) : null] })) : null, _jsxs("div", { className: "flex flex-col gap-1.5", children: [_jsx(Heading, { as: headingLevel, size: "3xl", children: title }), description ? (_jsx(Text, { size: "lg", tone: "muted", children: description })) : null] }), _jsx(Separator, {})] }));
 }
 export default PageHeader01;

package/dist/blocks/passkey-01/index.d.ts

@@ -0,0 +1,3 @@
+export { Passkey01, default } from './passkey-01.js';
+export type { Passkey01Authenticator, Passkey01Props, Passkey01Status, } from './passkey-01.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/blocks/passkey-01/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/blocks/passkey-01/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAOjD,YAAY,EACV,sBAAsB,EACtB,cAAc,EACd,eAAe,GAChB,MAAM,cAAc,CAAA"}

package/dist/blocks/passkey-01/index.js

@@ -0,0 +1 @@
+export { Passkey01, default } from './passkey-01.js';