@entifix/react-controls 0.18.2 → 0.20.0

package/dist/ui/actions/action-surfaces.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/ui/actions/action-surfaces.ts"],"sourcesContent":["import {\n  type UseCaseBinding,\n  type UseCaseDescriptor,\n  type UseCasePlacement,\n} from '@entifix/core';\n\n/**\n * Where a declared verb is rendered.\n *\n * The use-case descriptor has two independent axes, and at first only one\n * surface, so four of the nine cells had nowhere to go: `EntityForm` filtered\n * `binding === 'entity' && placement !== 'context-dependent'` and everything\n * else was dropped without a word. This is the map that closes it —\n * **placement decides the surface, binding decides the payload** — and it lives\n * in one module so no surface re-derives it and the two axes cannot drift\n * apart again.\n */\nexport const ACTION_SURFACES = [\n  'form-header',\n  'form-footer',\n  'row-menu',\n  'bulk-bar',\n  'table-toolbar',\n  'command-palette',\n] as const;\nexport type ActionSurface = (typeof ACTION_SURFACES)[number];\n\n/**\n * The nine cells, exhaustively.\n *\n * `collection` + `determining` is deliberately absent, and asking for it\n * throws rather than returning `undefined`. A determining action *finalizes a\n * page* — it is the footer that ends an object page — and a list screen has no\n * such thing to finalize, which is Fiori's own rule. Dropping it silently is\n * the fault this repo already writes an assertion against elsewhere: the verb\n * would be declared, granted, exported, pass every check a register runs,\n * and simply never appear, which reads to its author as \"the permission is\n * wrong\" and sends them looking in the wrong place entirely.\n */\nconst SURFACE_BY_CELL: Record<string, ActionSurface> = {\n  'entity:context-independent': 'form-header',\n  'entity:determining': 'form-footer',\n  'entity:context-dependent': 'row-menu',\n  'collection:context-dependent': 'bulk-bar',\n  'collection:context-independent': 'table-toolbar',\n  'unbound:context-dependent': 'command-palette',\n  'unbound:context-independent': 'command-palette',\n  'unbound:determining': 'command-palette',\n};\n\n/**\n * The overflow trigger's glyph.\n *\n * A constant rather than a literal in JSX, because `react/jsx-no-literals`\n * fails the build on written-in copy and is right to: it cannot tell a\n * typographic glyph from a forgotten Spanish string. The trigger's *name* is a\n * catalog key (`form.moreActions`, `table.actions`) — this is only the mark,\n * and it is never read aloud.\n */\nexport const OVERFLOW_GLYPH = '\\u22ef';\n\n/** Which surface renders one cell. Throws on a cell no surface owns. */\nfunction surfaceForCell(\n  key: string,\n  binding: UseCaseBinding,\n  placement: UseCasePlacement,\n): ActionSurface {\n  const surface = SURFACE_BY_CELL[`${binding}:${placement}`];\n\n  if (surface === undefined) {\n    throw new Error(\n      `The use case \"${key}\" is declared ${binding} + ${placement}, which no surface renders. ` +\n        'A `determining` action finalizes a page — it is an object page’s footer — and a list ' +\n        'screen has no page to finalize, so a collection-bound verb cannot be determining. ' +\n        'Declare it `context-dependent` to reach the bulk bar, or `context-independent` to sit ' +\n        'in the table toolbar.',\n    );\n  }\n\n  return surface;\n}\n\n/**\n * Every surface this descriptor renders on.\n *\n * ⚠️ **A verb may name more than one cell**, and that is what makes publishing\n * reachable from a form header, a row menu and a selection without becoming\n * three permissions. The primary `binding` + `placement` come first, then\n * whatever `alsoAt` adds, and each is validated the same way — an illegal cell\n * in `alsoAt` throws exactly as one in the primary pair does.\n *\n * Duplicates are collapsed. A descriptor that named the same cell twice would\n * otherwise render the verb twice in one menu, which reads as a bug in the\n * screen rather than in the declaration.\n */\nexport function surfacesFor(\n  descriptor: UseCaseDescriptor,\n): readonly ActionSurface[] {\n  const cells = [\n    { binding: descriptor.binding, placement: descriptor.placement },\n    ...(descriptor.alsoAt ?? []),\n  ];\n\n  return [\n    ...new Set(\n      cells.map(cell =>\n        surfaceForCell(descriptor.key, cell.binding, cell.placement),\n      ),\n    ),\n  ];\n}\n\n/**\n * The single surface this descriptor renders on.\n *\n * Kept for the callers that genuinely have one — the command palette asks \"is\n * this mine?\" of an `unbound` verb, which can only ever be in one place. Any\n * caller that renders a *list* of verbs wants {@link surfacesFor}.\n */\nexport function surfaceFor(descriptor: UseCaseDescriptor): ActionSurface {\n  return surfaceForCell(\n    descriptor.key,\n    descriptor.binding,\n    descriptor.placement,\n  );\n}\n\n/**\n * The descriptors one surface should render, in declaration order.\n *\n * Every descriptor is passed through {@link surfacesFor}, so an unrenderable\n * cell throws on the **first render of any surface** rather than only on the\n * one that would have shown it — the same reason\n * `assertLinkSourcesAreEditable` runs as one pass over the registry instead of\n * per row: a check that only fires on the screen that was already looking for\n * the verb is a check that fires after the bug is reported. A cell declared in\n * `alsoAt` is validated on that same first render, not on the surface it names.\n */\nexport function useCasesForSurface(\n  surface: ActionSurface,\n  useCases: readonly UseCaseDescriptor[] | undefined,\n): UseCaseDescriptor[] {\n  return (useCases ?? []).filter(descriptor =>\n    surfacesFor(descriptor).includes(surface),\n  );\n}\n"],"names":["ACTION_SURFACES","SURFACE_BY_CELL","OVERFLOW_GLYPH","surfaceForCell","key","binding","placement","surface","undefined","Error","surfacesFor","descriptor","cells","alsoAt","Set","map","cell","surfaceFor","useCasesForSurface","useCases","filter","includes"],"mappings":"AAMA;;;;;;;;;;CAUC,GACD,OAAO,MAAMA,kBAAkB;IAC7B;IACA;IACA;IACA;IACA;IACA;CACD,CAAU;AAGX;;;;;;;;;;;CAWC,GACD,MAAMC,kBAAiD;IACrD,8BAA8B;IAC9B,sBAAsB;IACtB,4BAA4B;IAC5B,gCAAgC;IAChC,kCAAkC;IAClC,6BAA6B;IAC7B,+BAA+B;IAC/B,uBAAuB;AACzB;AAEA;;;;;;;;CAQC,GACD,OAAO,MAAMC,iBAAiB,SAAS;AAEvC,sEAAsE,GACtE,SAASC,eACPC,GAAW,EACXC,OAAuB,EACvBC,SAA2B;IAE3B,MAAMC,UAAUN,eAAe,CAAC,GAAGI,QAAQ,CAAC,EAAEC,WAAW,CAAC;IAE1D,IAAIC,YAAYC,WAAW;QACzB,MAAM,IAAIC,MACR,CAAC,cAAc,EAAEL,IAAI,cAAc,EAAEC,QAAQ,GAAG,EAAEC,UAAU,4BAA4B,CAAC,GACvF,0FACA,uFACA,2FACA;IAEN;IAEA,OAAOC;AACT;AAEA;;;;;;;;;;;;CAYC,GACD,OAAO,SAASG,YACdC,UAA6B;QAIvBA;IAFN,MAAMC,QAAQ;QACZ;YAAEP,SAASM,WAAWN,OAAO;YAAEC,WAAWK,WAAWL,SAAS;QAAC;YAC3DK,qBAAAA,WAAWE,MAAM,YAAjBF,qBAAqB,EAAE;KAC5B;IAED,OAAO;WACF,IAAIG,IACLF,MAAMG,GAAG,CAACC,CAAAA,OACRb,eAAeQ,WAAWP,GAAG,EAAEY,KAAKX,OAAO,EAAEW,KAAKV,SAAS;KAGhE;AACH;AAEA;;;;;;CAMC,GACD,OAAO,SAASW,WAAWN,UAA6B;IACtD,OAAOR,eACLQ,WAAWP,GAAG,EACdO,WAAWN,OAAO,EAClBM,WAAWL,SAAS;AAExB;AAEA;;;;;;;;;;CAUC,GACD,OAAO,SAASY,mBACdX,OAAsB,EACtBY,QAAkD;IAElD,OAAO,CAACA,mBAAAA,WAAY,EAAE,EAAEC,MAAM,CAACT,CAAAA,aAC7BD,YAAYC,YAAYU,QAAQ,CAACd;AAErC"}
+{"version":3,"sources":["../../../src/ui/actions/action-surfaces.ts"],"sourcesContent":["import {\n  type UseCaseBinding,\n  type UseCaseDescriptor,\n  type UseCasePlacement,\n} from '@entifix/core';\n\n/**\n * Where a declared verb is rendered.\n *\n * The use-case descriptor has two independent axes, and at first only one\n * surface, so four of the nine cells had nowhere to go: `EntityForm` filtered\n * `binding === 'entity' && placement !== 'context-dependent'` and everything\n * else was dropped without a word. This is the map that closes it —\n * **placement decides the surface, binding decides the payload** — and it lives\n * in one module so no surface re-derives it and the two axes cannot drift\n * apart again.\n */\nexport const ACTION_SURFACES = [\n  'form-header',\n  'form-footer',\n  'row-menu',\n  'bulk-bar',\n  'table-toolbar',\n  'command-palette',\n] as const;\nexport type ActionSurface = (typeof ACTION_SURFACES)[number];\n\n/**\n * The nine cells, exhaustively.\n *\n * `collection` + `determining` is deliberately absent, and asking for it\n * throws rather than returning `undefined`. A determining action *finalizes a\n * page* — it is the footer that ends an object page — and a list screen has no\n * such thing to finalize, which is Fiori's own rule. Dropping it silently is\n * the fault this repo already writes an assertion against elsewhere: the verb\n * would be declared, granted, exported, pass every check a register runs,\n * and simply never appear, which reads to its author as \"the permission is\n * wrong\" and sends them looking in the wrong place entirely.\n */\nconst SURFACE_BY_CELL: Record<string, ActionSurface> = {\n  'entity:context-independent': 'form-header',\n  'entity:determining': 'form-footer',\n  'entity:context-dependent': 'row-menu',\n  'collection:context-dependent': 'bulk-bar',\n  'collection:context-independent': 'table-toolbar',\n  'unbound:context-dependent': 'command-palette',\n  'unbound:context-independent': 'command-palette',\n  'unbound:determining': 'command-palette',\n};\n\n/**\n * The overflow trigger's glyph.\n *\n * A constant rather than a literal in JSX, because `react/jsx-no-literals`\n * fails the build on written-in copy and is right to: it cannot tell a\n * typographic glyph from a forgotten Spanish string. The trigger's *name* is a\n * catalog key (`actions.more`, `actions.forRecord`) — this is only the mark,\n * and it is never read aloud.\n */\nexport const OVERFLOW_GLYPH = '\\u22ef';\n\n/** Which surface renders one cell. Throws on a cell no surface owns. */\nfunction surfaceForCell(\n  key: string,\n  binding: UseCaseBinding,\n  placement: UseCasePlacement,\n): ActionSurface {\n  const surface = SURFACE_BY_CELL[`${binding}:${placement}`];\n\n  if (surface === undefined) {\n    throw new Error(\n      `The use case \"${key}\" is declared ${binding} + ${placement}, which no surface renders. ` +\n        'A `determining` action finalizes a page — it is an object page’s footer — and a list ' +\n        'screen has no page to finalize, so a collection-bound verb cannot be determining. ' +\n        'Declare it `context-dependent` to reach the bulk bar, or `context-independent` to sit ' +\n        'in the table toolbar.',\n    );\n  }\n\n  return surface;\n}\n\n/**\n * Every surface this descriptor renders on.\n *\n * ⚠️ **A verb may name more than one cell**, and that is what makes publishing\n * reachable from a form header, a row menu and a selection without becoming\n * three permissions. The primary `binding` + `placement` come first, then\n * whatever `alsoAt` adds, and each is validated the same way — an illegal cell\n * in `alsoAt` throws exactly as one in the primary pair does.\n *\n * Duplicates are collapsed. A descriptor that named the same cell twice would\n * otherwise render the verb twice in one menu, which reads as a bug in the\n * screen rather than in the declaration.\n */\nexport function surfacesFor(\n  descriptor: UseCaseDescriptor,\n): readonly ActionSurface[] {\n  const cells = [\n    { binding: descriptor.binding, placement: descriptor.placement },\n    ...(descriptor.alsoAt ?? []),\n  ];\n\n  return [\n    ...new Set(\n      cells.map(cell =>\n        surfaceForCell(descriptor.key, cell.binding, cell.placement),\n      ),\n    ),\n  ];\n}\n\n/**\n * The single surface this descriptor renders on.\n *\n * Kept for the callers that genuinely have one — the command palette asks \"is\n * this mine?\" of an `unbound` verb, which can only ever be in one place. Any\n * caller that renders a *list* of verbs wants {@link surfacesFor}.\n */\nexport function surfaceFor(descriptor: UseCaseDescriptor): ActionSurface {\n  return surfaceForCell(\n    descriptor.key,\n    descriptor.binding,\n    descriptor.placement,\n  );\n}\n\n/**\n * The descriptors one surface should render, in declaration order.\n *\n * Every descriptor is passed through {@link surfacesFor}, so an unrenderable\n * cell throws on the **first render of any surface** rather than only on the\n * one that would have shown it — the same reason\n * `assertLinkSourcesAreEditable` runs as one pass over the registry instead of\n * per row: a check that only fires on the screen that was already looking for\n * the verb is a check that fires after the bug is reported. A cell declared in\n * `alsoAt` is validated on that same first render, not on the surface it names.\n */\nexport function useCasesForSurface(\n  surface: ActionSurface,\n  useCases: readonly UseCaseDescriptor[] | undefined,\n): UseCaseDescriptor[] {\n  return (useCases ?? []).filter(descriptor =>\n    surfacesFor(descriptor).includes(surface),\n  );\n}\n"],"names":["ACTION_SURFACES","SURFACE_BY_CELL","OVERFLOW_GLYPH","surfaceForCell","key","binding","placement","surface","undefined","Error","surfacesFor","descriptor","cells","alsoAt","Set","map","cell","surfaceFor","useCasesForSurface","useCases","filter","includes"],"mappings":"AAMA;;;;;;;;;;CAUC,GACD,OAAO,MAAMA,kBAAkB;IAC7B;IACA;IACA;IACA;IACA;IACA;CACD,CAAU;AAGX;;;;;;;;;;;CAWC,GACD,MAAMC,kBAAiD;IACrD,8BAA8B;IAC9B,sBAAsB;IACtB,4BAA4B;IAC5B,gCAAgC;IAChC,kCAAkC;IAClC,6BAA6B;IAC7B,+BAA+B;IAC/B,uBAAuB;AACzB;AAEA;;;;;;;;CAQC,GACD,OAAO,MAAMC,iBAAiB,SAAS;AAEvC,sEAAsE,GACtE,SAASC,eACPC,GAAW,EACXC,OAAuB,EACvBC,SAA2B;IAE3B,MAAMC,UAAUN,eAAe,CAAC,GAAGI,QAAQ,CAAC,EAAEC,WAAW,CAAC;IAE1D,IAAIC,YAAYC,WAAW;QACzB,MAAM,IAAIC,MACR,CAAC,cAAc,EAAEL,IAAI,cAAc,EAAEC,QAAQ,GAAG,EAAEC,UAAU,4BAA4B,CAAC,GACvF,0FACA,uFACA,2FACA;IAEN;IAEA,OAAOC;AACT;AAEA;;;;;;;;;;;;CAYC,GACD,OAAO,SAASG,YACdC,UAA6B;QAIvBA;IAFN,MAAMC,QAAQ;QACZ;YAAEP,SAASM,WAAWN,OAAO;YAAEC,WAAWK,WAAWL,SAAS;QAAC;YAC3DK,qBAAAA,WAAWE,MAAM,YAAjBF,qBAAqB,EAAE;KAC5B;IAED,OAAO;WACF,IAAIG,IACLF,MAAMG,GAAG,CAACC,CAAAA,OACRb,eAAeQ,WAAWP,GAAG,EAAEY,KAAKX,OAAO,EAAEW,KAAKV,SAAS;KAGhE;AACH;AAEA;;;;;;CAMC,GACD,OAAO,SAASW,WAAWN,UAA6B;IACtD,OAAOR,eACLQ,WAAWP,GAAG,EACdO,WAAWN,OAAO,EAClBM,WAAWL,SAAS;AAExB;AAEA;;;;;;;;;;CAUC,GACD,OAAO,SAASY,mBACdX,OAAsB,EACtBY,QAAkD;IAElD,OAAO,CAACA,mBAAAA,WAAY,EAAE,EAAEC,MAAM,CAACT,CAAAA,aAC7BD,YAAYC,YAAYU,QAAQ,CAACd;AAErC"}

