@dashforge/tw 0.11.0-beta → 1.0.0

package/CHANGELOG.md

@@ -12,6 +12,17 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 > duplicated intentionally — no shared "lowest common denominator" headless
 > layer.
 
+## [1.0.0] — 2026-05-23
+
+**Stable release.** First semver-stable version. The public API is now
+governed by strict semver — any future breaking change requires a major
+bump. Functionally identical to the previous beta tarball.
+
+- Version: `1.0.0`
+- Cross-package `@dashforge/*` peer-dependency ranges updated to `^1.0.0`.
+- See the [top-level CHANGELOG](https://github.com/kensaadi/dashforge/blob/main/CHANGELOG.md#100---2026-05-23) for the coordinated release context.
+- See [`MIGRATION.md`](https://github.com/kensaadi/dashforge/blob/main/MIGRATION.md) for the upgrade guide from any `0.x-beta` to `1.0.0` (no code changes required).
+
 ## [0.11.0-beta] — 2026-05-22
 
 **Sprint 7 — Tabs.** `<Tabs>` rebuilt as a custom, clean-room component.
@@ -137,8 +148,8 @@ Strictly additive — no breaking changes on existing component APIs.
   starts a column-reorder drag. On coarse-pointer (touch) devices the
   reorder `draggable` affordance is disabled — native HTML5
   drag-and-drop does not fire touch events, so it was a dead
-  interaction. (A pointer-event reorder covering touch is tracked in
-  `REFINEMENT-NOTES.md`.)
+  interaction. A pointer-event reorder covering touch is tracked
+  internally.
 - **`Table`** now emits a dev-only `console.warn` when `getRowId` is
   omitted while sort / search / selection / expandable rows are
   active — the positional-index fallback breaks row identity on
@@ -1349,16 +1360,6 @@ have shipped as `0.2.2-beta` in isolation.
   Breadcrumbs in its center slot, so fixing the Breadcrumbs link
   fixes TopBar transitively.
 
-### Internal
-
-- **`libs/dashforge/tw/CONSUMER-VALIDATION.md`** — Sprint 2 P1
-  deliverable. Per-component status table for the dash-consumer
-  end-to-end validation pass (24 components, 7-point check each).
-  Records the pattern lesson that motivated the Autocomplete
-  async fix: the bug was invisible to both unit tests (using
-  static `options`) and the docs lab (static demo) — only a real
-  consumer with `loadOptions` configured exposed it.
-
 ### Compatibility
 
 | Compatibility axis | Pre-`0.3.0` | Post-`0.3.0` |

package/COVERAGE.md

@@ -1,7 +1,7 @@
 # COVERAGE — `@dashforge/tw`
 
-> Sprint 6 P4 deliverable (2026-05-20). Test-coverage audit + the
-> gap-fill done this sprint, plus the tracked debt.
+> Test-coverage audit for `@dashforge/tw`. Current numbers, the gap-fill
+> performed, and the tracked debt.
 
 ## Current coverage (`vitest --coverage`, v8 provider)
 

package/PARITY.md

@@ -1,19 +1,17 @@
 # `@dashforge/tw` ↔ `@dashforge/ui` parity audit
 
-> Sprint 3 P1 deliverable (2026-05-19). Per-component diff between the
-> two Dashforge UI lines for the **10 bridge-integrated components**.
+> Per-component diff between the two Dashforge UI lines for the
+> **10 bridge-integrated components**.
 >
-> **Motivation (revised post-Sprint 2).** This audit does NOT exist to
-> support customer migration MUI→TW (no consumer switches across UI
-> ecosystems in real life). It exists because:
+> **Motivation.** This audit ensures:
 >
 > 1. **Internal consistency** — a refactor on `@dashforge/ui` that
 >    doesn't land on `@dashforge/tw` would otherwise be invisible.
-> 2. **Bridge contract validation** — proves that the same
->    `@dashforge/forms` schema works identically on both lines.
-> 3. **Foundation for Sprint 5 starter kits** — two parallel kits
+> 2. **Bridge contract validation** — the same `@dashforge/forms`
+>    schema works identically on both lines.
+> 3. **Parallel starter-kit maintainability** — two parallel kits
 >    (one MUI, one TW) require call-site-level parity to stay
->    parallel-maintainable.
+>    in sync.
 
 ## Versions audited
 

package/PERFORMANCE.md

@@ -1,9 +1,8 @@
 # `@dashforge/tw` performance baseline
 
-> Sprint 3 P4 deliverable (2026-05-19). Establishes the pre-`1.0.0`
-> performance commitment for `@dashforge/tw@0.4.0-beta` (29
-> components). Every subsequent release MUST hold this line or
-> justify the regression in `CHANGELOG.md`.
+> Establishes the performance commitment for `@dashforge/tw`. Every
+> subsequent release should hold these numbers or justify any
+> regression in `CHANGELOG.md`.
 
 ## Bundle size
 

package/THEME-AUDIT.md

@@ -1,15 +1,14 @@
 # THEME-AUDIT — @dashforge/tw catalog identity sweep
 
-> Sprint 4.3 deliverable (2026-05-19). Audit of every `@dashforge/tw`
-> component against the **default `dashforgePreset()` identity rule**
-> (memory: `feedback_dashforge_preset_is_identity`).
+> Audit of every `@dashforge/tw` component against the **default
+> `dashforgePreset()` identity rule**.
 >
 > **Rule recap.** The `dashforgePreset()` CSS-variable swap
 > auto-inverts the neutral palette:
 > `bg-neutral-50` / `text-neutral-900` etc. resolve to the
 > appropriate physical color via `--df-tw-color-neutral-N`. Adding a
 > `dark:` variant on a neutral class **double-inverts** the value
-> and breaks dark mode. The Sprint 4.1 Table fix established the
+> and breaks dark mode. The Table fix established the
 > canonical patterns; Sprint 4.3 applies them to the whole catalog.
 
 ## Scoring legend

package/dist/components/Accordion/Accordion.d.ts

@@ -0,0 +1,21 @@
+import type { AccordionProps } from './accordion.types.js';
+/**
+ * Dashforge TW `<Accordion>` — collapsible section list.
+ *
+ * Built on `@radix-ui/react-accordion`:
+ *  - APG accordion pattern: `role="region"` on content, header
+ *    button with `aria-expanded` and `aria-controls` linked to
+ *    the panel.
+ *  - Keyboard support: Space / Enter toggle, ArrowDown / ArrowUp
+ *    move focus between triggers, Home / End to extremes.
+ *  - Two modes:
+ *    - `type="single"` — at most one section open at a time;
+ *      `collapsible` allows clicking the open section to close it
+ *      (default true).
+ *    - `type="multiple"` — multiple sections open simultaneously.
+ *
+ * The trigger renders a chevron that flips 180° via CSS
+ * (`data-state=open` selector) — no React state, no JS animation.
+ */
+export declare function Accordion(props: AccordionProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Accordion.d.ts.map

package/dist/components/Accordion/Accordion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Accordion.d.ts","sourceRoot":"","sources":["../../../src/components/Accordion/Accordion.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,cAAc,EAGf,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,2CAqE9C"}

package/dist/components/Accordion/accordion.types.d.ts

@@ -0,0 +1,74 @@
+import type { ReactNode } from 'react';
+export interface AccordionSlotProps {
+    root?: {
+        className?: string;
+    };
+    item?: {
+        className?: string;
+    };
+    header?: {
+        className?: string;
+    };
+    trigger?: {
+        className?: string;
+    };
+    content?: {
+        className?: string;
+    };
+    chevron?: {
+        className?: string;
+    };
+}
+/**
+ * Single accordion section — paired `{ value, header, content }`.
+ * The `value` is the canonical id (used in `value` / `defaultValue`
+ * to control which sections are expanded).
+ */
+export interface AccordionItem {
+    value: string;
+    /** Trigger label (clickable to expand / collapse). */
+    header: ReactNode;
+    /** Section body, revealed when this item is expanded. */
+    content: ReactNode;
+    /** Per-item disabled flag. */
+    disabled?: boolean;
+}
+interface AccordionBaseProps {
+    items: AccordionItem[];
+    /** Root className shortcut. */
+    sx?: string;
+    /** Per-slot overrides. */
+    slotProps?: AccordionSlotProps;
+}
+/**
+ * Single-mode props — at most one section open at a time.
+ * `collapsible: true` (default) lets the user close the open
+ * section by clicking it again.
+ */
+export interface AccordionSingleProps extends AccordionBaseProps {
+    type?: 'single';
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    /** @default true */
+    collapsible?: boolean;
+}
+/**
+ * Multiple-mode props — any number of sections open simultaneously.
+ */
+export interface AccordionMultipleProps extends AccordionBaseProps {
+    type: 'multiple';
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+}
+/**
+ * Props for `<Accordion>`.
+ *
+ * Built on `@radix-ui/react-accordion`. Discriminated by `type`:
+ *  - `type="single"` (default) — `value` is `string`.
+ *  - `type="multiple"` — `value` is `string[]`.
+ */
+export type AccordionProps = AccordionSingleProps | AccordionMultipleProps;
+export {};
+//# sourceMappingURL=accordion.types.d.ts.map

package/dist/components/Accordion/accordion.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accordion.types.d.ts","sourceRoot":"","sources":["../../../src/components/Accordion/accordion.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9B,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9B,MAAM,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAChC,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACjC,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACjC,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAClC;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,sDAAsD;IACtD,MAAM,EAAE,SAAS,CAAC;IAClB,yDAAyD;IACzD,OAAO,EAAE,SAAS,CAAC;IACnB,8BAA8B;IAC9B,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,UAAU,kBAAkB;IAC1B,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,+BAA+B;IAC/B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,0BAA0B;IAC1B,SAAS,CAAC,EAAE,kBAAkB,CAAC;CAChC;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAqB,SAAQ,kBAAkB;IAC9D,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,oBAAoB;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,kBAAkB;IAChE,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;CAC3C;AAED;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,oBAAoB,GAAG,sBAAsB,CAAC"}

package/dist/components/Accordion/accordion.variants.d.ts

@@ -0,0 +1,58 @@
+import { type VariantProps } from 'tailwind-variants';
+export declare const accordionVariants: import("tailwind-variants").TVReturnType<{
+    [key: string]: {
+        [key: string]: import("tailwind-merge").ClassNameValue | {
+            content?: import("tailwind-merge").ClassNameValue;
+            root?: import("tailwind-merge").ClassNameValue;
+            header?: import("tailwind-merge").ClassNameValue;
+            trigger?: import("tailwind-merge").ClassNameValue;
+            item?: import("tailwind-merge").ClassNameValue;
+            chevron?: import("tailwind-merge").ClassNameValue;
+        };
+    };
+} | {
+    [x: string]: {
+        [x: string]: import("tailwind-merge").ClassNameValue | {
+            content?: import("tailwind-merge").ClassNameValue;
+            root?: import("tailwind-merge").ClassNameValue;
+            header?: import("tailwind-merge").ClassNameValue;
+            trigger?: import("tailwind-merge").ClassNameValue;
+            item?: import("tailwind-merge").ClassNameValue;
+            chevron?: import("tailwind-merge").ClassNameValue;
+        };
+    };
+} | {}, {
+    root: string;
+    item: string;
+    header: string;
+    trigger: string[];
+    content: string[];
+    chevron: string[];
+}, undefined, {
+    [key: string]: {
+        [key: string]: import("tailwind-merge").ClassNameValue | {
+            content?: import("tailwind-merge").ClassNameValue;
+            root?: import("tailwind-merge").ClassNameValue;
+            header?: import("tailwind-merge").ClassNameValue;
+            trigger?: import("tailwind-merge").ClassNameValue;
+            item?: import("tailwind-merge").ClassNameValue;
+            chevron?: import("tailwind-merge").ClassNameValue;
+        };
+    };
+} | {}, {
+    root: string;
+    item: string;
+    header: string;
+    trigger: string[];
+    content: string[];
+    chevron: string[];
+}, import("tailwind-variants").TVReturnType<unknown, {
+    root: string;
+    item: string;
+    header: string;
+    trigger: string[];
+    content: string[];
+    chevron: string[];
+}, undefined, unknown, unknown, undefined>>;
+export type AccordionVariants = VariantProps<typeof accordionVariants>;
+//# sourceMappingURL=accordion.variants.d.ts.map

package/dist/components/Accordion/accordion.variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accordion.variants.d.ts","sourceRoot":"","sources":["../../../src/components/Accordion/accordion.variants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAM,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAE1D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CA2B5B,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,YAAY,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/components/AppShell/AppShell.d.ts

@@ -0,0 +1,46 @@
+import type { AppShellProps } from './appShell.types.js';
+/**
+ * Dashforge TW AppShell — top-level layout orchestrator.
+ *
+ *   ┌──────────────────────────────────────────┐
+ *   │              header                      │  ← `header` slot
+ *   ├────────┬─────────────────────────────────┤
+ *   │        │                                 │
+ *   │  nav   │           main                  │  ← `nav` + `children`
+ *   │        │                                 │
+ *   ├────────┴─────────────────────────────────┤
+ *   │              footer                      │  ← `footer` slot
+ *   └──────────────────────────────────────────┘
+ *
+ * **Responsive**:
+ *   - `≥ md`: nav stays in the inline slot at the left.
+ *   - `< md`: nav becomes a slide-in drawer toggled by `navOpen`.
+ *     A backdrop closes the drawer on click (mirrors `<Dialog>` UX).
+ *
+ * **Body scroll lock**: when the mobile drawer is open we add
+ * `overflow-hidden` to `<body>` to prevent dual-scroll wobble. The
+ * effect cleans up on close + on unmount.
+ *
+ * **A11y**:
+ *   - `<main>` landmark wraps the content area.
+ *   - `<header>` / `<footer>` come for free from their HTML tags.
+ *   - The mobile drawer + backdrop participate in the standard
+ *     "click outside to close" pattern — `Escape` closes the drawer
+ *     too (added via global keydown).
+ *   - **Focus trap** (WCAG 2.4.3) — when the mobile drawer opens:
+ *       1. The previously-focused element is captured.
+ *       2. Focus moves to the first focusable element inside the drawer.
+ *       3. Tab / Shift+Tab wrap inside the drawer (cycle from
+ *          last → first and first → last) — Tab can never escape
+ *          to the page underneath while the drawer is open.
+ *       4. On close, focus returns to the captured element (typically
+ *          the hamburger toggle the user pressed to open the drawer).
+ *     This pattern matches WAI-ARIA APG's modal dialog guidance even
+ *     though the drawer isn't strictly a dialog — same focus
+ *     management makes keyboard users' experience predictable.
+ *   - **`role="dialog"` + `aria-modal="true"`** are applied to the
+ *     drawer when open so screen readers announce it as a modal
+ *     overlay rather than just an aside.
+ */
+export declare function AppShell(props: AppShellProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AppShell.d.ts.map

package/dist/components/AppShell/AppShell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppShell.d.ts","sourceRoot":"","sources":["../../../src/components/AppShell/AppShell.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AA0BzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,2CAsK5C"}

package/dist/components/AppShell/appShell.types.d.ts

@@ -0,0 +1,62 @@
+import type { ReactNode } from 'react';
+import type { AppShellVariants } from './appShell.variants.js';
+export interface AppShellSlotProps {
+    root?: {
+        className?: string;
+    };
+    header?: {
+        className?: string;
+    };
+    nav?: {
+        className?: string;
+    };
+    navMobile?: {
+        className?: string;
+    };
+    main?: {
+        className?: string;
+    };
+    footer?: {
+        className?: string;
+    };
+    backdrop?: {
+        className?: string;
+    };
+}
+/**
+ * Props for `<AppShell>`.
+ *
+ * Top-level layout orchestrator with 4 named slots:
+ *
+ *   - `header` (top, sticky)
+ *   - `nav`    (left side, fixed-width on desktop, drawer on mobile)
+ *   - `footer` (bottom, non-sticky)
+ *   - `children` (main content, scrolls independently)
+ *
+ * Responsive behavior:
+ *   - **≥ md (768px)**: nav is rendered inline at the left.
+ *   - **< md**:        nav slides in as an overlay drawer when
+ *                      `navOpen={true}` (controlled).
+ *
+ * The shell is router-agnostic — pass any nav/header content. Typical
+ * pairing is `<LeftNav>` + `<TopBar>` (with a hamburger button in
+ * `TopBar.start` that flips `navOpen`).
+ */
+export interface AppShellProps extends AppShellVariants {
+    header?: ReactNode;
+    nav?: ReactNode;
+    footer?: ReactNode;
+    children?: ReactNode;
+    /**
+     * Mobile drawer open state. Controlled — provide
+     * `onNavOpenChange` to update. When `undefined`, the mobile drawer
+     * is always closed (consumer hasn't wired up the toggle yet).
+     */
+    navOpen?: boolean;
+    onNavOpenChange?: (open: boolean) => void;
+    /** Root className shortcut. */
+    sx?: string;
+    /** Per-slot className overrides. */
+    slotProps?: AppShellSlotProps;
+}
+//# sourceMappingURL=appShell.types.d.ts.map

package/dist/components/AppShell/appShell.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appShell.types.d.ts","sourceRoot":"","sources":["../../../src/components/AppShell/appShell.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,MAAM,WAAW,iBAAiB;IAChC,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9B,MAAM,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAChC,GAAG,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7B,SAAS,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9B,MAAM,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAChC,QAAQ,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,aAAc,SAAQ,gBAAgB;IACrD,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IAC1C,+BAA+B;IAC/B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,oCAAoC;IACpC,SAAS,CAAC,EAAE,iBAAiB,CAAC;CAC/B"}

package/dist/components/AppShell/appShell.variants.d.ts

@@ -0,0 +1,65 @@
+import { type VariantProps } from 'tailwind-variants';
+/**
+ * Tailwind-variants recipe for `<AppShell>`.
+ *
+ * Slots:
+ *   - `root`      — outer flex column (full viewport)
+ *   - `header`    — top region
+ *   - `body`      — flex row holding nav + main
+ *   - `nav`       — desktop nav rail (md+)
+ *   - `navMobile` — mobile drawer (slide-in)
+ *   - `main`      — scrollable content area
+ *   - `footer`    — bottom region
+ *   - `backdrop`  — semi-opaque overlay behind the mobile drawer
+ */
+export declare const appShellVariants: import("tailwind-variants").TVReturnType<{
+    navOpen: {
+        true: {
+            navMobile: string;
+            backdrop: string;
+        };
+    };
+}, {
+    root: string;
+    header: string;
+    body: string;
+    nav: string;
+    navMobile: string[];
+    main: string;
+    footer: string;
+    backdrop: string[];
+}, undefined, {
+    navOpen: {
+        true: {
+            navMobile: string;
+            backdrop: string;
+        };
+    };
+}, {
+    root: string;
+    header: string;
+    body: string;
+    nav: string;
+    navMobile: string[];
+    main: string;
+    footer: string;
+    backdrop: string[];
+}, import("tailwind-variants").TVReturnType<{
+    navOpen: {
+        true: {
+            navMobile: string;
+            backdrop: string;
+        };
+    };
+}, {
+    root: string;
+    header: string;
+    body: string;
+    nav: string;
+    navMobile: string[];
+    main: string;
+    footer: string;
+    backdrop: string[];
+}, undefined, unknown, unknown, undefined>>;
+export type AppShellVariants = VariantProps<typeof appShellVariants>;
+//# sourceMappingURL=appShell.variants.d.ts.map

package/dist/components/AppShell/appShell.variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appShell.variants.d.ts","sourceRoot":"","sources":["../../../src/components/AppShell/appShell.variants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAM,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAE1D;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAoC3B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,YAAY,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/components/AspectRatio/AspectRatio.d.ts

@@ -0,0 +1,36 @@
+import type { AspectRatioProps } from './aspectRatio.types.js';
+/**
+ * `<AspectRatio>` — locks the aspect ratio of its child container,
+ * regardless of width. The classic use is responsive images and
+ * embedded media: an `<img>` that takes 100% of the available width
+ * but always renders at 16:9 (or 1:1, or whatever the source ratio is)
+ * — no jumping layouts during image load, no whitespace below the
+ * media, no JS measurement.
+ *
+ * Implementation: native CSS `aspect-ratio` property. Supported in
+ * every browser shipped from 2021 onward (Chrome 88, Firefox 89,
+ * Safari 15, Edge 88). No padding-bottom hack — that workaround
+ * predates the native property and brings ugly absolute-positioning
+ * requirements on the child.
+ *
+ * Why a component if it's "just one CSS property"?
+ *   Two reasons:
+ *     1. Discoverability — `<AspectRatio ratio={16/9}>` documents the
+ *        intent at the call site. `style={{ aspectRatio: '16/9' }}` is
+ *        the same thing functionally, but harder to spot in a 200-line
+ *        component file.
+ *     2. Composition — pairs naturally with `sx="rounded-xl overflow-hidden"`
+ *        for the canonical "rounded clipped media" pattern. Forgetting
+ *        the `overflow-hidden` is the #1 mistake we want to prevent
+ *        through documentation (it's in this component's MDX, at the
+ *        top of the Notes).
+ *
+ * Child contract:
+ *   The single child is expected to fill the container — typically
+ *   `<img>` / `<video>` with `className="w-full h-full object-cover"`.
+ *   We don't force this via CSS (the consumer might want a centered
+ *   icon instead of a filling image) — but it's the 99% case, and the
+ *   docs show it first.
+ */
+export declare const AspectRatio: import("react").ForwardRefExoticComponent<AspectRatioProps & import("react").RefAttributes<HTMLElement>>;
+//# sourceMappingURL=AspectRatio.d.ts.map

package/dist/components/AspectRatio/AspectRatio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AspectRatio.d.ts","sourceRoot":"","sources":["../../../src/components/AspectRatio/AspectRatio.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,WAAW,0GAiCvB,CAAC"}

package/dist/components/AspectRatio/aspectRatio.types.d.ts

@@ -0,0 +1,50 @@
+import type { ElementType, HTMLAttributes, ReactNode } from 'react';
+/**
+ * Props for `<AspectRatio>` — content-shape primitive that locks the
+ * aspect ratio of its child regardless of width.
+ *
+ * Implementation: uses the native CSS `aspect-ratio` property
+ * (supported in all current browsers since 2021 — Chrome 88+, Firefox 89+,
+ * Safari 15+, Edge 88+). No padding-bottom hack, no JS measurement.
+ *
+ * `ratio` accepts:
+ *   • A number — width / height. `16/9` is 1.7777…, `1` is square,
+ *     `4/3` is 1.333…, `21/9` is ultrawide cinema.
+ *   • A string with the CSS `aspect-ratio` syntax, e.g. `'16 / 9'`,
+ *     `'4 / 3'`. Useful when you want the source ratio to read clearly
+ *     in the JSX (`ratio="16 / 9"` is more legible than `ratio={16/9}`).
+ *
+ * The component renders a single element with `aspect-ratio: X` and
+ * `width: 100%`. The child is expected to fill it — typically an
+ * `<img>` or `<video>` with `className="w-full h-full object-cover"`.
+ *
+ * Why not a TV recipe?
+ *   The ratio is arbitrary (`16/9`, `1`, `2.35`, anything). Tailwind
+ *   has `aspect-square` / `aspect-video` / `aspect-[16/9]` arbitrary
+ *   values, but enumerating every conceivable ratio in TV would be
+ *   pointless. We set `style={{ aspectRatio }}` directly — pure CSS
+ *   property, no class purge concerns.
+ */
+export interface AspectRatioProps extends Omit<HTMLAttributes<HTMLDivElement>, 'className'> {
+    /**
+     * Aspect ratio as width/height. Number (`16/9`) or CSS string
+     * (`'16 / 9'`). Default `1` (square).
+     */
+    ratio?: number | string;
+    /**
+     * The child that fills the locked-ratio container. Typically an
+     * `<img>` or `<video>` with `className="w-full h-full object-cover"`.
+     */
+    children?: ReactNode;
+    /**
+     * Override the rendered HTML tag. Defaults to `'div'`.
+     */
+    as?: ElementType;
+    /**
+     * Utility classes appended to the base. Resolved via `tailwind-merge`.
+     * Common overrides: `sx="rounded-xl overflow-hidden"` to clip the
+     * child's overflow (image bleeds otherwise).
+     */
+    sx?: string;
+}
+//# sourceMappingURL=aspectRatio.types.d.ts.map

package/dist/components/AspectRatio/aspectRatio.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aspectRatio.types.d.ts","sourceRoot":"","sources":["../../../src/components/AspectRatio/aspectRatio.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,gBACf,SAAQ,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,EAAE,WAAW,CAAC;IACzD;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAExB;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;IAErB;;OAEG;IACH,EAAE,CAAC,EAAE,WAAW,CAAC;IAEjB;;;;OAIG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;CACb"}

package/dist/components/Autocomplete/Autocomplete.d.ts

@@ -0,0 +1,32 @@
+import type { AutocompleteOption, AutocompleteProps } from './autocomplete.types.js';
+/**
+ * Dashforge TW Autocomplete — bridge-integrated single-select combobox.
+ *
+ * **Implementation note (F5-A, rev. 2)**
+ *
+ * The first revision wrapped `react-aria-components`' `<ComboBox>` to get
+ * AAA-grade a11y for free. In practice React Aria's internal state
+ * machine fought every controlled-state pattern we tried (the input text
+ * would not clear when `selectedKey` went to `null`, even with a forced
+ * remount via `key` bumping). To get deterministic behaviour we own all
+ * of the state ourselves:
+ *
+ *   - `inputValue`       — the visible text in the `<input>`
+ *   - `isOpen`           — popover visibility
+ *   - `highlightedIndex` — keyboard navigation cursor
+ *
+ * A11y is still solid:
+ *   - `role="combobox"` + `aria-autocomplete="list"` on the input
+ *   - `aria-expanded`, `aria-controls`, `aria-activedescendant`
+ *   - `role="listbox"` / `role="option"` with `aria-selected`
+ *   - Full keyboard nav (↑/↓ navigate, Enter selects, Escape closes,
+ *     Home/End jump, Tab closes, click-outside closes)
+ *   - Required field gets `aria-required="true"`
+ *
+ * F5-A scope: single-select, static options, contains-substring filter
+ * (case-insensitive). Multi-select, free-solo text, generic option
+ * shapes, and async runtime options (`optionsFromFieldData`) are
+ * deferred to F5-A-bis.
+ */
+export declare function Autocomplete<TOption = AutocompleteOption>(props: AutocompleteProps<TOption>): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=Autocomplete.d.ts.map

package/dist/components/Autocomplete/Autocomplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Autocomplete.d.ts","sourceRoot":"","sources":["../../../src/components/Autocomplete/Autocomplete.tsx"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EACV,kBAAkB,EAClB,iBAAiB,EAElB,MAAM,yBAAyB,CAAC;AA8FjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAG,kBAAkB,EACvD,KAAK,EAAE,iBAAiB,CAAC,OAAO,CAAC,kDAy5BlC"}