@wow-two-beta/ui-vue 0.0.5 → 0.0.6

package/dist/foundation/primitives/focusScope/FocusScope.vue.d.ts

@@ -1,22 +1,24 @@
-import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 export interface FocusScopeProps {
-    /** Wrap Tab / Shift+Tab at the scope's edges. Default false. */
-    loop?: boolean;
-    /** Keep focus inside the scope — focus that escapes is pulled back. Default false. */
-    trapped?: boolean;
-    /** Fires before the scope auto-focuses on mount; `preventDefault()` to keep focus where it is. */
-    onMountAutoFocus?: (event: CustomEvent) => void;
-    /** Fires before focus is restored on unmount; `preventDefault()` to keep focus where it is. */
-    onUnmountAutoFocus?: (event: CustomEvent) => void;
+    /** Wrap Tab and Shift+Tab at the scope edges. Default false. */
+    readonly loop?: boolean;
+    /** Recover focus when it leaves this scope and its logical portal descendants. */
+    readonly trapped?: boolean;
+    /** Make background content inert while this modal scope is mounted. Default false. */
+    readonly modal?: boolean;
+    /** Cancel the initial focus move with preventDefault(). */
+    readonly onMountAutoFocus?: (event: CustomEvent) => void;
+    /** Cancel restoration to the opening control with preventDefault(). */
+    readonly onUnmountAutoFocus?: (event: CustomEvent) => void;
     /** Merge into the single slot child instead of rendering a wrapper div. */
-    asChild?: boolean;
+    readonly asChild?: boolean;
 }