package/dist/ui/actions/error-actions.d.ts

@@ -0,0 +1,32 @@
+import { type ReactNode } from 'react';
+/** What a host can do about a failure, by the failure's `code`. */
+export type ErrorActions = Readonly<Record<string, () => void>>;
+/**
+ * Registers the host's next step for each failure code it can resolve —
+ * "Choose organization" for `noActiveOrganization` — so a region or a toast
+ * showing that failure can offer it ([ADR 0028](../../../../../../docs/adr/0028-states-an-organism-must-render.md)).
+ */
+export declare function ErrorActionsProvider({ actions, children, }: {
+    actions: ErrorActions;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** A failure as the organisms hold it. */
+interface CodedFailure {
+    code?: unknown;
+    details?: Record<string, unknown>;
+}
+/** The action a failure offers: its label, and what it does. */
+export interface ErrorAction {
+    readonly label: string;
+    readonly onAction: () => void;
+}
+/**
+ * The next step for a failure, or `undefined`. Offered only when **both**
+ * exist: a handler the host registered for the failure's code, and the
+ * catalog's `errors:<code>Action` to name it — the code stays the catalog key,
+ * so a button never shows a key, and copy without a handler never shows a
+ * button that does nothing.
+ */
+export declare function useErrorAction(): (failure: CodedFailure | undefined) => ErrorAction | undefined;
+export {};
+//# sourceMappingURL=error-actions.d.ts.map

package/dist/ui/actions/error-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-actions.d.ts","sourceRoot":"","sources":["../../../src/ui/actions/error-actions.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAiB,KAAK,SAAS,EAAc,MAAM,OAAO,CAAC;AAIlE,mEAAmE;AACnE,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC;AAIhE;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,OAAO,EACP,QAAQ,GACT,EAAE;IACD,OAAO,EAAE,YAAY,CAAC;IACtB,QAAQ,EAAE,SAAS,CAAC;CACrB,+BAMA;AAED,0CAA0C;AAC1C,UAAU,YAAY;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,gEAAgE;AAChE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,IAAI,CAChC,OAAO,EAAE,YAAY,GAAG,SAAS,KAC9B,WAAW,GAAG,SAAS,CAe3B"}

package/dist/ui/actions/error-actions.js

@@ -0,0 +1,40 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+import { useTranslateKey } from '../../i18n/index.js';
+const ErrorActionsContext = /*#__PURE__*/ createContext({});
+/**
+ * Registers the host's next step for each failure code it can resolve —
+ * "Choose organization" for `noActiveOrganization` — so a region or a toast
+ * showing that failure can offer it ([ADR 0028](../../../../../../docs/adr/0028-states-an-organism-must-render.md)).
+ */ export function ErrorActionsProvider({ actions, children }) {
+    return /*#__PURE__*/ _jsx(ErrorActionsContext.Provider, {
+        value: actions,
+        children: children
+    });
+}
+/**
+ * The next step for a failure, or `undefined`. Offered only when **both**
+ * exist: a handler the host registered for the failure's code, and the
+ * catalog's `errors:<code>Action` to name it — the code stays the catalog key,
+ * so a button never shows a key, and copy without a handler never shows a
+ * button that does nothing.
+ */ export function useErrorAction() {
+    const actions = useContext(ErrorActionsContext);
+    const translateKey = useTranslateKey();
+    return (failure)=>{
+        var _failure_details;
+        const code = typeof (failure == null ? void 0 : failure.code) === 'string' ? failure.code : failure == null ? void 0 : (_failure_details = failure.details) == null ? void 0 : _failure_details['code'];
+        if (typeof code !== 'string') return undefined;
+        const onAction = actions[code];
+        if (onAction === undefined) return undefined;
+        // A missing key comes back as itself, without its namespace.
+        const label = translateKey(`errors:${code}Action`);
+        return label === `${code}Action` ? undefined : {
+            label,
+            onAction
+        };
+    };
+}
+
+//# sourceMappingURL=error-actions.js.map

package/dist/ui/actions/error-actions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/ui/actions/error-actions.tsx"],"sourcesContent":["'use client';\n\nimport { createContext, type ReactNode, useContext } from 'react';\n\nimport { useTranslateKey } from '../../i18n/index.js';\n\n/** What a host can do about a failure, by the failure's `code`. */\nexport type ErrorActions = Readonly<Record<string, () => void>>;\n\nconst ErrorActionsContext = createContext<ErrorActions>({});\n\n/**\n * Registers the host's next step for each failure code it can resolve —\n * \"Choose organization\" for `noActiveOrganization` — so a region or a toast\n * showing that failure can offer it ([ADR 0028](../../../../../../docs/adr/0028-states-an-organism-must-render.md)).\n */\nexport function ErrorActionsProvider({\n  actions,\n  children,\n}: {\n  actions: ErrorActions;\n  children: ReactNode;\n}) {\n  return (\n    <ErrorActionsContext.Provider value={actions}>\n      {children}\n    </ErrorActionsContext.Provider>\n  );\n}\n\n/** A failure as the organisms hold it. */\ninterface CodedFailure {\n  code?: unknown;\n  details?: Record<string, unknown>;\n}\n\n/** The action a failure offers: its label, and what it does. */\nexport interface ErrorAction {\n  readonly label: string;\n  readonly onAction: () => void;\n}\n\n/**\n * The next step for a failure, or `undefined`. Offered only when **both**\n * exist: a handler the host registered for the failure's code, and the\n * catalog's `errors:<code>Action` to name it — the code stays the catalog key,\n * so a button never shows a key, and copy without a handler never shows a\n * button that does nothing.\n */\nexport function useErrorAction(): (\n  failure: CodedFailure | undefined,\n) => ErrorAction | undefined {\n  const actions = useContext(ErrorActionsContext);\n  const translateKey = useTranslateKey();\n  return failure => {\n    const code =\n      typeof failure?.code === 'string'\n        ? failure.code\n        : failure?.details?.['code'];\n    if (typeof code !== 'string') return undefined;\n    const onAction = actions[code];\n    if (onAction === undefined) return undefined;\n    // A missing key comes back as itself, without its namespace.\n    const label = translateKey(`errors:${code}Action`);\n    return label === `${code}Action` ? undefined : { label, onAction };\n  };\n}\n"],"names":["createContext","useContext","useTranslateKey","ErrorActionsContext","ErrorActionsProvider","actions","children","Provider","value","useErrorAction","translateKey","failure","code","details","undefined","onAction","label"],"mappings":"AAAA;;AAEA,SAASA,aAAa,EAAkBC,UAAU,QAAQ,QAAQ;AAElE,SAASC,eAAe,QAAQ,sBAAsB;AAKtD,MAAMC,oCAAsBH,cAA4B,CAAC;AAEzD;;;;CAIC,GACD,OAAO,SAASI,qBAAqB,EACnCC,OAAO,EACPC,QAAQ,EAIT;IACC,qBACE,KAACH,oBAAoBI,QAAQ;QAACC,OAAOH;kBAClCC;;AAGP;AAcA;;;;;;CAMC,GACD,OAAO,SAASG;IAGd,MAAMJ,UAAUJ,WAAWE;IAC3B,MAAMO,eAAeR;IACrB,OAAOS,CAAAA;YAICA;QAHN,MAAMC,OACJ,QAAOD,2BAAAA,QAASC,IAAI,MAAK,WACrBD,QAAQC,IAAI,GACZD,4BAAAA,mBAAAA,QAASE,OAAO,qBAAhBF,gBAAkB,CAAC,OAAO;QAChC,IAAI,OAAOC,SAAS,UAAU,OAAOE;QACrC,MAAMC,WAAWV,OAAO,CAACO,KAAK;QAC9B,IAAIG,aAAaD,WAAW,OAAOA;QACnC,6DAA6D;QAC7D,MAAME,QAAQN,aAAa,CAAC,OAAO,EAAEE,KAAK,MAAM,CAAC;QACjD,OAAOI,UAAU,GAAGJ,KAAK,MAAM,CAAC,GAAGE,YAAY;YAAEE;YAAOD;QAAS;IACnE;AACF"}

package/dist/ui/actions/index.d.ts

@@ -1,3 +1,5 @@
 export * from './action-surfaces.js';
+export * from './error-actions.js';
 export * from './render-link.js';
+export * from './shortcut.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/ui/actions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ui/actions/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ui/actions/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC"}

package/dist/ui/actions/index.js

@@ -1,4 +1,6 @@
 export * from './action-surfaces.js';
+export * from './error-actions.js';
 export * from './render-link.js';
+export * from './shortcut.js';
 
 //# sourceMappingURL=index.js.map

package/dist/ui/actions/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/ui/actions/index.ts"],"sourcesContent":["export * from './action-surfaces.js';\nexport * from './render-link.js';\n"],"names":[],"mappings":"AAAA,cAAc,uBAAuB;AACrC,cAAc,mBAAmB"}
+{"version":3,"sources":["../../../src/ui/actions/index.ts"],"sourcesContent":["export * from './action-surfaces.js';\nexport * from './error-actions.js';\nexport * from './render-link.js';\nexport * from './shortcut.js';\n"],"names":[],"mappings":"AAAA,cAAc,uBAAuB;AACrC,cAAc,qBAAqB;AACnC,cAAc,mBAAmB;AACjC,cAAc,gBAAgB"}

package/dist/ui/actions/shortcut.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A declared chord as `aria-keyshortcuts` writes it: `Mod` is ⌘ on macOS and
+ * Ctrl elsewhere, and the attribute cannot know which machine it is read on, so
+ * it names both — `Mod+S` is `Control+S Meta+S`. A chord with no `Mod` is
+ * written once.
+ */
+export declare function ariaKeyShortcuts(chord: string): string;
+/**
+ * A declared chord as a person reads it on their own machine: `⌘S` on a Mac,
+ * `Ctrl+S` elsewhere — what the command palette shows beside an action.
+ */
+export declare function shortcutLabel(chord: string, mac?: boolean): string;
+//# sourceMappingURL=shortcut.d.ts.map

package/dist/ui/actions/shortcut.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortcut.d.ts","sourceRoot":"","sources":["../../../src/ui/actions/shortcut.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQtD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,GAAG,UAA6C,GAC/C,MAAM,CAKR"}

package/dist/ui/actions/shortcut.js

@@ -0,0 +1,18 @@
+/**
+ * A declared chord as `aria-keyshortcuts` writes it: `Mod` is ⌘ on macOS and
+ * Ctrl elsewhere, and the attribute cannot know which machine it is read on, so
+ * it names both — `Mod+S` is `Control+S Meta+S`. A chord with no `Mod` is
+ * written once.
+ */ export function ariaKeyShortcuts(chord) {
+    if (!chord.split('+').includes('Mod')) return chord;
+    const as = (modifier)=>chord.split('+').map((part)=>part === 'Mod' ? modifier : part).join('+');
+    return `${as('Control')} ${as('Meta')}`;
+}
+/**
+ * A declared chord as a person reads it on their own machine: `⌘S` on a Mac,
+ * `Ctrl+S` elsewhere — what the command palette shows beside an action.
+ */ export function shortcutLabel(chord, mac = /Mac|iPhone|iPad/.test(navigator.platform)) {
+    return chord.split('+').map((part)=>part === 'Mod' ? mac ? '⌘' : 'Ctrl' : part).join(mac ? '' : '+');
+}
+
+//# sourceMappingURL=shortcut.js.map

package/dist/ui/actions/shortcut.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/ui/actions/shortcut.ts"],"sourcesContent":["/**\n * A declared chord as `aria-keyshortcuts` writes it: `Mod` is ⌘ on macOS and\n * Ctrl elsewhere, and the attribute cannot know which machine it is read on, so\n * it names both — `Mod+S` is `Control+S Meta+S`. A chord with no `Mod` is\n * written once.\n */\nexport function ariaKeyShortcuts(chord: string): string {\n  if (!chord.split('+').includes('Mod')) return chord;\n  const as = (modifier: string) =>\n    chord\n      .split('+')\n      .map(part => (part === 'Mod' ? modifier : part))\n      .join('+');\n  return `${as('Control')} ${as('Meta')}`;\n}\n\n/**\n * A declared chord as a person reads it on their own machine: `⌘S` on a Mac,\n * `Ctrl+S` elsewhere — what the command palette shows beside an action.\n */\nexport function shortcutLabel(\n  chord: string,\n  mac = /Mac|iPhone|iPad/.test(navigator.platform),\n): string {\n  return chord\n    .split('+')\n    .map(part => (part === 'Mod' ? (mac ? '⌘' : 'Ctrl') : part))\n    .join(mac ? '' : '+');\n}\n"],"names":["ariaKeyShortcuts","chord","split","includes","as","modifier","map","part","join","shortcutLabel","mac","test","navigator","platform"],"mappings":"AAAA;;;;;CAKC,GACD,OAAO,SAASA,iBAAiBC,KAAa;IAC5C,IAAI,CAACA,MAAMC,KAAK,CAAC,KAAKC,QAAQ,CAAC,QAAQ,OAAOF;IAC9C,MAAMG,KAAK,CAACC,WACVJ,MACGC,KAAK,CAAC,KACNI,GAAG,CAACC,CAAAA,OAASA,SAAS,QAAQF,WAAWE,MACzCC,IAAI,CAAC;IACV,OAAO,GAAGJ,GAAG,WAAW,CAAC,EAAEA,GAAG,SAAS;AACzC;AAEA;;;CAGC,GACD,OAAO,SAASK,cACdR,KAAa,EACbS,MAAM,kBAAkBC,IAAI,CAACC,UAAUC,QAAQ,CAAC;IAEhD,OAAOZ,MACJC,KAAK,CAAC,KACNI,GAAG,CAACC,CAAAA,OAASA,SAAS,QAASG,MAAM,MAAM,SAAUH,MACrDC,IAAI,CAACE,MAAM,KAAK;AACrB"}

package/dist/ui/actions/use-verb-invoker.d.ts

@@ -0,0 +1,50 @@
+import type { UseCaseDescriptor } from '@entifix/core';
+import { type ReactNode } from 'react';
+/**
+ * A `matching` selection larger than this asks for the count to be typed
+ * before a destructive verb runs over it.
+ */
+export declare const TYPED_SELECTION_THRESHOLD = 1000;
+/** One verb about to run, and what it runs on. */
+export interface VerbRequest<TTarget> {
+    readonly descriptor: Pick<UseCaseDescriptor, 'key' | 'labelKey' | 'confirm' | 'reversible' | 'inverse'>;
+    readonly target: TTarget;
+    /** What it acts on, as the dialog names it: "Acme", "12 invoices". */
+    readonly object: string;
+    /** How many records; 1 for a single record. */
+    readonly count: number;
+    /** A selection of everything a filter matches, rather than ticked rows. */
+    readonly matching?: boolean;
+}
+export interface VerbInvokerOptions<TTarget> {
+    /** Runs a verb — the descriptor's own, or its inverse on Undo — by key. */
+    readonly run: (key: string, target: TTarget) => void;
+    readonly busy?: boolean;
+    readonly typedThreshold?: number;
+    /**
+     * The verbs this caller may run — the served document's `useCases`, which
+     * leave out what the caller holds no grant for. Undo is offered only when
+     * its `inverse` is one of them. Without it, every verb may run.
+     */
+    readonly served?: readonly Pick<UseCaseDescriptor, 'key'>[];
+}
+export interface VerbInvoker<TTarget> {
+    readonly invoke: (request: VerbRequest<TTarget>) => void;
+    /** The confirmation, while one is open. Render it once, anywhere. */
+    readonly dialog: ReactNode;
+}
+/**
+ * Where every surface sends a verb, so none can reach one around its safety
+ * ([ADR 0026](../../../../../../docs/adr/0026-actions-hierarchy-overflow-and-destructive-verbs.md)):
+ *
+ * - no `confirm` — it runs;
+ * - `reversible: 'undo'` — it runs, and a toast offers Undo, which runs its
+ *   `inverse`. Without a toast region to offer Undo in, or an inverse this
+ *   caller may run, it asks instead;
+ * - `confirm` — an alert dialog asks a question naming the object and the
+ *   count, and the button repeats the verb with the count;
+ * - `typed`, or a `matching` selection over {@link TYPED_SELECTION_THRESHOLD}
+ *   — the same dialog, and the name or the count has to be typed first.
+ */
+export declare function useVerbInvoker<TTarget>({ run, busy, typedThreshold, served, }: VerbInvokerOptions<TTarget>): VerbInvoker<TTarget>;
+//# sourceMappingURL=use-verb-invoker.d.ts.map

package/dist/ui/actions/use-verb-invoker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-verb-invoker.d.ts","sourceRoot":"","sources":["../../../src/ui/actions/use-verb-invoker.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,KAAK,SAAS,EAAY,MAAM,OAAO,CAAC;AAMjD;;;GAGG;AACH,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C,kDAAkD;AAClD,MAAM,WAAW,WAAW,CAAC,OAAO;IAClC,QAAQ,CAAC,UAAU,EAAE,IAAI,CACvB,iBAAiB,EACjB,KAAK,GAAG,UAAU,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CAC1D,CAAC;IACF,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,sEAAsE;IACtE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,+CAA+C;IAC/C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,kBAAkB,CAAC,OAAO;IACzC,2EAA2E;IAC3E,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IACrD,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,IAAI,CAAC,iBAAiB,EAAE,KAAK,CAAC,EAAE,CAAC;CAC7D;AAED,MAAM,WAAW,WAAW,CAAC,OAAO;IAClC,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC;IACzD,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;CAC5B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,EACtC,GAAG,EACH,IAAY,EACZ,cAA0C,EAC1C,MAAM,GACP,EAAE,kBAAkB,CAAC,OAAO,CAAC,GAAG,WAAW,CAAC,OAAO,CAAC,CAyEpD"}

package/dist/ui/actions/use-verb-invoker.js

@@ -0,0 +1,93 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { useT, useTranslateKey } from '../../i18n/index.js';
+import { ConfirmDialog } from '../molecules/confirm-dialog/index.js';
+import { useToasts } from '../molecules/toast-region/index.js';
+/**
+ * A `matching` selection larger than this asks for the count to be typed
+ * before a destructive verb runs over it.
+ */ export const TYPED_SELECTION_THRESHOLD = 1000;
+/**
+ * Where every surface sends a verb, so none can reach one around its safety
+ * ([ADR 0026](../../../../../../docs/adr/0026-actions-hierarchy-overflow-and-destructive-verbs.md)):
+ *
+ * - no `confirm` — it runs;
+ * - `reversible: 'undo'` — it runs, and a toast offers Undo, which runs its
+ *   `inverse`. Without a toast region to offer Undo in, or an inverse this
+ *   caller may run, it asks instead;
+ * - `confirm` — an alert dialog asks a question naming the object and the
+ *   count, and the button repeats the verb with the count;
+ * - `typed`, or a `matching` selection over {@link TYPED_SELECTION_THRESHOLD}
+ *   — the same dialog, and the name or the count has to be typed first.
+ */ export function useVerbInvoker({ run, busy = false, typedThreshold = TYPED_SELECTION_THRESHOLD, served }) {
+    var _confirm_confirmLabelKey;
+    const t = useT();
+    const translateKey = useTranslateKey();
+    const toasts = useToasts();
+    const [pending, setPending] = useState(undefined);
+    const invoke = (request)=>{
+        const { descriptor, target, object } = request;
+        const { confirm, inverse } = descriptor;
+        if (confirm === undefined) {
+            run(descriptor.key, target);
+            return;
+        }
+        if (descriptor.reversible === 'undo' && inverse !== undefined && (served === undefined || served.some((useCase)=>useCase.key === inverse)) && toasts !== undefined) {
+            run(descriptor.key, target);
+            const verb = translateKey(descriptor.labelKey);
+            toasts.show({
+                tone: 'undo',
+                message: confirm.doneKey === undefined ? t('confirm.done', {
+                    verb,
+                    object
+                }) : translateKey(confirm.doneKey, {
+                    object,
+                    count: request.count
+                }),
+                action: {
+                    label: t('confirm.undo'),
+                    onAction: ()=>run(inverse, target)
+                }
+            });
+            return;
+        }
+        setPending(request);
+    };
+    if (pending === undefined) return {
+        invoke,
+        dialog: undefined
+    };
+    const { descriptor, object, count } = pending;
+    const confirm = descriptor.confirm;
+    const verb = translateKey((_confirm_confirmLabelKey = confirm.confirmLabelKey) != null ? _confirm_confirmLabelKey : descriptor.labelKey);
+    const typed = descriptor.reversible === 'typed' || pending.matching === true && count > typedThreshold;
+    return {
+        invoke,
+        dialog: /*#__PURE__*/ _jsx(ConfirmDialog, {
+            open: true,
+            tone: confirm.tone,
+            title: t('confirm.question', {
+                verb: translateKey(descriptor.labelKey),
+                object
+            }),
+            message: translateKey(confirm.messageKey, {
+                object,
+                count
+            }),
+            confirmLabel: t('confirm.verbCount', {
+                verb,
+                count
+            }),
+            typed: typed ? count > 1 ? String(count) : object : undefined,
+            busy: busy,
+            onCancel: ()=>setPending(undefined),
+            onConfirm: ()=>{
+                setPending(undefined);
+                run(descriptor.key, pending.target);
+            }
+        })
+    };
+}
+
+//# sourceMappingURL=use-verb-invoker.js.map

package/dist/ui/actions/use-verb-invoker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/ui/actions/use-verb-invoker.tsx"],"sourcesContent":["'use client';\n\nimport type { UseCaseDescriptor } from '@entifix/core';\nimport { type ReactNode, useState } from 'react';\n\nimport { useT, useTranslateKey } from '../../i18n/index.js';\nimport { ConfirmDialog } from '../molecules/confirm-dialog/index.js';\nimport { useToasts } from '../molecules/toast-region/index.js';\n\n/**\n * A `matching` selection larger than this asks for the count to be typed\n * before a destructive verb runs over it.\n */\nexport const TYPED_SELECTION_THRESHOLD = 1000;\n\n/** One verb about to run, and what it runs on. */\nexport interface VerbRequest<TTarget> {\n  readonly descriptor: Pick<\n    UseCaseDescriptor,\n    'key' | 'labelKey' | 'confirm' | 'reversible' | 'inverse'\n  >;\n  readonly target: TTarget;\n  /** What it acts on, as the dialog names it: \"Acme\", \"12 invoices\". */\n  readonly object: string;\n  /** How many records; 1 for a single record. */\n  readonly count: number;\n  /** A selection of everything a filter matches, rather than ticked rows. */\n  readonly matching?: boolean;\n}\n\nexport interface VerbInvokerOptions<TTarget> {\n  /** Runs a verb — the descriptor's own, or its inverse on Undo — by key. */\n  readonly run: (key: string, target: TTarget) => void;\n  readonly busy?: boolean;\n  readonly typedThreshold?: number;\n  /**\n   * The verbs this caller may run — the served document's `useCases`, which\n   * leave out what the caller holds no grant for. Undo is offered only when\n   * its `inverse` is one of them. Without it, every verb may run.\n   */\n  readonly served?: readonly Pick<UseCaseDescriptor, 'key'>[];\n}\n\nexport interface VerbInvoker<TTarget> {\n  readonly invoke: (request: VerbRequest<TTarget>) => void;\n  /** The confirmation, while one is open. Render it once, anywhere. */\n  readonly dialog: ReactNode;\n}\n\n/**\n * Where every surface sends a verb, so none can reach one around its safety\n * ([ADR 0026](../../../../../../docs/adr/0026-actions-hierarchy-overflow-and-destructive-verbs.md)):\n *\n * - no `confirm` — it runs;\n * - `reversible: 'undo'` — it runs, and a toast offers Undo, which runs its\n *   `inverse`. Without a toast region to offer Undo in, or an inverse this\n *   caller may run, it asks instead;\n * - `confirm` — an alert dialog asks a question naming the object and the\n *   count, and the button repeats the verb with the count;\n * - `typed`, or a `matching` selection over {@link TYPED_SELECTION_THRESHOLD}\n *   — the same dialog, and the name or the count has to be typed first.\n */\nexport function useVerbInvoker<TTarget>({\n  run,\n  busy = false,\n  typedThreshold = TYPED_SELECTION_THRESHOLD,\n  served,\n}: VerbInvokerOptions<TTarget>): VerbInvoker<TTarget> {\n  const t = useT();\n  const translateKey = useTranslateKey();\n  const toasts = useToasts();\n  const [pending, setPending] = useState<VerbRequest<TTarget> | undefined>(\n    undefined,\n  );\n\n  const invoke = (request: VerbRequest<TTarget>) => {\n    const { descriptor, target, object } = request;\n    const { confirm, inverse } = descriptor;\n    if (confirm === undefined) {\n      run(descriptor.key, target);\n      return;\n    }\n    if (\n      descriptor.reversible === 'undo' &&\n      inverse !== undefined &&\n      (served === undefined ||\n        served.some(useCase => useCase.key === inverse)) &&\n      toasts !== undefined\n    ) {\n      run(descriptor.key, target);\n      const verb = translateKey(descriptor.labelKey);\n      toasts.show({\n        tone: 'undo',\n        message:\n          confirm.doneKey === undefined\n            ? t('confirm.done', { verb, object })\n            : translateKey(confirm.doneKey, { object, count: request.count }),\n        action: {\n          label: t('confirm.undo'),\n          onAction: () => run(inverse, target),\n        },\n      });\n      return;\n    }\n    setPending(request);\n  };\n\n  if (pending === undefined) return { invoke, dialog: undefined };\n\n  const { descriptor, object, count } = pending;\n  const confirm = descriptor.confirm as NonNullable<\n    UseCaseDescriptor['confirm']\n  >;\n  const verb = translateKey(confirm.confirmLabelKey ?? descriptor.labelKey);\n  const typed =\n    descriptor.reversible === 'typed' ||\n    (pending.matching === true && count > typedThreshold);\n\n  return {\n    invoke,\n    dialog: (\n      <ConfirmDialog\n        open\n        tone={confirm.tone}\n        title={t('confirm.question', {\n          verb: translateKey(descriptor.labelKey),\n          object,\n        })}\n        message={translateKey(confirm.messageKey, { object, count })}\n        confirmLabel={t('confirm.verbCount', { verb, count })}\n        typed={typed ? (count > 1 ? String(count) : object) : undefined}\n        busy={busy}\n        onCancel={() => setPending(undefined)}\n        onConfirm={() => {\n          setPending(undefined);\n          run(descriptor.key, pending.target);\n        }}\n      />\n    ),\n  };\n}\n"],"names":["useState","useT","useTranslateKey","ConfirmDialog","useToasts","TYPED_SELECTION_THRESHOLD","useVerbInvoker","run","busy","typedThreshold","served","confirm","t","translateKey","toasts","pending","setPending","undefined","invoke","request","descriptor","target","object","inverse","key","reversible","some","useCase","verb","labelKey","show","tone","message","doneKey","count","action","label","onAction","dialog","confirmLabelKey","typed","matching","open","title","messageKey","confirmLabel","String","onCancel","onConfirm"],"mappings":"AAAA;;AAGA,SAAyBA,QAAQ,QAAQ,QAAQ;AAEjD,SAASC,IAAI,EAAEC,eAAe,QAAQ,sBAAsB;AAC5D,SAASC,aAAa,QAAQ,uCAAuC;AACrE,SAASC,SAAS,QAAQ,qCAAqC;AAE/D;;;CAGC,GACD,OAAO,MAAMC,4BAA4B,KAAK;AAoC9C;;;;;;;;;;;;CAYC,GACD,OAAO,SAASC,eAAwB,EACtCC,GAAG,EACHC,OAAO,KAAK,EACZC,iBAAiBJ,yBAAyB,EAC1CK,MAAM,EACsB;QA8CFC;IA7C1B,MAAMC,IAAIX;IACV,MAAMY,eAAeX;IACrB,MAAMY,SAASV;IACf,MAAM,CAACW,SAASC,WAAW,GAAGhB,SAC5BiB;IAGF,MAAMC,SAAS,CAACC;QACd,MAAM,EAAEC,UAAU,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGH;QACvC,MAAM,EAAER,OAAO,EAAEY,OAAO,EAAE,GAAGH;QAC7B,IAAIT,YAAYM,WAAW;YACzBV,IAAIa,WAAWI,GAAG,EAAEH;YACpB;QACF;QACA,IACED,WAAWK,UAAU,KAAK,UAC1BF,YAAYN,aACXP,CAAAA,WAAWO,aACVP,OAAOgB,IAAI,CAACC,CAAAA,UAAWA,QAAQH,GAAG,KAAKD,QAAO,KAChDT,WAAWG,WACX;YACAV,IAAIa,WAAWI,GAAG,EAAEH;YACpB,MAAMO,OAAOf,aAAaO,WAAWS,QAAQ;YAC7Cf,OAAOgB,IAAI,CAAC;gBACVC,MAAM;gBACNC,SACErB,QAAQsB,OAAO,KAAKhB,YAChBL,EAAE,gBAAgB;oBAAEgB;oBAAMN;gBAAO,KACjCT,aAAaF,QAAQsB,OAAO,EAAE;oBAAEX;oBAAQY,OAAOf,QAAQe,KAAK;gBAAC;gBACnEC,QAAQ;oBACNC,OAAOxB,EAAE;oBACTyB,UAAU,IAAM9B,IAAIgB,SAASF;gBAC/B;YACF;YACA;QACF;QACAL,WAAWG;IACb;IAEA,IAAIJ,YAAYE,WAAW,OAAO;QAAEC;QAAQoB,QAAQrB;IAAU;IAE9D,MAAM,EAAEG,UAAU,EAAEE,MAAM,EAAEY,KAAK,EAAE,GAAGnB;IACtC,MAAMJ,UAAUS,WAAWT,OAAO;IAGlC,MAAMiB,OAAOf,cAAaF,2BAAAA,QAAQ4B,eAAe,YAAvB5B,2BAA2BS,WAAWS,QAAQ;IACxE,MAAMW,QACJpB,WAAWK,UAAU,KAAK,WACzBV,QAAQ0B,QAAQ,KAAK,QAAQP,QAAQzB;IAExC,OAAO;QACLS;QACAoB,sBACE,KAACnC;YACCuC,IAAI;YACJX,MAAMpB,QAAQoB,IAAI;YAClBY,OAAO/B,EAAE,oBAAoB;gBAC3BgB,MAAMf,aAAaO,WAAWS,QAAQ;gBACtCP;YACF;YACAU,SAASnB,aAAaF,QAAQiC,UAAU,EAAE;gBAAEtB;gBAAQY;YAAM;YAC1DW,cAAcjC,EAAE,qBAAqB;gBAAEgB;gBAAMM;YAAM;YACnDM,OAAOA,QAASN,QAAQ,IAAIY,OAAOZ,SAASZ,SAAUL;YACtDT,MAAMA;YACNuC,UAAU,IAAM/B,WAAWC;YAC3B+B,WAAW;gBACThC,WAAWC;gBACXV,IAAIa,WAAWI,GAAG,EAAET,QAAQM,MAAM;YACpC;;IAGN;AACF"}

package/dist/ui/atoms/alert/alert-dismiss.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentPropsWithoutRef } from 'react';
+export type AlertDismissProps = Omit<ComponentPropsWithoutRef<'button'>, 'children' | 'type'>;
+/**
+ * The × that dismisses an {@link Alert}, passed as its `action`. A client
+ * component of its own so `Alert` stays server-safe: dismissing is the one part
+ * of a message that needs a handler. Its name comes from the controls catalog.
+ */
+export declare function AlertDismiss({ className, ...props }: AlertDismissProps): import("react").JSX.Element;
+//# sourceMappingURL=alert-dismiss.d.ts.map

package/dist/ui/atoms/alert/alert-dismiss.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alert-dismiss.d.ts","sourceRoot":"","sources":["../../../../src/ui/atoms/alert/alert-dismiss.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,OAAO,CAAC;AAKtD,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAClC,wBAAwB,CAAC,QAAQ,CAAC,EAClC,UAAU,GAAG,MAAM,CACpB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,EAAE,SAAS,EAAE,GAAG,KAAK,EAAE,EAAE,iBAAiB,+BAetE"}

package/dist/ui/atoms/alert/alert-dismiss.js

@@ -0,0 +1,28 @@
+'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useT } from '../../../i18n/index.js';
+import { cn } from '../../utils/cn.js';
+/**
+ * The × that dismisses an {@link Alert}, passed as its `action`. A client
+ * component of its own so `Alert` stays server-safe: dismissing is the one part
+ * of a message that needs a handler. Its name comes from the controls catalog.
+ */ export function AlertDismiss(_0) {
+    let { className } = _0, props = _object_without_properties_loose(_0, [
+        "className"
+    ]);
+    const t = useT();
+    return /*#__PURE__*/ _jsx("button", _extends({
+        type: "button",
+        "aria-label": t('alert.dismiss'),
+        className: cn('flex min-h-(--target-min) min-w-(--target-min) items-center justify-center rounded-md focus-ring hover:bg-surface-elevated/60', className)
+    }, props, {
+        children: /*#__PURE__*/ _jsx("span", {
+            "aria-hidden": "true",
+            children: "×"
+        })
+    }));
+}
+
+//# sourceMappingURL=alert-dismiss.js.map

package/dist/ui/atoms/alert/alert-dismiss.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/atoms/alert/alert-dismiss.tsx"],"sourcesContent":["'use client';\n\nimport type { ComponentPropsWithoutRef } from 'react';\n\nimport { useT } from '../../../i18n/index.js';\nimport { cn } from '../../utils/cn.js';\n\nexport type AlertDismissProps = Omit<\n  ComponentPropsWithoutRef<'button'>,\n  'children' | 'type'\n>;\n\n/**\n * The × that dismisses an {@link Alert}, passed as its `action`. A client\n * component of its own so `Alert` stays server-safe: dismissing is the one part\n * of a message that needs a handler. Its name comes from the controls catalog.\n */\nexport function AlertDismiss({ className, ...props }: AlertDismissProps) {\n  const t = useT();\n  return (\n    <button\n      type=\"button\"\n      aria-label={t('alert.dismiss')}\n      className={cn(\n        'flex min-h-(--target-min) min-w-(--target-min) items-center justify-center rounded-md focus-ring hover:bg-surface-elevated/60',\n        className,\n      )}\n      {...props}\n    >\n      <span aria-hidden=\"true\">×</span>\n    </button>\n  );\n}\n"],"names":["useT","cn","AlertDismiss","className","props","t","button","type","aria-label","span","aria-hidden"],"mappings":"AAAA;;;;AAIA,SAASA,IAAI,QAAQ,yBAAyB;AAC9C,SAASC,EAAE,QAAQ,oBAAoB;AAOvC;;;;CAIC,GACD,OAAO,SAASC,aAAa,EAA0C;QAA1C,EAAEC,SAAS,EAA+B,OAA1BC;;;IAC3C,MAAMC,IAAIL;IACV,qBACE,KAACM;QACCC,MAAK;QACLC,cAAYH,EAAE;QACdF,WAAWF,GACT,iIACAE;OAEEC;kBAEJ,cAAA,KAACK;YAAKC,eAAY;sBAAO;;;AAG/B"}

package/dist/ui/atoms/alert/alert.d.ts

@@ -0,0 +1,24 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+import { type Tone } from './tone.js';
+export type { Tone as AlertTone } from './tone.js';
+export interface AlertProps extends Omit<ComponentPropsWithoutRef<'div'>, 'title' | 'role'> {
+    tone: Tone;
+    /** A short heading in bold before the message. */
+    title?: ReactNode;
+    /** What to do about it: a link, a retry button, an {@link AlertDismiss}. */
+    action?: ReactNode;
+}
+/**
+ * An inline message: something went wrong, needs attention, worked, or is
+ * worth knowing. It stays until the page changes; nothing dismisses it unless
+ * the caller passes an {@link AlertDismiss} as its `action`.
+ *
+ * `danger` is announced at once (`role="alert"`, assertive); every other tone
+ * waits its turn (`role="status"`, polite). Never both, and never neither: an
+ * inline message a screen reader is not told about is one only sighted users
+ * receive. Server-safe — no hooks, no client boundary.
+ */
+export declare function Alert({ tone, title, action, className, children, ...props }: AlertProps): import("react").JSX.Element;
+/** The same message under the name some hosts look for. */
+export declare const InlineMessage: typeof Alert;
+//# sourceMappingURL=alert.d.ts.map

package/dist/ui/atoms/alert/alert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alert.d.ts","sourceRoot":"","sources":["../../../../src/ui/atoms/alert/alert.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGjE,OAAO,EAAE,KAAK,IAAI,EAAgB,MAAM,WAAW,CAAC;AAEpD,YAAY,EAAE,IAAI,IAAI,SAAS,EAAE,MAAM,WAAW,CAAC;AAEnD,MAAM,WAAW,UAAW,SAAQ,IAAI,CACtC,wBAAwB,CAAC,KAAK,CAAC,EAC/B,OAAO,GAAG,MAAM,CACjB;IACC,IAAI,EAAE,IAAI,CAAC;IACX,kDAAkD;IAClD,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,4EAA4E;IAC5E,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,EACpB,IAAI,EACJ,KAAK,EACL,MAAM,EACN,SAAS,EACT,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,UAAU,+BAmBZ;AAED,2DAA2D;AAC3D,eAAO,MAAM,aAAa,cAAQ,CAAC"}

package/dist/ui/atoms/alert/alert.js

@@ -0,0 +1,50 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from '../../utils/cn.js';
+import { TONE_SURFACE } from './tone.js';
+/**
+ * An inline message: something went wrong, needs attention, worked, or is
+ * worth knowing. It stays until the page changes; nothing dismisses it unless
+ * the caller passes an {@link AlertDismiss} as its `action`.
+ *
+ * `danger` is announced at once (`role="alert"`, assertive); every other tone
+ * waits its turn (`role="status"`, polite). Never both, and never neither: an
+ * inline message a screen reader is not told about is one only sighted users
+ * receive. Server-safe — no hooks, no client boundary.
+ */ export function Alert(_0) {
+    let { tone, title, action, className, children } = _0, props = _object_without_properties_loose(_0, [
+        "tone",
+        "title",
+        "action",
+        "className",
+        "children"
+    ]);
+    return /*#__PURE__*/ _jsxs("div", _extends({
+        role: tone === 'danger' ? 'alert' : 'status',
+        "data-tone": tone,
+        className: cn('flex items-start gap-s rounded-lg border-l-4 px-s py-xs text-step-sm', TONE_SURFACE[tone], className)
+    }, props, {
+        children: [
+            /*#__PURE__*/ _jsxs("div", {
+                className: "min-w-0 flex flex-1 flex-col gap-3xs",
+                children: [
+                    title !== undefined && /*#__PURE__*/ _jsx("p", {
+                        className: "m-0 font-semibold",
+                        children: title
+                    }),
+                    /*#__PURE__*/ _jsx("div", {
+                        children: children
+                    })
+                ]
+            }),
+            action !== undefined && /*#__PURE__*/ _jsx("div", {
+                className: "shrink-0",
+                children: action
+            })
+        ]
+    }));
+}
+/** The same message under the name some hosts look for. */ export const InlineMessage = Alert;
+
+//# sourceMappingURL=alert.js.map

package/dist/ui/atoms/alert/alert.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/atoms/alert/alert.tsx"],"sourcesContent":["import type { ComponentPropsWithoutRef, ReactNode } from 'react';\n\nimport { cn } from '../../utils/cn.js';\nimport { type Tone, TONE_SURFACE } from './tone.js';\n\nexport type { Tone as AlertTone } from './tone.js';\n\nexport interface AlertProps extends Omit<\n  ComponentPropsWithoutRef<'div'>,\n  'title' | 'role'\n> {\n  tone: Tone;\n  /** A short heading in bold before the message. */\n  title?: ReactNode;\n  /** What to do about it: a link, a retry button, an {@link AlertDismiss}. */\n  action?: ReactNode;\n}\n\n/**\n * An inline message: something went wrong, needs attention, worked, or is\n * worth knowing. It stays until the page changes; nothing dismisses it unless\n * the caller passes an {@link AlertDismiss} as its `action`.\n *\n * `danger` is announced at once (`role=\"alert\"`, assertive); every other tone\n * waits its turn (`role=\"status\"`, polite). Never both, and never neither: an\n * inline message a screen reader is not told about is one only sighted users\n * receive. Server-safe — no hooks, no client boundary.\n */\nexport function Alert({\n  tone,\n  title,\n  action,\n  className,\n  children,\n  ...props\n}: AlertProps) {\n  return (\n    <div\n      role={tone === 'danger' ? 'alert' : 'status'}\n      data-tone={tone}\n      className={cn(\n        'flex items-start gap-s rounded-lg border-l-4 px-s py-xs text-step-sm',\n        TONE_SURFACE[tone],\n        className,\n      )}\n      {...props}\n    >\n      <div className=\"min-w-0 flex flex-1 flex-col gap-3xs\">\n        {title !== undefined && <p className=\"m-0 font-semibold\">{title}</p>}\n        <div>{children}</div>\n      </div>\n      {action !== undefined && <div className=\"shrink-0\">{action}</div>}\n    </div>\n  );\n}\n\n/** The same message under the name some hosts look for. */\nexport const InlineMessage = Alert;\n"],"names":["cn","TONE_SURFACE","Alert","tone","title","action","className","children","props","div","role","data-tone","undefined","p","InlineMessage"],"mappings":";;;AAEA,SAASA,EAAE,QAAQ,oBAAoB;AACvC,SAAoBC,YAAY,QAAQ,YAAY;AAepD;;;;;;;;;CASC,GACD,OAAO,SAASC,MAAM,EAOT;QAPS,EACpBC,IAAI,EACJC,KAAK,EACLC,MAAM,EACNC,SAAS,EACTC,QAAQ,EAEG,OADRC;;;;;;;IAEH,qBACE,MAACC;QACCC,MAAMP,SAAS,WAAW,UAAU;QACpCQ,aAAWR;QACXG,WAAWN,GACT,wEACAC,YAAY,CAACE,KAAK,EAClBG;OAEEE;;0BAEJ,MAACC;gBAAIH,WAAU;;oBACZF,UAAUQ,2BAAa,KAACC;wBAAEP,WAAU;kCAAqBF;;kCAC1D,KAACK;kCAAKF;;;;YAEPF,WAAWO,2BAAa,KAACH;gBAAIH,WAAU;0BAAYD;;;;AAG1D;AAEA,yDAAyD,GACzD,OAAO,MAAMS,gBAAgBZ,MAAM"}

package/dist/ui/atoms/alert/index.d.ts

@@ -0,0 +1,3 @@
+export * from './alert.js';
+export * from './alert-dismiss.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ui/atoms/alert/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ui/atoms/alert/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC"}

package/dist/ui/atoms/alert/index.js

@@ -0,0 +1,4 @@
+export * from './alert.js';
+export * from './alert-dismiss.js';
+
+//# sourceMappingURL=index.js.map

package/dist/ui/atoms/alert/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/atoms/alert/index.ts"],"sourcesContent":["export * from './alert.js';\nexport * from './alert-dismiss.js';\n"],"names":[],"mappings":"AAAA,cAAc,aAAa;AAC3B,cAAc,qBAAqB"}

package/dist/ui/atoms/alert/tone.d.ts

@@ -0,0 +1,8 @@
+/** The four message tones of the token contract (ADR 0025). */
+export type Tone = 'danger' | 'warning' | 'success' | 'info';
+/**
+ * Each tone's text on its own `-subtle` surface: a pair the contract holds to
+ * 4.5:1 in every palette, so nothing here needs a contrast of its own.
+ */
+export declare const TONE_SURFACE: Record<Tone, string>;
+//# sourceMappingURL=tone.d.ts.map

package/dist/ui/atoms/alert/tone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tone.d.ts","sourceRoot":"","sources":["../../../../src/ui/atoms/alert/tone.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,MAAM,MAAM,IAAI,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAK7C,CAAC"}

package/dist/ui/atoms/alert/tone.js

@@ -0,0 +1,11 @@
+/** The four message tones of the token contract (ADR 0025). */ /**
+ * Each tone's text on its own `-subtle` surface: a pair the contract holds to
+ * 4.5:1 in every palette, so nothing here needs a contrast of its own.
+ */ export const TONE_SURFACE = {
+    danger: 'border-danger bg-danger-subtle text-danger',
+    warning: 'border-warning bg-warning-subtle text-warning',
+    success: 'border-success bg-success-subtle text-success',
+    info: 'border-info bg-info-subtle text-info'
+};
+
+//# sourceMappingURL=tone.js.map

package/dist/ui/atoms/alert/tone.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/atoms/alert/tone.ts"],"sourcesContent":["/** The four message tones of the token contract (ADR 0025). */\nexport type Tone = 'danger' | 'warning' | 'success' | 'info';\n\n/**\n * Each tone's text on its own `-subtle` surface: a pair the contract holds to\n * 4.5:1 in every palette, so nothing here needs a contrast of its own.\n */\nexport const TONE_SURFACE: Record<Tone, string> = {\n  danger: 'border-danger bg-danger-subtle text-danger',\n  warning: 'border-warning bg-warning-subtle text-warning',\n  success: 'border-success bg-success-subtle text-success',\n  info: 'border-info bg-info-subtle text-info',\n};\n"],"names":["TONE_SURFACE","danger","warning","success","info"],"mappings":"AAAA,6DAA6D,GAG7D;;;CAGC,GACD,OAAO,MAAMA,eAAqC;IAChDC,QAAQ;IACRC,SAAS;IACTC,SAAS;IACTC,MAAM;AACR,EAAE"}

package/dist/ui/atoms/button/button-recipe.js

@@ -9,7 +9,7 @@ import { cva } from 'class-variance-authority';
  * constraint, so a link-shaped variant (`ButtonLink`) can wear the same clothes
  * and still render entirely on the server.
  */ export const button = cva([
-    'inline-flex items-center justify-center rounded-lg font-medium',
+    'inline-flex min-h-(--target-min) min-w-(--target-min) items-center justify-center rounded-lg font-medium',
     'transition duration-200 ease-smooth active:scale-[0.97]',
     'focus-ring',
     'disabled:cursor-not-allowed disabled:opacity-50 disabled:shadow-none disabled:active:scale-100'

package/dist/ui/atoms/button/button-recipe.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/ui/atoms/button/button-recipe.ts"],"sourcesContent":["import { cva, type VariantProps } from 'class-variance-authority';\n\n/**\n * The button's visual recipe, kept in its own module so it can be shared with\n * components that must **not** be client ones.\n *\n * `Button` is `'use client'` for a single reason — it renders HeadlessUI's\n * `Button` — and a server page that puts one inside every card in a grid pays a\n * client boundary per card. `cva` and the token classes have no such\n * constraint, so a link-shaped variant (`ButtonLink`) can wear the same clothes\n * and still render entirely on the server.\n */\nexport const button = cva(\n  [\n    'inline-flex items-center justify-center rounded-lg font-medium',\n    'transition duration-200 ease-smooth active:scale-[0.97]',\n    'focus-ring',\n    'disabled:cursor-not-allowed disabled:opacity-50 disabled:shadow-none disabled:active:scale-100',\n  ],\n  {\n    variants: {\n      variant: {\n        primary:\n          'bg-primary text-primary-content shadow-raised hover:opacity-90 hover:shadow-card',\n        secondary:\n          'border border-border bg-surface-elevated text-content shadow-edge hover:border-primary hover:shadow-raised',\n        ghost: 'bg-transparent text-content hover:bg-surface-elevated',\n        // For an act that destroys something — ending every session a user\n        // holds, deleting a record. The `--color-danger*` tokens already\n        // existed and were being reached for as raw classes at call sites; this\n        // only gives them a name, so a destructive action looks the same\n        // wherever it appears rather than depending on who wrote the screen.\n        destructive:\n          'bg-danger text-danger-content shadow-raised hover:opacity-90 hover:shadow-card',\n      },\n      // Padding uses the fluid spacing tokens so buttons scale with the viewport.\n      size: {\n        sm: 'px-xs py-3xs text-step-0',\n        md: 'px-s py-2xs text-step-0',\n        lg: 'px-m py-xs text-step-1',\n      },\n    },\n    defaultVariants: {\n      variant: 'primary',\n      size: 'md',\n    },\n  },\n);\n\nexport type ButtonVariant = NonNullable<VariantProps<typeof button>['variant']>;\nexport type ButtonSize = NonNullable<VariantProps<typeof button>['size']>;\nexport type ButtonVariantProps = VariantProps<typeof button>;\n"],"names":["cva","button","variants","variant","primary","secondary","ghost","destructive","size","sm","md","lg","defaultVariants"],"mappings":"AAAA,SAASA,GAAG,QAA2B,2BAA2B;AAElE;;;;;;;;;CASC,GACD,OAAO,MAAMC,SAASD,IACpB;IACE;IACA;IACA;IACA;CACD,EACD;IACEE,UAAU;QACRC,SAAS;YACPC,SACE;YACFC,WACE;YACFC,OAAO;YACP,mEAAmE;YACnE,iEAAiE;YACjE,wEAAwE;YACxE,iEAAiE;YACjE,qEAAqE;YACrEC,aACE;QACJ;QACA,4EAA4E;QAC5EC,MAAM;YACJC,IAAI;YACJC,IAAI;YACJC,IAAI;QACN;IACF;IACAC,iBAAiB;QACfT,SAAS;QACTK,MAAM;IACR;AACF,GACA"}
+{"version":3,"sources":["../../../../src/ui/atoms/button/button-recipe.ts"],"sourcesContent":["import { cva, type VariantProps } from 'class-variance-authority';\n\n/**\n * The button's visual recipe, kept in its own module so it can be shared with\n * components that must **not** be client ones.\n *\n * `Button` is `'use client'` for a single reason — it renders HeadlessUI's\n * `Button` — and a server page that puts one inside every card in a grid pays a\n * client boundary per card. `cva` and the token classes have no such\n * constraint, so a link-shaped variant (`ButtonLink`) can wear the same clothes\n * and still render entirely on the server.\n */\nexport const button = cva(\n  [\n    'inline-flex min-h-(--target-min) min-w-(--target-min) items-center justify-center rounded-lg font-medium',\n    'transition duration-200 ease-smooth active:scale-[0.97]',\n    'focus-ring',\n    'disabled:cursor-not-allowed disabled:opacity-50 disabled:shadow-none disabled:active:scale-100',\n  ],\n  {\n    variants: {\n      variant: {\n        primary:\n          'bg-primary text-primary-content shadow-raised hover:opacity-90 hover:shadow-card',\n        secondary:\n          'border border-border bg-surface-elevated text-content shadow-edge hover:border-primary hover:shadow-raised',\n        ghost: 'bg-transparent text-content hover:bg-surface-elevated',\n        // For an act that destroys something — ending every session a user\n        // holds, deleting a record. The `--color-danger*` tokens already\n        // existed and were being reached for as raw classes at call sites; this\n        // only gives them a name, so a destructive action looks the same\n        // wherever it appears rather than depending on who wrote the screen.\n        destructive:\n          'bg-danger text-danger-content shadow-raised hover:opacity-90 hover:shadow-card',\n      },\n      // Padding uses the fluid spacing tokens so buttons scale with the viewport.\n      size: {\n        sm: 'px-xs py-3xs text-step-0',\n        md: 'px-s py-2xs text-step-0',\n        lg: 'px-m py-xs text-step-1',\n      },\n    },\n    defaultVariants: {\n      variant: 'primary',\n      size: 'md',\n    },\n  },\n);\n\nexport type ButtonVariant = NonNullable<VariantProps<typeof button>['variant']>;\nexport type ButtonSize = NonNullable<VariantProps<typeof button>['size']>;\nexport type ButtonVariantProps = VariantProps<typeof button>;\n"],"names":["cva","button","variants","variant","primary","secondary","ghost","destructive","size","sm","md","lg","defaultVariants"],"mappings":"AAAA,SAASA,GAAG,QAA2B,2BAA2B;AAElE;;;;;;;;;CASC,GACD,OAAO,MAAMC,SAASD,IACpB;IACE;IACA;IACA;IACA;CACD,EACD;IACEE,UAAU;QACRC,SAAS;YACPC,SACE;YACFC,WACE;YACFC,OAAO;YACP,mEAAmE;YACnE,iEAAiE;YACjE,wEAAwE;YACxE,iEAAiE;YACjE,qEAAqE;YACrEC,aACE;QACJ;QACA,4EAA4E;QAC5EC,MAAM;YACJC,IAAI;YACJC,IAAI;YACJC,IAAI;QACN;IACF;IACAC,iBAAiB;QACfT,SAAS;QACTK,MAAM;IACR;AACF,GACA"}

package/dist/ui/atoms/button/index.d.ts

@@ -1,4 +1,5 @@
 export * from './button.js';
 export * from './button-link.js';
 export * from './button-recipe.js';
+export * from './submit-button.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/ui/atoms/button/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ui/atoms/button/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ui/atoms/button/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC"}

package/dist/ui/atoms/button/index.js

@@ -1,5 +1,6 @@
 export * from './button.js';
 export * from './button-link.js';
 export * from './button-recipe.js';
+export * from './submit-button.js';
 
 //# sourceMappingURL=index.js.map

package/dist/ui/atoms/button/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/ui/atoms/button/index.ts"],"sourcesContent":["export * from './button.js';\nexport * from './button-link.js';\nexport * from './button-recipe.js';\n"],"names":[],"mappings":"AAAA,cAAc,cAAc;AAC5B,cAAc,mBAAmB;AACjC,cAAc,qBAAqB"}
+{"version":3,"sources":["../../../../src/ui/atoms/button/index.ts"],"sourcesContent":["export * from './button.js';\nexport * from './button-link.js';\nexport * from './button-recipe.js';\nexport * from './submit-button.js';\n"],"names":[],"mappings":"AAAA,cAAc,cAAc;AAC5B,cAAc,mBAAmB;AACjC,cAAc,qBAAqB;AACnC,cAAc,qBAAqB"}