-declare const _default: __VLS_WithSlots< DefineComponent<FocusScopeProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<FocusScopeProps> & Readonly<{}>, {
-    asChild: boolean;
-    loop: boolean;
-    trapped: boolean;
-}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
-    default?: (props: {}) => any;
+declare const _default: __VLS_WithSlots<import('vue').DefineComponent<FocusScopeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<FocusScopeProps> & Readonly<{}>, {
+    readonly asChild: boolean;
+    readonly loop: boolean;
+    readonly trapped: boolean;
+    readonly modal: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default(): unknown;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/foundation/primitives/focusScope/FocusScopeRegistry.d.ts

@@ -0,0 +1,27 @@
+import { InjectionKey } from 'vue';
+/** A scope's logical ownership survives Vue Teleport. */
+export interface FocusScopeEntry {
+    readonly parent: FocusScopeEntry | null;
+    readonly node: () => HTMLElement | null;
+    readonly trapped: () => boolean;
+    readonly modal: () => boolean;
+    readonly recover: () => void;
+    readonly onKeydown: (event: KeyboardEvent) => void;
+    readonly captureReturnFocus: (document: Document) => void;
+}
+/** Carries logical focus ancestry across portalled descendants. */
+export declare const FocusScopeKey: InjectionKey<FocusScopeEntry>;
+/** Checks logical ancestry, including scopes whose DOM lives in another portal. */
+export declare function isScopeDescendant(entry: FocusScopeEntry, ancestor: FocusScopeEntry): boolean;
+/** Returns every mounted DOM branch owned by the scope. */
+export declare function scopeContainers(entry: FocusScopeEntry): HTMLElement[];
+/** Checks whether a DOM node belongs to the scope or a logical portal branch. */
+export declare function scopeContains(entry: FocusScopeEntry, target: Node | null): boolean;
+/** Returns the currently active focus trap for this document. */
+export declare function topFocusScope(document: Document): FocusScopeEntry | undefined;
+/** Registers a mounted scope with one document's trap and modal-background lifecycle. */
+export declare function registerFocusScope(entry: FocusScopeEntry): () => void;
+/** Refreshes modal attributes after reactive trap/modal options change. */
+export declare function refreshFocusScope(entry: FocusScopeEntry): void;
+/** Whether this scope still owns a mounted registry entry. */
+export declare function isFocusScopeRegistered(entry: FocusScopeEntry): boolean;

package/dist/foundation/primitives/formControlContext/FormControlContext.d.ts

@@ -1,6 +1,15 @@
 import { InjectionKey, MaybeRefOrGetter } from 'vue';
 /** The chrome slots a form control can be described/named by. */
-export type FormControlChromeKind = 'label' | 'helper' | 'error';
+export declare const FormControlChromeKind: {
+    /** Names the control — its rendered id joins `aria-labelledby`. */
+    readonly Label: "label";
+    /** Describes the control in the resting case — its id joins `aria-describedby`. */
+    readonly Helper: "helper";
+    /** Describes the control's validation failure — its id joins `aria-describedby` and wins over the helper. */
+    readonly Error: "error";
+};
+/** The chrome slots a form control can be described/named by. */
+export type FormControlChromeKind = (typeof FormControlChromeKind)[keyof typeof FormControlChromeKind];
 export interface FormControlContextValue {
     readonly id: string;
     readonly labelId: string;
@@ -24,12 +33,12 @@ export interface FormControlContextValue {
      * forms-engine `Field` glue so error chrome (`FormErrorMessage`) renders them
      * without hand-wiring. `undefined` outside an engine-driven field.
      */
-    readonly errors?: readonly string[];
+    readonly errors?: ReadonlyArray<string>;
     readonly isInvalid: boolean;
     readonly isDisabled: boolean;
     readonly isRequired: boolean;
     readonly isReadOnly: boolean;
-    /** Registers a mounted chrome node (label/helper/error); returns the unregister. Chrome uses {@link useFormControlChrome}. */
+    /** Registers a chrome node (label/helper/error); returns the unregister. Called by {@link useFormControlChrome}. */
     registerChrome: (kind: FormControlChromeKind) => () => void;
 }
 export declare const FormControlKey: InjectionKey<FormControlContextValue>;

package/dist/foundation/primitives/formControlContext/FormControlProvider.vue.d.ts

@@ -1,21 +1,21 @@
-import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 export interface FormControlProviderProps {
     /** The id override for the auto-generated id (also used as control's `id`). */
-    id?: string;
+    readonly id?: string;
     /** The field's error messages — exposed to chrome via context. */
-    errors?: readonly string[];
-    isInvalid?: boolean;
-    isDisabled?: boolean;
-    isRequired?: boolean;
-    isReadOnly?: boolean;
+    readonly errors?: ReadonlyArray<string>;
+    readonly isInvalid?: boolean;
+    readonly isDisabled?: boolean;
+    readonly isRequired?: boolean;
+    readonly isReadOnly?: boolean;
 }
-declare const _default: __VLS_WithSlots< DefineComponent<FormControlProviderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<FormControlProviderProps> & Readonly<{}>, {
-    isInvalid: boolean;
-    isDisabled: boolean;
-    isRequired: boolean;
-    isReadOnly: boolean;
-}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
-    default?: (props: {}) => any;
+declare const _default: __VLS_WithSlots<import('vue').DefineComponent<FormControlProviderProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<FormControlProviderProps> & Readonly<{}>, {
+    readonly isInvalid: boolean;
+    readonly isDisabled: boolean;
+    readonly isRequired: boolean;
+    readonly isReadOnly: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    /** The field subtree — the control plus its label, helper, and error chrome. */
+    default(): unknown;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/foundation/primitives/formControlContext/index.d.ts

@@ -1,2 +1,2 @@
-export { default as FormControlProvider, type FormControlProviderProps, } from './FormControlProvider.vue';
+export { default as FormControlProvider, type FormControlProviderProps } from './FormControlProvider.vue';
 export { useFormControl, useFormControlChrome, FormControlKey, type FormControlChromeKind, type FormControlContextValue, } from './FormControlContext';

package/dist/foundation/primitives/index.js

@@ -1,17 +1,17 @@
 import { _ } from "../../chunks/AnchoredPositioner.vue_vue_type_script_setup_true_lang-BpBVI2Cu.js";
-import { _ as _2, P } from "../../chunks/Announce.vue_vue_type_script_setup_true_lang-CDTltiIl.js";
-import { A, _ as _3, a, b, c, d } from "../../chunks/index-op-kbVUk.js";
-import { a as a2, _ as _4 } from "../../chunks/DismissableLayer.vue_vue_type_script_setup_true_lang-ptH1ttBL.js";
-import { _ as _5 } from "../../chunks/FormControlProvider.vue_vue_type_script_setup_true_lang-Fak7Jv46.js";
+import { _ as _2, P } from "../../chunks/Announce.vue_vue_type_script_setup_true_lang-QM4vCs2n.js";
+import { A, _ as _3, a, b, c, d } from "../../chunks/index-BvFTmSpn.js";
+import { a as a2, _ as _4 } from "../../chunks/DismissableLayer.vue_vue_type_script_setup_true_lang-DElE4ZeQ.js";
+import { _ as _5 } from "../../chunks/FormControlProvider.vue_vue_type_script_setup_true_lang-D_yikT2o.js";
 import { _ as _6 } from "../../chunks/OverlayArrow.vue_vue_type_script_setup_true_lang-CLYhnI8i.js";
-import { _ as _7 } from "../../chunks/Portal.vue_vue_type_script_setup_true_lang-CF3R0VCZ.js";
-import { D, a as a3, O, _ as _8, R, p, u, b as b2 } from "../../chunks/RovingFocusGroup.vue_vue_type_script_setup_true_lang-DCpYSP2V.js";
-import { _ as _9 } from "../../chunks/ScrollLockProvider.vue_vue_type_script_setup_true_lang-_ihHJ7jI.js";
-import { C, a as a4, u as u2 } from "../../chunks/ColorModeContext-Bz6CBL0V.js";
+import { _ as _7 } from "../../chunks/Portal.vue_vue_type_script_setup_true_lang-C2_xSIMy.js";
+import { D, a as a3, O, _ as _8, R, p, u, b as b2 } from "../../chunks/RovingFocusGroup.vue_vue_type_script_setup_true_lang-BGZe5AX4.js";
+import { _ as _9 } from "../../chunks/ScrollLockProvider.vue_vue_type_script_setup_true_lang-DAYt3wgP.js";
+import { C, a as a4, u as u2 } from "../../chunks/ColorModeContext-DC77vyvQ.js";
 import { F, u as u3, a as a5 } from "../../chunks/FormControlContext-B71MFW26.js";
-import { P as P2 } from "../../chunks/Presence-DE4MlrJz.js";
-import { P as P3 } from "../../chunks/Primitive-Cm3ECaVw.js";
-import { S, m, a as a6, r } from "../../chunks/Slot-D2lIitvV.js";
+import { P as P2 } from "../../chunks/Presence-BwBquQOQ.js";
+import { P as P3 } from "../../chunks/Primitive-Bt_MgDir.js";
+import { S, m, a as a6, r } from "../../chunks/Slot-CLT4PkWl.js";
 export {
   A as AccessibleIcon,
   _ as AnchoredPositioner,

package/dist/foundation/primitives/overlayArrow/OverlayArrow.vue.d.ts

@@ -1,18 +1,18 @@
-import { SVGAttributes, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { SVGAttributes } from 'vue';
 export interface OverlayArrowProps extends /* @vue-ignore */ SVGAttributes {
     /** The arrow width in px. Default 12. */
-    width?: number;
+    readonly width?: number;
     /** The arrow height in px. Default 6. */
-    height?: number;
+    readonly height?: number;
 }
-declare const _default: DefineComponent<{
+declare const _default: import('vue').DefineComponent<{
     /** The arrow width in px. Default 12. */
     width?: number;
     /** The arrow height in px. Default 6. */
     height?: number;
     /** The triangle fill. Default `currentColor`. */
     fill?: string;
-}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
     /** The arrow width in px. Default 12. */
     width?: number;
     /** The arrow height in px. Default 6. */
@@ -23,5 +23,5 @@ declare const _default: DefineComponent<{
     fill: string;
     height: number;
     width: number;
-}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/foundation/primitives/portal/Portal.vue.d.ts

@@ -1,12 +1,12 @@
-import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 export interface PortalProps {
     /** The container to render into. Default: `document.body`. */
-    container?: HTMLElement | null;
+    readonly container?: HTMLElement | null;
     /** The optional named layer — sets `data-portal-name` on the wrapper. */
-    name?: string;
+    readonly name?: string;
 }
-declare const _default: __VLS_WithSlots< DefineComponent<PortalProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PortalProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
-    default?: (props: {}) => any;
+declare const _default: __VLS_WithSlots<import('vue').DefineComponent<PortalProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<PortalProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    /** The content teleported into the target container. */
+    default(): unknown;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/foundation/primitives/presence/Presence.d.ts

@@ -1,7 +1,7 @@
-import { VNode, DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { VNode } from 'vue';
 export interface PresenceProps {
     /** The presence flag — toggle false to trigger exit. */
-    isPresent: boolean;
+    readonly isPresent: boolean;
 }
 /**
  * Defer unmount until the child's exit animation/transition finishes.
@@ -23,14 +23,14 @@ export interface PresenceProps {
  * {@link afterTwoFrames}, and the exit additionally arms its unmount timer up front, so a
  * document that is never painted still enters and — the part that matters — still unmounts.
  */
-export declare const Presence: DefineComponent<ExtractPropTypes<{
+export declare const Presence: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     isPresent: {
         type: BooleanConstructor;
         required: true;
     };
-}>, () => VNode | null, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+}>, () => VNode | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     isPresent: {
         type: BooleanConstructor;
         required: true;
     };
-}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/foundation/primitives/rovingFocusGroup/RovingFocusContext.d.ts

@@ -49,7 +49,7 @@ export interface RovingFocusContextValue {
 }
 export declare const RovingFocusKey: InjectionKey<RovingFocusContextValue>;
 export interface UseRovingFocusItemOptions {
-    /** Preferred tab stop while focus is outside the group (e.g. the selected tab) — APG composite-widget pattern. Accepts a ref or getter. */
+    /** Preferred tab stop while focus is outside the group (e.g. the selected tab) — APG composite-widget pattern. */
     isActive?: MaybeRefOrGetter<boolean>;
 }
 export interface UseRovingFocusItemReturn {

package/dist/foundation/primitives/rovingFocusGroup/RovingFocusGroup.vue.d.ts

@@ -1,16 +1,17 @@
 import { Orientation } from './RovingFocusContext';
-import { HTMLAttributes, DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { HTMLAttributes } from 'vue';
 export interface RovingFocusGroupProps extends /* @vue-ignore */ HTMLAttributes {
-    orientation?: Orientation;
-    canLoop?: boolean;
+    readonly orientation?: Orientation;
+    readonly canLoop?: boolean;
 }
-declare const _default: __VLS_WithSlots< DefineComponent<RovingFocusGroupProps, {
-    el: Readonly< ShallowRef<HTMLElement | null>>;
-}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<RovingFocusGroupProps> & Readonly<{}>, {
-    orientation: Orientation;
-    canLoop: boolean;
-}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
-    default?: (props: {}) => any;
+declare const _default: __VLS_WithSlots<import('vue').DefineComponent<RovingFocusGroupProps, {
+    el: Readonly<import('vue').ShallowRef<HTMLElement | null>>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<RovingFocusGroupProps> & Readonly<{}>, {
+    readonly orientation: Orientation;
+    readonly canLoop: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    /** The focusable children that register as arrow-key stops. */
+    default(): unknown;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/foundation/primitives/scrollLockProvider/ScrollLockProvider.vue.d.ts

@@ -1,11 +1,11 @@
-import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 export interface ScrollLockProviderProps {
-    isEnabled?: boolean;
+    readonly isEnabled?: boolean;
 }
-declare const _default: __VLS_WithSlots< DefineComponent<ScrollLockProviderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ScrollLockProviderProps> & Readonly<{}>, {
-    isEnabled: boolean;
-}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
-    default?: (props: {}) => any;
+declare const _default: __VLS_WithSlots<import('vue').DefineComponent<ScrollLockProviderProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ScrollLockProviderProps> & Readonly<{}>, {
+    readonly isEnabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    /** The content whose mount lifetime holds the scroll lock. */
+    default(): unknown;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/foundation/primitives/scrollLockProvider/index.d.ts

@@ -1 +1 @@
-export { default as ScrollLockProvider, type ScrollLockProviderProps, } from './ScrollLockProvider.vue';
+export { default as ScrollLockProvider, type ScrollLockProviderProps } from './ScrollLockProvider.vue';

package/dist/foundation/primitives/scrollViewport/ScrollViewport.vue.d.ts

@@ -1,37 +1,38 @@
-import { HTMLAttributes, DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { HTMLAttributes } from 'vue';
 export interface ScrollViewportProps extends /* @vue-ignore */ HTMLAttributes {
     /**
      * The fixed viewport height. Number → pixels; string → any CSS length
      * (`'20rem'`, `'50vh'`). Content beyond this scrolls; the box does not grow.
      * Omit to let the container size to its context (still clips + scrolls via `maxHeight`).
      */
-    height?: number | string;
+    readonly height?: number | string;
     /**
      * The height ceiling — grows with content up to this cap without pinning it,
      * then scrolls. Number → pixels; string → any CSS length.
      */
-    maxHeight?: number | string;
+    readonly maxHeight?: number | string;
     /**
      * The height/opacity transition flag (a content swap, an expand). Respects
      * `prefers-reduced-motion` — the transition is dropped when the user opts out.
      * @default false
      */
-    animate?: boolean;
+    readonly animate?: boolean;
 }
-declare const _default: __VLS_WithSlots< DefineComponent<{
+declare const _default: __VLS_WithSlots<import('vue').DefineComponent<{
     height?: number | string;
     maxHeight?: number | string;
     animate?: boolean;
 }, {
-    el: Readonly< ShallowRef<HTMLDivElement | null>>;
-}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
+    el: Readonly<import('vue').ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
     height?: number | string;
     maxHeight?: number | string;
     animate?: boolean;
 }> & Readonly<{}>, {
     animate: boolean;
-}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
-    default?: (props: {}) => any;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    /** The scrollable content inside the viewport. */
+    default(): unknown;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/foundation/primitives/slot/ComponentElement.d.ts

@@ -0,0 +1,7 @@
+/** Defines the element handle of a single-element component root. */
+export interface ComponentElement {
+    /** The mounted root element exposed by Vue. */
+    readonly $el: HTMLElement;
+    /** The component's explicit root ref, unwrapped by Vue. */
+    readonly el: HTMLElement | null;
+}

package/dist/foundation/primitives/slot/Primitive.d.ts

@@ -1,14 +1,14 @@
-import { PropType, DefineComponent, ExtractPropTypes, VNode, RendererNode, RendererElement, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
-import { ElementType } from '../../utils/polymorphic';
+import { PropType } from 'vue';
+import { ElementType } from '../../dom/Polymorphic';
 export interface PrimitiveProps {
     /** The element or component to render. Default `'div'`. Ignored when `asChild`. */
-    as?: ElementType;
+    readonly as?: ElementType;
     /**
      * The merge flag — render the single slot child instead of `as`, with this
      * component's attrs merged into it (class concatenated, handlers chained,
      * child props winning). The Vue counterpart of React's `asChild` + `Slot`.
      */
-    asChild?: boolean;
+    readonly asChild?: boolean;
 }
 /**
  * The base element every headless primitive renders through — a polymorphic
@@ -43,7 +43,7 @@ export interface PrimitiveProps {
  * counterpart — the merged element *is* the root, so a parent's template ref
  * resolves to it through `$el`.
  */
-export declare const Primitive: DefineComponent<ExtractPropTypes<{
+export declare const Primitive: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     as: {
         type: PropType<ElementType>;
         default: string;
@@ -52,9 +52,9 @@ export declare const Primitive: DefineComponent<ExtractPropTypes<{
         type: BooleanConstructor;
         default: boolean;
     };
-}>, () => VNode<RendererNode, RendererElement, {
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
     [key: string]: any;
-}> | null, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+}> | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     as: {
         type: PropType<ElementType>;
         default: string;
@@ -66,4 +66,4 @@ export declare const Primitive: DefineComponent<ExtractPropTypes<{
 }>> & Readonly<{}>, {
     as: ElementType;
     asChild: boolean;
-}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/foundation/primitives/slot/Slot.d.ts

@@ -1,4 +1,4 @@
-import { Slots, VNode, VNodeArrayChildren, DefineComponent, RendererNode, RendererElement, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { Slots, VNode, VNodeArrayChildren } from 'vue';
 export type AnyProps = Record<string, unknown>;
 /**
  * Merge the slot's own props into the child element's props. Port of the React
@@ -27,9 +27,9 @@ export type SlottableProps = Record<string, never>;
  * around it — the surrounding children then compose *inside* the cloned target,
  * so the single-child `Slot` contract is never violated.
  */
-export declare const Slottable: DefineComponent<{}, () => VNode< RendererNode, RendererElement, {
+export declare const Slottable: import('vue').DefineComponent<{}, () => VNode<import('vue').RendererNode, import('vue').RendererElement, {
     [key: string]: any;
-}>[] | null, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+}>[] | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 /**
  * The single-child merge shared by `Slot` and `Primitive`'s `asChild` branch.
  * Resolves the merge target (honouring `<Slottable>`), merges `slotProps` into

package/dist/foundation/primitives/slot/index.d.ts

@@ -1,2 +1,3 @@
 export { Primitive, type PrimitiveProps } from './Primitive';
-export { Slottable, mergeProps, renderSlotClone, renderableChildren, type SlottableProps, type AnyProps, } from './Slot';
+export type { ComponentElement } from './ComponentElement';
+export { Slottable, mergeProps, renderSlotClone, renderableChildren, type SlottableProps, type AnyProps } from './Slot';

package/dist/foundation/primitives/visuallyHidden/VisuallyHidden.vue.d.ts

@@ -1,7 +1,8 @@
-import { HTMLAttributes, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { HTMLAttributes } from 'vue';
 export type VisuallyHiddenProps = HTMLAttributes;
-declare const _default: __VLS_WithSlots< DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
-    default?: (props: {}) => any;
+declare const _default: __VLS_WithSlots<import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>, {
+    /** The content announced to screen readers but hidden from view. */
+    default(): unknown;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/foundation/resilience/RetryDelay.d.ts

@@ -1,5 +1,8 @@
 import { RetryPolicy } from './RetryPolicy';
-/** Computes the delay (ms) to wait before a retry attempt (1-based), per the policy's backoff + jitter — `random` is injectable for deterministic tests. */
+/**
+ * Computes the delay (ms) to wait before a retry attempt (1-based), per the policy's backoff + jitter.
+ * `random` is injectable for deterministic tests.
+ */
 export declare function computeRetryDelay(policy: RetryPolicy, attempt: number, previousDelayMs?: number, random?: () => number): number;
 /** Decides whether a failed attempt should retry — within `maxRetries` and the status is transient per the policy. */
 export declare function shouldRetry(policy: RetryPolicy, failureCount: number, status: number): boolean;

package/dist/foundation/resilience/RetryPolicy.d.ts

@@ -1,7 +1,7 @@
-import { BackoffStrategy } from './BackoffStrategy';
-import { JitterStrategy } from './JitterStrategy';
+import { BackoffStrategy } from './enums/BackoffStrategy';
+import { JitterStrategy } from './enums/JitterStrategy';
 /** Provides the HTTP statuses treated as transient by default — network (`0`) plus the standard transient set. */
-export declare const DefaultTransientStatuses: readonly number[];
+export declare const DefaultTransientStatuses: ReadonlyArray<number>;
 /** Defines the context passed to a retry's `onRetry` hook. */
 export interface RetryContext {
     /** The upcoming attempt number (1-based). */
@@ -13,7 +13,7 @@ export interface RetryContext {
     /** The delay (ms) waited before this attempt. */
     readonly delayMs: number;
 }
-/** Defines a retry policy — how many times, how the delay backs off, whether to jitter, and which failures are transient. */
+/** Defines a retry policy — attempt count, backoff growth, jitter, and which failures count as transient. */
 export interface RetryPolicy {
     /** The max retry attempts after the first failure. */
     readonly maxRetries: number;
@@ -26,9 +26,9 @@ export interface RetryPolicy {
     /** The jitter applied to each computed delay. Default `JitterStrategy.None`. */
     readonly jitter?: JitterStrategy;
     /** The HTTP statuses treated as transient (retryable). Default `DefaultTransientStatuses`. */
-    readonly retryableStatuses?: readonly number[];
+    readonly retryableStatuses?: ReadonlyArray<number>;
     /** Fires before each retry — logging / metrics. */
     readonly onRetry?: (context: RetryContext) => void;
 }
-/** Provides the default retry policy — 2 exponential retries with full jitter (base 1s, cap 30s) over the transient statuses. */
+/** Provides the default retry policy — 2 exponential retries, full jitter, base 1s, cap 30s, transient statuses. */
 export declare const DefaultRetryPolicy: RetryPolicy;

package/dist/foundation/resilience/index.d.ts

@@ -1,4 +1,4 @@
-export { BackoffStrategy } from './BackoffStrategy';
-export { JitterStrategy } from './JitterStrategy';
+export { BackoffStrategy } from './enums/BackoffStrategy';
+export { JitterStrategy } from './enums/JitterStrategy';
 export { DefaultTransientStatuses, DefaultRetryPolicy, type RetryPolicy, type RetryContext } from './RetryPolicy';
 export { computeRetryDelay, shouldRetry } from './RetryDelay';

package/dist/foundation/resilience/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../src/foundation/resilience/BackoffStrategy.ts","../../../src/foundation/resilience/JitterStrategy.ts","../../../src/foundation/resilience/RetryPolicy.ts","../../../src/foundation/resilience/RetryDelay.ts"],"sourcesContent":["/** Defines how the delay between retries grows across attempts. */\nexport const BackoffStrategy = {\n  /** Refers to a fixed delay before every retry. */\n  Constant: 'constant',\n  /** Refers to a delay that grows linearly with the attempt (base × attempt). */\n  Linear: 'linear',\n  /** Refers to a delay that doubles each attempt (base × 2^(attempt − 1)). */\n  Exponential: 'exponential',\n} as const;\n\nexport type BackoffStrategy = (typeof BackoffStrategy)[keyof typeof BackoffStrategy];\n","/** Defines how jitter randomizes a computed retry delay — spreading retries to avoid a thundering herd. */\nexport const JitterStrategy = {\n  /** Refers to no jitter — the exact computed delay. */\n  None: 'none',\n  /** Refers to full jitter — a uniform random value in `[0, delay]`. */\n  Full: 'full',\n  /** Refers to equal jitter — `delay/2 + random[0, delay/2]`. */\n  Equal: 'equal',\n  /** Refers to decorrelated jitter (AWS / Polly) — random growth off the previous delay. */\n  Decorrelated: 'decorrelated',\n} as const;\n\nexport type JitterStrategy = (typeof JitterStrategy)[keyof typeof JitterStrategy];\n","import { BackoffStrategy } from './BackoffStrategy';\nimport { JitterStrategy } from './JitterStrategy';\n\n/** Provides the HTTP statuses treated as transient by default — network (`0`) plus the standard transient set. */\nexport const DefaultTransientStatuses: readonly number[] = [0, 408, 429, 500, 502, 503, 504];\n\n/** Defines the context passed to a retry's `onRetry` hook. */\nexport interface RetryContext {\n  /** The upcoming attempt number (1-based). */\n  readonly attempt: number;\n\n  /** The error that triggered the retry. */\n  readonly error: unknown;\n\n  /** The coerced HTTP status (`0` = network / unknown). */\n  readonly status: number;\n\n  /** The delay (ms) waited before this attempt. */\n  readonly delayMs: number;\n}\n\n/** Defines a retry policy — how many times, how the delay backs off, whether to jitter, and which failures are transient. */\nexport interface RetryPolicy {\n  /** The max retry attempts after the first failure. */\n  readonly maxRetries: number;\n\n  /** The backoff growth across attempts. */\n  readonly backoff: BackoffStrategy;\n\n  /** The base delay (ms) — the first backoff step. */\n  readonly baseDelayMs: number;\n\n  /** The delay cap (ms); omit for uncapped. */\n  readonly maxDelayMs?: number;\n\n  /** The jitter applied to each computed delay. Default `JitterStrategy.None`. */\n  readonly jitter?: JitterStrategy;\n\n  /** The HTTP statuses treated as transient (retryable). Default `DefaultTransientStatuses`. */\n  readonly retryableStatuses?: readonly number[];\n\n  /** Fires before each retry — logging / metrics. */\n  readonly onRetry?: (context: RetryContext) => void;\n}\n\n/** Provides the default retry policy — 2 exponential retries with full jitter (base 1s, cap 30s) over the transient statuses. */\nexport const DefaultRetryPolicy: RetryPolicy = {\n  maxRetries: 2,\n  backoff: BackoffStrategy.Exponential,\n  baseDelayMs: 1_000,\n  maxDelayMs: 30_000,\n  jitter: JitterStrategy.Full,\n  retryableStatuses: DefaultTransientStatuses,\n};\n","import { BackoffStrategy } from './BackoffStrategy';\nimport { JitterStrategy } from './JitterStrategy';\nimport { DefaultTransientStatuses, type RetryPolicy } from './RetryPolicy';\n\n/** Computes the raw (pre-jitter) backoff delay for an attempt, capped at `maxDelayMs`. */\nfunction backoffDelay(policy: RetryPolicy, attempt: number): number {\n  const { backoff, baseDelayMs } = policy;\n  const raw =\n    backoff === BackoffStrategy.Constant\n      ? baseDelayMs\n      : backoff === BackoffStrategy.Linear\n        ? baseDelayMs * attempt\n        : baseDelayMs * 2 ** (attempt - 1);\n  return policy.maxDelayMs != null ? Math.min(raw, policy.maxDelayMs) : raw;\n}\n\n/** Applies the policy's jitter to a delay; `previousDelayMs` powers decorrelated jitter. */\nfunction applyJitter(policy: RetryPolicy, delay: number, previousDelayMs: number, random: () => number): number {\n  switch (policy.jitter ?? JitterStrategy.None) {\n    case JitterStrategy.Full:\n      return random() * delay;\n    case JitterStrategy.Equal:\n      return delay / 2 + random() * (delay / 2);\n    case JitterStrategy.Decorrelated: {\n      const next = policy.baseDelayMs + random() * (previousDelayMs * 3 - policy.baseDelayMs);\n      return policy.maxDelayMs != null ? Math.min(next, policy.maxDelayMs) : Math.max(next, policy.baseDelayMs);\n    }\n    default:\n      return delay;\n  }\n}\n\n/** Computes the delay (ms) to wait before a retry attempt (1-based), per the policy's backoff + jitter — `random` is injectable for deterministic tests. */\nexport function computeRetryDelay(policy: RetryPolicy, attempt: number, previousDelayMs = 0, random: () => number = Math.random): number {\n  const delay = backoffDelay(policy, attempt);\n  return Math.round(applyJitter(policy, delay, previousDelayMs || delay, random));\n}\n\n/** Decides whether a failed attempt should retry — within `maxRetries` and the status is transient per the policy. */\nexport function shouldRetry(policy: RetryPolicy, failureCount: number, status: number): boolean {\n  const transient = new Set(policy.retryableStatuses ?? DefaultTransientStatuses);\n  return failureCount < policy.maxRetries && transient.has(status);\n}\n"],"names":[],"mappings":"AACO,MAAM,kBAAkB;AAAA;AAAA,EAE7B,UAAU;AAAA;AAAA,EAEV,QAAQ;AAAA;AAAA,EAER,aAAa;AACf;ACPO,MAAM,iBAAiB;AAAA;AAAA,EAE5B,MAAM;AAAA;AAAA,EAEN,MAAM;AAAA;AAAA,EAEN,OAAO;AAAA;AAAA,EAEP,cAAc;AAChB;ACNO,MAAM,2BAA8C,CAAC,GAAG,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG;AA0CpF,MAAM,qBAAkC;AAAA,EAC7C,YAAY;AAAA,EACZ,SAAS,gBAAgB;AAAA,EACzB,aAAa;AAAA,EACb,YAAY;AAAA,EACZ,QAAQ,eAAe;AAAA,EACvB,mBAAmB;AACrB;AChDA,SAAS,aAAa,QAAqB,SAAyB;AAClE,QAAM,EAAE,SAAS,YAAA,IAAgB;AACjC,QAAM,MACJ,YAAY,gBAAgB,WACxB,cACA,YAAY,gBAAgB,SAC1B,cAAc,UACd,cAAc,MAAM,UAAU;AACtC,SAAO,OAAO,cAAc,OAAO,KAAK,IAAI,KAAK,OAAO,UAAU,IAAI;AACxE;AAGA,SAAS,YAAY,QAAqB,OAAe,iBAAyB,QAA8B;AAC9G,UAAQ,OAAO,UAAU,eAAe,MAAA;AAAA,IACtC,KAAK,eAAe;AAClB,aAAO,WAAW;AAAA,IACpB,KAAK,eAAe;AAClB,aAAO,QAAQ,IAAI,OAAA,KAAY,QAAQ;AAAA,IACzC,KAAK,eAAe,cAAc;AAChC,YAAM,OAAO,OAAO,cAAc,YAAY,kBAAkB,IAAI,OAAO;AAC3E,aAAO,OAAO,cAAc,OAAO,KAAK,IAAI,MAAM,OAAO,UAAU,IAAI,KAAK,IAAI,MAAM,OAAO,WAAW;AAAA,IAC1G;AAAA,IACA;AACE,aAAO;AAAA,EAAA;AAEb;AAGO,SAAS,kBAAkB,QAAqB,SAAiB,kBAAkB,GAAG,SAAuB,KAAK,QAAgB;AACvI,QAAM,QAAQ,aAAa,QAAQ,OAAO;AAC1C,SAAO,KAAK,MAAM,YAAY,QAAQ,OAAO,mBAAmB,OAAO,MAAM,CAAC;AAChF;AAGO,SAAS,YAAY,QAAqB,cAAsB,QAAyB;AAC9F,QAAM,YAAY,IAAI,IAAI,OAAO,qBAAqB,wBAAwB;AAC9E,SAAO,eAAe,OAAO,cAAc,UAAU,IAAI,MAAM;AACjE;"}
+{"version":3,"file":"index.js","sources":["../../../src/foundation/resilience/enums/BackoffStrategy.ts","../../../src/foundation/resilience/enums/JitterStrategy.ts","../../../src/foundation/resilience/RetryPolicy.ts","../../../src/foundation/resilience/RetryDelay.ts"],"sourcesContent":["/** Defines how the delay between retries grows across attempts. */\nexport const BackoffStrategy = {\n  /** Refers to a fixed delay before every retry. */\n  Constant: 'constant',\n  /** Refers to a delay that grows linearly with the attempt (base × attempt). */\n  Linear: 'linear',\n  /** Refers to a delay that doubles each attempt (base × 2^(attempt − 1)). */\n  Exponential: 'exponential',\n} as const;\n\nexport type BackoffStrategy = (typeof BackoffStrategy)[keyof typeof BackoffStrategy];\n","/** Defines how jitter randomizes a computed retry delay — spreading retries to avoid a thundering herd. */\nexport const JitterStrategy = {\n  /** Refers to no jitter — the exact computed delay. */\n  None: 'none',\n  /** Refers to full jitter — a uniform random value in `[0, delay]`. */\n  Full: 'full',\n  /** Refers to equal jitter — `delay/2 + random[0, delay/2]`. */\n  Equal: 'equal',\n  /** Refers to decorrelated jitter (AWS / Polly) — random growth off the previous delay. */\n  Decorrelated: 'decorrelated',\n} as const;\n\nexport type JitterStrategy = (typeof JitterStrategy)[keyof typeof JitterStrategy];\n","import { BackoffStrategy } from './enums/BackoffStrategy';\nimport { JitterStrategy } from './enums/JitterStrategy';\n\n/** Provides the HTTP statuses treated as transient by default — network (`0`) plus the standard transient set. */\nexport const DefaultTransientStatuses: ReadonlyArray<number> = [0, 408, 429, 500, 502, 503, 504];\n\n/** Defines the context passed to a retry's `onRetry` hook. */\nexport interface RetryContext {\n  /** The upcoming attempt number (1-based). */\n  readonly attempt: number;\n\n  /** The error that triggered the retry. */\n  readonly error: unknown;\n\n  /** The coerced HTTP status (`0` = network / unknown). */\n  readonly status: number;\n\n  /** The delay (ms) waited before this attempt. */\n  readonly delayMs: number;\n}\n\n/** Defines a retry policy — attempt count, backoff growth, jitter, and which failures count as transient. */\nexport interface RetryPolicy {\n  /** The max retry attempts after the first failure. */\n  readonly maxRetries: number;\n\n  /** The backoff growth across attempts. */\n  readonly backoff: BackoffStrategy;\n\n  /** The base delay (ms) — the first backoff step. */\n  readonly baseDelayMs: number;\n\n  /** The delay cap (ms); omit for uncapped. */\n  readonly maxDelayMs?: number;\n\n  /** The jitter applied to each computed delay. Default `JitterStrategy.None`. */\n  readonly jitter?: JitterStrategy;\n\n  /** The HTTP statuses treated as transient (retryable). Default `DefaultTransientStatuses`. */\n  readonly retryableStatuses?: ReadonlyArray<number>;\n\n  /** Fires before each retry — logging / metrics. */\n  readonly onRetry?: (context: RetryContext) => void;\n}\n\n/** Provides the default retry policy — 2 exponential retries, full jitter, base 1s, cap 30s, transient statuses. */\nexport const DefaultRetryPolicy: RetryPolicy = {\n  maxRetries: 2,\n  backoff: BackoffStrategy.Exponential,\n  baseDelayMs: 1_000,\n  maxDelayMs: 30_000,\n  jitter: JitterStrategy.Full,\n  retryableStatuses: DefaultTransientStatuses,\n};\n","import { BackoffStrategy } from './enums/BackoffStrategy';\nimport { JitterStrategy } from './enums/JitterStrategy';\nimport { DefaultTransientStatuses, type RetryPolicy } from './RetryPolicy';\n\n/** Computes the raw (pre-jitter) backoff delay for an attempt, capped at `maxDelayMs`. */\nfunction backoffDelay(policy: RetryPolicy, attempt: number): number {\n  const { backoff, baseDelayMs } = policy;\n  const raw =\n    backoff === BackoffStrategy.Constant\n      ? baseDelayMs\n      : backoff === BackoffStrategy.Linear\n        ? baseDelayMs * attempt\n        : baseDelayMs * 2 ** (attempt - 1);\n  return policy.maxDelayMs != null ? Math.min(raw, policy.maxDelayMs) : raw;\n}\n\n/** Applies the policy's jitter to a delay; `previousDelayMs` powers decorrelated jitter. */\nfunction applyJitter(policy: RetryPolicy, delay: number, previousDelayMs: number, random: () => number): number {\n  switch (policy.jitter ?? JitterStrategy.None) {\n    case JitterStrategy.Full:\n      return random() * delay;\n    case JitterStrategy.Equal:\n      return delay / 2 + random() * (delay / 2);\n    case JitterStrategy.Decorrelated: {\n      const next = policy.baseDelayMs + random() * (previousDelayMs * 3 - policy.baseDelayMs);\n      return policy.maxDelayMs != null ? Math.min(next, policy.maxDelayMs) : Math.max(next, policy.baseDelayMs);\n    }\n    default:\n      return delay;\n  }\n}\n\n/**\n * Computes the delay (ms) to wait before a retry attempt (1-based), per the policy's backoff + jitter.\n * `random` is injectable for deterministic tests.\n */\nexport function computeRetryDelay(\n  policy: RetryPolicy,\n  attempt: number,\n  previousDelayMs = 0,\n  random: () => number = Math.random,\n): number {\n  const delay = backoffDelay(policy, attempt);\n  return Math.round(applyJitter(policy, delay, previousDelayMs || delay, random));\n}\n\n/** Decides whether a failed attempt should retry — within `maxRetries` and the status is transient per the policy. */\nexport function shouldRetry(policy: RetryPolicy, failureCount: number, status: number): boolean {\n  const transient = new Set(policy.retryableStatuses ?? DefaultTransientStatuses);\n  return failureCount < policy.maxRetries && transient.has(status);\n}\n"],"names":[],"mappings":"AACO,MAAM,kBAAkB;AAAA;AAAA,EAE7B,UAAU;AAAA;AAAA,EAEV,QAAQ;AAAA;AAAA,EAER,aAAa;AACf;ACPO,MAAM,iBAAiB;AAAA;AAAA,EAE5B,MAAM;AAAA;AAAA,EAEN,MAAM;AAAA;AAAA,EAEN,OAAO;AAAA;AAAA,EAEP,cAAc;AAChB;ACNO,MAAM,2BAAkD,CAAC,GAAG,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG;AA0CxF,MAAM,qBAAkC;AAAA,EAC7C,YAAY;AAAA,EACZ,SAAS,gBAAgB;AAAA,EACzB,aAAa;AAAA,EACb,YAAY;AAAA,EACZ,QAAQ,eAAe;AAAA,EACvB,mBAAmB;AACrB;AChDA,SAAS,aAAa,QAAqB,SAAyB;AAClE,QAAM,EAAE,SAAS,YAAA,IAAgB;AACjC,QAAM,MACJ,YAAY,gBAAgB,WACxB,cACA,YAAY,gBAAgB,SAC1B,cAAc,UACd,cAAc,MAAM,UAAU;AACtC,SAAO,OAAO,cAAc,OAAO,KAAK,IAAI,KAAK,OAAO,UAAU,IAAI;AACxE;AAGA,SAAS,YAAY,QAAqB,OAAe,iBAAyB,QAA8B;AAC9G,UAAQ,OAAO,UAAU,eAAe,MAAA;AAAA,IACtC,KAAK,eAAe;AAClB,aAAO,WAAW;AAAA,IACpB,KAAK,eAAe;AAClB,aAAO,QAAQ,IAAI,OAAA,KAAY,QAAQ;AAAA,IACzC,KAAK,eAAe,cAAc;AAChC,YAAM,OAAO,OAAO,cAAc,YAAY,kBAAkB,IAAI,OAAO;AAC3E,aAAO,OAAO,cAAc,OAAO,KAAK,IAAI,MAAM,OAAO,UAAU,IAAI,KAAK,IAAI,MAAM,OAAO,WAAW;AAAA,IAC1G;AAAA,IACA;AACE,aAAO;AAAA,EAAA;AAEb;AAMO,SAAS,kBACd,QACA,SACA,kBAAkB,GAClB,SAAuB,KAAK,QACpB;AACR,QAAM,QAAQ,aAAa,QAAQ,OAAO;AAC1C,SAAO,KAAK,MAAM,YAAY,QAAQ,OAAO,mBAAmB,OAAO,MAAM,CAAC;AAChF;AAGO,SAAS,YAAY,QAAqB,cAAsB,QAAyB;AAC9F,QAAM,YAAY,IAAI,IAAI,OAAO,qBAAqB,wBAAwB;AAC9E,SAAO,eAAe,OAAO,cAAc,UAAU,IAAI,MAAM;AACjE;"}

package/dist/foundation/results/AppErrorFactory.d.ts

@@ -0,0 +1,22 @@
+import { AppError } from './models/AppError';
+/** Creates display-safe failures from the shared catalog. */
+export declare const AppErrorFactory: {
+    /** Creates a validation failure. */
+    readonly validation: () => AppError;
+    /** Creates an unavailable failure. */
+    readonly unavailable: () => AppError;
+    /** Creates an authentication failure. */
+    readonly unauthorized: () => AppError;
+    /** Creates a permission failure. */
+    readonly forbidden: () => AppError;
+    /** Creates a missing-resource failure. */
+    readonly notFound: () => AppError;
+    /** Creates a conflicting-update failure. */
+    readonly conflict: () => AppError;
+    /** Creates a cancellation outcome; no user notice is required. */
+    readonly cancelled: () => AppError;
+    /** Creates a deadline failure. */
+    readonly timeout: () => AppError;
+    /** Creates an unexpected failure without exposing an exception message. */
+    readonly unexpected: () => AppError;
+};

package/dist/foundation/results/AppErrorType.d.ts

@@ -0,0 +1,13 @@
+/** Defines transport-independent failure categories. */
+export declare const AppErrorType: {
+    readonly Validation: "validation";
+    readonly Unavailable: "unavailable";
+    readonly Unauthorized: "unauthorized";
+    readonly Forbidden: "forbidden";
+    readonly NotFound: "notFound";
+    readonly Conflict: "conflict";
+    readonly Cancelled: "cancelled";
+    readonly Timeout: "timeout";
+    readonly Unexpected: "unexpected";
+};
+export type AppErrorType = (typeof AppErrorType)[keyof typeof AppErrorType];