@stridge/noctis 1.0.0-beta.0

package/README.md

@@ -0,0 +1,60 @@
+# @stridge/noctis
+
+The Stridge design system, and the single package consumers install. It pairs Base UI
+behavior with precompiled, **framework-neutral component CSS** on the semantic token layer, and
+ships the authoring substrate every primitive builds on — the polymorphic `Primitive` base, the
+`Surface` elevation primitive, render utilities, `Icon`, and the unified `NoctisProvider` (CSP +
+theme + locale/direction). It re-exports the design tokens, theme engine, and i18n through
+subpaths so apps depend on one package.
+
+## Styling
+
+Components are styled by hand-authored, per-component `.css` under `@layer noctis.components`,
+keyed off `data-slot` — no styling framework required. Import the one stylesheet:
+
+```ts
+// app CSS entry
+@import "@stridge/noctis/styles.css";
+```
+
+Authoring _with Tailwind_ is optional. Tailwind users additionally import the utility bridge and
+pull class helpers from the adapter subpath:
+
+```ts
+@import "@stridge/noctis/tailwind.css"; // mints bg-background-style utilities
+```
+
+```tsx
+import { cn, tv } from "@stridge/noctis/tailwind";
+import { Primitive } from "@stridge/noctis";
+```
+
+## Usage
+
+```tsx
+import { Button, Dialog, NoctisProvider } from "@stridge/noctis";
+
+<NoctisProvider>
+  <Button>Save</Button>
+</NoctisProvider>;
+```
+
+## Subpaths
+
+- `@stridge/noctis` — components + authoring substrate (`Primitive`, `Surface`, `NoctisProvider`, `Icon`, …).
+- `@stridge/noctis/props` — RSC-safe `*Props()` escape-hatch builders (no `"use client"` boundary).
+- `@stridge/noctis/styles.css` — the precompiled component stylesheet.
+- `@stridge/noctis/tailwind.css` — the optional Tailwind utility bridge.
+- `@stridge/noctis/tailwind` — the optional Tailwind adapter (`cn`, `tv`).
+- `@stridge/noctis/tokens` (+ `/react`) — re-exported `@stridge/noctis-design-tokens`.
+- `@stridge/noctis/theme` (+ `/react`) — re-exported `@stridge/noctis-theme-engine`.
+- `@stridge/noctis/i18n` (+ `/messages`) — re-exported `@stridge/noctis-intl` + the default catalog.
+- `@stridge/noctis/primitives` (+ `/*`) — the generated Base UI primitive re-exports.
+
+## Build & checks
+
+`build` runs `tsdown` then `scripts/bundle-css.mjs`; `check:publish` runs `publint` + `size-limit`.
+Component CSS is governed by stylelint.
+
+The component authoring contract lives in [COMPONENTS.md](./COMPONENTS.md), the slot catalog in
+[SLOTS.md](./SLOTS.md), and the repo-wide rules in [/AGENTS.md](../../AGENTS.md).

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,27 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+//#endregion
+export { __exportAll, __reExport };

package/dist/components/accordion/accordion.context.js

@@ -0,0 +1,15 @@
+"use client";
+import { createContext, use } from "react";
+//#region src/components/accordion/accordion.context.ts
+const AccordionContext = createContext(null);
+/** Provided by `Accordion.Root`; carries the shared size/level/landmark settings. */
+const AccordionProvider = AccordionContext.Provider;
+/**
+* Read the stack settings, or `null` for a part rendered outside `Accordion.Root` (the escape-hatch
+* `*.props()` path) — it never throws, so a bare part falls back to the component defaults.
+*/
+function useAccordionContext() {
+	return use(AccordionContext);
+}
+//#endregion
+export { AccordionProvider, useAccordionContext };

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

@@ -0,0 +1,136 @@
+import { accordion_d_exports } from "../../primitives/accordion.js";
+import { AccordionPartProps, itemProps, panelProps, rootProps, triggerProps } from "./accordion.props.js";
+import { AccordionLevel, AccordionSize } from "./accordion.types.js";
+import { ReactElement, ReactNode } from "react";
+
+//#region src/components/accordion/accordion.d.ts
+/**
+ * Groups the accordion items and owns which are expanded. Works controlled (`value` + `onValueChange`)
+ * or uncontrolled (`defaultValue`); the value is the array of open item values. By default one item is
+ * open at a time — pass `multiple` to let several stay open together. The stack-wide settings live here:
+ * `size` (sm · md), the heading `level`, and whether panels keep their `region` landmark
+ * (`landmarkPanels`).
+ *
+ * Compose one `Accordion.Item` per section, each holding an `Accordion.Trigger` over an
+ * `Accordion.Panel`.
+ */
+declare function AccordionRoot({
+  size,
+  level,
+  landmarkPanels,
+  role,
+  className,
+  children,
+  ...props
+}: Accordion.Root.Props): ReactElement;
+/**
+ * One collapsible section: a trigger over a panel. Pass `value` to control or initialise its open state
+ * from `Accordion.Root`; omit it and Base UI generates a stable one. The bare item carries only the
+ * hairline rule dividing it from the next — wrap the stack or pad the item with `className` to build a
+ * bordered or card layout. Base UI stamps the live `data-open`/`data-disabled`.
+ */
+declare function AccordionItem({
+  className,
+  children,
+  ...props
+}: Accordion.Item.Props): ReactElement;
+/**
+ * The full-width button that expands and collapses its panel, wrapped in its own heading so the section
+ * sits at the right rank in the document outline. Renders an `<h{level}>` around the button — the Root's
+ * `level` (default `3`) unless this trigger overrides it. Base UI wires `aria-expanded` and
+ * `aria-controls`, the roving focus, and the `data-panel-open` the muted chevron rotates a half-turn off.
+ * Pass the label as children; the chevron is appended automatically.
+ */
+declare function AccordionTrigger({
+  level: levelOverride,
+  className,
+  children,
+  ...props
+}: Accordion.Trigger.Props): ReactElement;
+/**
+ * The disclosed content for one item. Its height animates open and closed via Base UI's measured
+ * `--accordion-panel-height`, respecting `prefers-reduced-motion`. Base UI labels it `role="region"` by
+ * its trigger; a large stack auto-steps that back to `group` (per `Accordion.Root`'s `landmarkPanels`)
+ * so the landmark list stays useful. Keep it mounted while closed with `keepMounted`, or expose it to
+ * in-page find with `hiddenUntilFound`.
+ */
+declare function AccordionPanel({
+  className,
+  children,
+  role,
+  ...props
+}: Accordion.Panel.Props): ReactElement;
+/**
+ * A stack of collapsible sections in the shadcn recipe: each item is a heading/trigger over a panel,
+ * divided from the next by a single hairline rule, with a medium-weight edge-aligned trigger and a muted
+ * chevron that rotates a half-turn as its panel expands. The accordion carries no chrome of its own —
+ * build a bordered or card layout by wrapping the stack and padding the items with `className`.
+ *
+ * Built on Base UI's Accordion, so the stack is fully keyboard-operable (arrows move between triggers,
+ * Home/End jump to the ends, Enter/Space toggle), RTL-aware, and the height animation respects
+ * `prefers-reduced-motion`. The look is set on `Accordion.Root`: `size` (sm · md), the heading `level`,
+ * and `landmarkPanels`.
+ *
+ * Compose from parts: `Accordion.Root` owns the open value(s); each `Accordion.Item` holds an
+ * `Accordion.Trigger` over an `Accordion.Panel`.
+ *
+ * The runtime compound is a plain object (kept tree-shakeable); per-part prop and state types are
+ * exposed through the matching `Accordion` namespace — e.g. `Accordion.Item.Props`.
+ */
+declare const Accordion: {
+  /** Owns the open value(s) and the stack-wide settings. `Accordion.Root.props()` → its spreadable prop bag. */Root: typeof AccordionRoot & {
+    props: typeof rootProps;
+  }; /** One collapsible section. `Accordion.Item.props({ open, disabled })` → its spreadable prop bag. */
+  Item: typeof AccordionItem & {
+    props: typeof itemProps;
+  }; /** The heading/toggle button. `Accordion.Trigger.props({ open, disabled })` → its spreadable prop bag. */
+  Trigger: typeof AccordionTrigger & {
+    props: typeof triggerProps;
+  }; /** The disclosed content. `Accordion.Panel.props({ open, disabled })` → its spreadable prop bag. */
+  Panel: typeof AccordionPanel & {
+    props: typeof panelProps;
+  };
+};
+/**
+ * Per-part prop and state types, mirroring Base UI's `Component.Part.Props` convention. Types-only —
+ * it emits no runtime code and merges with the `Accordion` object above, so `Accordion.Item` is the
+ * component value while `Accordion.Item.Props` is its prop type.
+ */
+declare namespace Accordion {
+  /** The spreadable data-attribute prop bag every `Accordion.*.props()` returns (D12). */
+  type PartProps = AccordionPartProps;
+  /** The trigger/content size. */
+  type Size = AccordionSize;
+  /** The heading rank. */
+  type Level = AccordionLevel;
+  namespace Root {
+    type Props = Omit<accordion_d_exports.Accordion.Root.Props, "className" | "children"> & {
+      /** The trigger and content size. Defaults to `md`. */size?: AccordionSize; /** The heading rank every `Accordion.Trigger` renders (overridable per trigger). Defaults to `3`. */
+      level?: AccordionLevel;
+      /**
+       * Force the panels' `region` landmark on or off. Defaults to auto — on for stacks of six or
+       * fewer expandable items, off (a plain `group`) above, per the APG landmark-flooding guidance.
+       */
+      landmarkPanels?: boolean; /** The `Accordion.Item`s. */
+      children?: ReactNode; /** Classes merged onto the root. */
+      className?: string;
+    };
+    type State = accordion_d_exports.Accordion.Root.State;
+  }
+  namespace Item {
+    type Props = accordion_d_exports.Accordion.Item.Props;
+    type State = accordion_d_exports.Accordion.Item.State;
+  }
+  namespace Trigger {
+    type Props = accordion_d_exports.Accordion.Trigger.Props & {
+      /** Override the Root's heading rank for this trigger's heading alone. */level?: AccordionLevel;
+    };
+    type State = accordion_d_exports.Accordion.Trigger.State;
+  }
+  namespace Panel {
+    type Props = accordion_d_exports.Accordion.Panel.Props;
+    type State = accordion_d_exports.Accordion.Panel.State;
+  }
+}
+//#endregion
+export { Accordion };

package/dist/components/accordion/accordion.js

@@ -0,0 +1,132 @@
+"use client";
+import { Icon } from "../../icons/icon.js";
+import { ChevronDownIcon } from "../../icons/glyphs.js";
+import { accordion_exports } from "../../primitives/accordion.js";
+import { AccordionProvider, useAccordionContext } from "./accordion.context.js";
+import { ACCORDION_SLOTS } from "./accordion.slots.js";
+import { itemProps, panelProps, rootProps, triggerProps } from "./accordion.props.js";
+import { Children, createElement } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/components/accordion/accordion.tsx
+/** APG warns against more than six simultaneously-expandable landmark regions, so auto-drop past this. */
+const LANDMARK_ITEM_LIMIT = 6;
+/**
+* Groups the accordion items and owns which are expanded. Works controlled (`value` + `onValueChange`)
+* or uncontrolled (`defaultValue`); the value is the array of open item values. By default one item is
+* open at a time — pass `multiple` to let several stay open together. The stack-wide settings live here:
+* `size` (sm · md), the heading `level`, and whether panels keep their `region` landmark
+* (`landmarkPanels`).
+*
+* Compose one `Accordion.Item` per section, each holding an `Accordion.Trigger` over an
+* `Accordion.Panel`.
+*/
+function AccordionRoot({ size = "md", level = 3, landmarkPanels, role, className, children, ...props }) {
+	const nested = useAccordionContext() !== null;
+	const landmark = landmarkPanels ?? (!nested && Children.toArray(children).length <= LANDMARK_ITEM_LIMIT);
+	return /* @__PURE__ */ jsx(accordion_exports.Accordion.Root, {
+		"data-slot": ACCORDION_SLOTS.root,
+		"data-size": size,
+		role: role ?? "group",
+		className,
+		...props,
+		children: /* @__PURE__ */ jsx(AccordionProvider, {
+			value: {
+				size,
+				level,
+				landmark
+			},
+			children
+		})
+	});
+}
+/**
+* One collapsible section: a trigger over a panel. Pass `value` to control or initialise its open state
+* from `Accordion.Root`; omit it and Base UI generates a stable one. The bare item carries only the
+* hairline rule dividing it from the next — wrap the stack or pad the item with `className` to build a
+* bordered or card layout. Base UI stamps the live `data-open`/`data-disabled`.
+*/
+function AccordionItem({ className, children, ...props }) {
+	return /* @__PURE__ */ jsx(accordion_exports.Accordion.Item, {
+		"data-slot": ACCORDION_SLOTS.item,
+		className,
+		...props,
+		children
+	});
+}
+/**
+* The full-width button that expands and collapses its panel, wrapped in its own heading so the section
+* sits at the right rank in the document outline. Renders an `<h{level}>` around the button — the Root's
+* `level` (default `3`) unless this trigger overrides it. Base UI wires `aria-expanded` and
+* `aria-controls`, the roving focus, and the `data-panel-open` the muted chevron rotates a half-turn off.
+* Pass the label as children; the chevron is appended automatically.
+*/
+function AccordionTrigger({ level: levelOverride, className, children, ...props }) {
+	const context = useAccordionContext();
+	const level = levelOverride ?? context?.level ?? 3;
+	return /* @__PURE__ */ jsx(accordion_exports.Accordion.Header, {
+		"data-slot": ACCORDION_SLOTS.header,
+		render: createElement(`h${level}`),
+		children: /* @__PURE__ */ jsxs(accordion_exports.Accordion.Trigger, {
+			"data-slot": ACCORDION_SLOTS.trigger,
+			className,
+			...props,
+			children: [children, /* @__PURE__ */ jsx("span", {
+				"data-slot": ACCORDION_SLOTS.triggerIcon,
+				"aria-hidden": true,
+				children: /* @__PURE__ */ jsx(Icon, {
+					icon: ChevronDownIcon,
+					directional: true
+				})
+			})]
+		})
+	});
+}
+/**
+* The disclosed content for one item. Its height animates open and closed via Base UI's measured
+* `--accordion-panel-height`, respecting `prefers-reduced-motion`. Base UI labels it `role="region"` by
+* its trigger; a large stack auto-steps that back to `group` (per `Accordion.Root`'s `landmarkPanels`)
+* so the landmark list stays useful. Keep it mounted while closed with `keepMounted`, or expose it to
+* in-page find with `hiddenUntilFound`.
+*/
+function AccordionPanel({ className, children, role, ...props }) {
+	const landmark = useAccordionContext()?.landmark ?? true;
+	return /* @__PURE__ */ jsx(accordion_exports.Accordion.Panel, {
+		"data-slot": ACCORDION_SLOTS.panel,
+		role: role ?? (landmark ? "region" : "group"),
+		className,
+		...props,
+		children: /* @__PURE__ */ jsx("div", {
+			"data-slot": ACCORDION_SLOTS.panelContent,
+			children
+		})
+	});
+}
+/**
+* A stack of collapsible sections in the shadcn recipe: each item is a heading/trigger over a panel,
+* divided from the next by a single hairline rule, with a medium-weight edge-aligned trigger and a muted
+* chevron that rotates a half-turn as its panel expands. The accordion carries no chrome of its own —
+* build a bordered or card layout by wrapping the stack and padding the items with `className`.
+*
+* Built on Base UI's Accordion, so the stack is fully keyboard-operable (arrows move between triggers,
+* Home/End jump to the ends, Enter/Space toggle), RTL-aware, and the height animation respects
+* `prefers-reduced-motion`. The look is set on `Accordion.Root`: `size` (sm · md), the heading `level`,
+* and `landmarkPanels`.
+*
+* Compose from parts: `Accordion.Root` owns the open value(s); each `Accordion.Item` holds an
+* `Accordion.Trigger` over an `Accordion.Panel`.
+*
+* The runtime compound is a plain object (kept tree-shakeable); per-part prop and state types are
+* exposed through the matching `Accordion` namespace — e.g. `Accordion.Item.Props`.
+*/
+const Accordion = {
+	/** Owns the open value(s) and the stack-wide settings. `Accordion.Root.props()` → its spreadable prop bag. */
+	Root: Object.assign(AccordionRoot, { props: rootProps }),
+	/** One collapsible section. `Accordion.Item.props({ open, disabled })` → its spreadable prop bag. */
+	Item: Object.assign(AccordionItem, { props: itemProps }),
+	/** The heading/toggle button. `Accordion.Trigger.props({ open, disabled })` → its spreadable prop bag. */
+	Trigger: Object.assign(AccordionTrigger, { props: triggerProps }),
+	/** The disclosed content. `Accordion.Panel.props({ open, disabled })` → its spreadable prop bag. */
+	Panel: Object.assign(AccordionPanel, { props: panelProps })
+};
+//#endregion
+export { Accordion };

package/dist/components/accordion/accordion.props.d.ts

@@ -0,0 +1,45 @@
+//#region src/components/accordion/accordion.props.d.ts
+/** A spreadable data-attribute prop bag — the shape every `Accordion.*.props()` returns. */
+type AccordionPartProps = {
+  /** The slot value the matching `accordion.css` rules anchor on. */"data-slot": string; /** Forwarded verbatim — styling is attribute-driven, so this is an optional consumer passthrough. */
+  className?: string; /** A data-attribute present (empty string) or absent (`undefined`); never `false`. */
+  [attr: `data-${string}`]: string | undefined;
+};
+/** Common shape: every part's `.props()` accepts an optional `className` passthrough. */
+interface BasePropsArgs {
+  /** Forwarded verbatim onto the returned prop bag. */
+  className?: string;
+}
+/** Argument to the open/disabled-aware part helpers — the per-item state the CSS keys its look off. */
+interface AccordionStatePropsArgs extends BasePropsArgs {
+  /** Whether this item is expanded (drives the chevron rotation and panel reveal via `data-open`). */
+  open?: boolean;
+  /** Whether this item is disabled (drives the not-allowed affordance via `data-disabled`). */
+  disabled?: boolean;
+}
+/** Argument to a stateless part's `.props(...)` — no state of its own. */
+type AccordionStatelessPropsArgs = BasePropsArgs;
+/** Root prop bag: just the slot anchor (the stack metrics flow from it). */
+declare function rootProps({
+  className
+}?: AccordionStatelessPropsArgs): AccordionPartProps;
+/** Item prop bag: slot anchor plus the `data-open`/`data-disabled` state. */
+declare function itemProps({
+  open,
+  disabled,
+  className
+}?: AccordionStatePropsArgs): AccordionPartProps;
+/** Trigger prop bag: slot anchor plus the `data-panel-open`/`data-disabled` state. */
+declare function triggerProps({
+  open,
+  disabled,
+  className
+}?: AccordionStatePropsArgs): AccordionPartProps;
+/** Panel prop bag: slot anchor plus the `data-open`/`data-disabled` state. */
+declare function panelProps({
+  open,
+  disabled,
+  className
+}?: AccordionStatePropsArgs): AccordionPartProps;
+//#endregion
+export { AccordionPartProps, itemProps, panelProps, rootProps, triggerProps };

package/dist/components/accordion/accordion.props.js

@@ -0,0 +1,53 @@
+import { ACCORDION_SLOTS } from "./accordion.slots.js";
+//#region src/components/accordion/accordion.props.ts
+/**
+* The D12 unified variant contract for Accordion — a spreadable, data-attribute-native prop bag per
+* part. Each compound part exposes a `props(...)` builder returning `{ "data-slot":
+* "noctis-accordion-<part>", ...dataAttrs }`, so spreading a part's `props()` onto a *foreign* element
+* styles it as that part (the precompiled `accordion.css` keys every rule off the slot the bag
+* carries):
+*
+*     <button {...Accordion.Trigger.props({ open: true })}>Shipping</button>
+*     // → <button data-slot="noctis-accordion-trigger" data-panel-open="">
+*
+* Boolean state is a bare flag — present (`""`) when on, absent (`undefined`) when off — never `false`.
+* The bag carries no className; an optional `className` passthrough is accepted and forwarded verbatim.
+* The same variant→data-attribute→values mapping is emitted as data from the token graph
+* (`generated/declarations.json`) so non-React / agent consumers can hand-write the markup.
+*/
+/** Stamp a boolean state as a bare data-attribute: present (`""`) when on, absent (`undefined`) when off. */
+const flag = (on) => on ? "" : void 0;
+const withClassName = (bag, className) => className === void 0 ? bag : {
+	...bag,
+	className
+};
+/** Root prop bag: just the slot anchor (the stack metrics flow from it). */
+function rootProps({ className } = {}) {
+	return withClassName({ "data-slot": ACCORDION_SLOTS.root }, className);
+}
+/** Item prop bag: slot anchor plus the `data-open`/`data-disabled` state. */
+function itemProps({ open, disabled, className } = {}) {
+	return withClassName({
+		"data-slot": ACCORDION_SLOTS.item,
+		"data-open": flag(open),
+		"data-disabled": flag(disabled)
+	}, className);
+}
+/** Trigger prop bag: slot anchor plus the `data-panel-open`/`data-disabled` state. */
+function triggerProps({ open, disabled, className } = {}) {
+	return withClassName({
+		"data-slot": ACCORDION_SLOTS.trigger,
+		"data-panel-open": flag(open),
+		"data-disabled": flag(disabled)
+	}, className);
+}
+/** Panel prop bag: slot anchor plus the `data-open`/`data-disabled` state. */
+function panelProps({ open, disabled, className } = {}) {
+	return withClassName({
+		"data-slot": ACCORDION_SLOTS.panel,
+		"data-open": flag(open),
+		"data-disabled": flag(disabled)
+	}, className);
+}
+//#endregion
+export { itemProps, panelProps, rootProps, triggerProps };

package/dist/components/accordion/accordion.slots.d.ts

@@ -0,0 +1,24 @@
+//#region src/components/accordion/accordion.slots.d.ts
+/**
+ * The `data-*` hooks `Accordion` stamps on its parts, for host-side styling and tests. Slot values
+ * mark each rendered element; the state attributes are emitted by Base UI's Accordion — pair a slot
+ * with a state to target, say, only the open item's trigger.
+ */
+declare enum AccordionDataAttributes {
+  /** The slot name on every rendered part. */
+  slot = "data-slot",
+  /** Present on the item, header, and panel while that item is expanded. */
+  open = "data-open",
+  /** Present on the trigger while its panel is expanded. */
+  panelOpen = "data-panel-open",
+  /** Present on a disabled item, header, trigger, and panel. */
+  disabled = "data-disabled",
+  /** The item's zero-based position in the stack. */
+  index = "data-index",
+  /** `horizontal` | `vertical` — the accordion's orientation. */
+  orientation = "data-orientation",
+  /** The transition phase of the panel — present while it animates open or closed. */
+  startingStyle = "data-starting-style"
+}
+//#endregion
+export { AccordionDataAttributes };

package/dist/components/accordion/accordion.slots.js

@@ -0,0 +1,39 @@
+//#region src/components/accordion/accordion.slots.ts
+/**
+* The slot vocabulary every `Accordion` part stamps as its `data-slot`. The authored source the
+* orchestration file reads from, kebab-cased `{component}-{part}`; SLOTS.md still generates from the
+* token-graph declarations, so keep this in lockstep with the declaration's `anatomy`.
+*/
+const ACCORDION_SLOTS = {
+	root: "noctis-accordion",
+	item: "noctis-accordion-item",
+	header: "noctis-accordion-header",
+	trigger: "noctis-accordion-trigger",
+	triggerIcon: "noctis-accordion-trigger-icon",
+	panel: "noctis-accordion-panel",
+	panelContent: "noctis-accordion-panel-content"
+};
+/**
+* The `data-*` hooks `Accordion` stamps on its parts, for host-side styling and tests. Slot values
+* mark each rendered element; the state attributes are emitted by Base UI's Accordion — pair a slot
+* with a state to target, say, only the open item's trigger.
+*/
+let AccordionDataAttributes = /* @__PURE__ */ function(AccordionDataAttributes) {
+	/** The slot name on every rendered part. */
+	AccordionDataAttributes["slot"] = "data-slot";
+	/** Present on the item, header, and panel while that item is expanded. */
+	AccordionDataAttributes["open"] = "data-open";
+	/** Present on the trigger while its panel is expanded. */
+	AccordionDataAttributes["panelOpen"] = "data-panel-open";
+	/** Present on a disabled item, header, trigger, and panel. */
+	AccordionDataAttributes["disabled"] = "data-disabled";
+	/** The item's zero-based position in the stack. */
+	AccordionDataAttributes["index"] = "data-index";
+	/** `horizontal` | `vertical` — the accordion's orientation. */
+	AccordionDataAttributes["orientation"] = "data-orientation";
+	/** The transition phase of the panel — present while it animates open or closed. */
+	AccordionDataAttributes["startingStyle"] = "data-starting-style";
+	return AccordionDataAttributes;
+}({});
+//#endregion
+export { ACCORDION_SLOTS, AccordionDataAttributes };

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

@@ -0,0 +1,11 @@
+//#region src/components/accordion/accordion.types.d.ts
+/**
+ * Shared, runtime-free Accordion option types. Kept in their own module so the orchestration, props,
+ * and context files import one shape without a cycle through `accordion.tsx`.
+ */
+/** Control density of the trigger rows and panel content — `sm` (compact) or `md` (default, comfortable). */
+type AccordionSize = "sm" | "md";
+/** The heading rank the trigger's heading renders. Defaults to `3`; set it so the stack nests correctly in the outline. */
+type AccordionLevel = 2 | 3 | 4 | 5 | 6;
+//#endregion
+export { AccordionLevel, AccordionSize };

package/dist/components/accordion/index.d.ts

@@ -0,0 +1,3 @@
+import { AccordionLevel, AccordionSize } from "./accordion.types.js";
+import { Accordion } from "./accordion.js";
+import { AccordionDataAttributes } from "./accordion.slots.js";

package/dist/components/alert-dialog/alert-dialog.context.js

@@ -0,0 +1,16 @@
+"use client";
+import { createContext, use } from "react";
+//#region src/components/alert-dialog/alert-dialog.context.ts
+const AlertDialogContext = createContext(null);
+AlertDialogContext.displayName = "AlertDialogContext";
+/**
+* Reads the nearest `AlertDialog` context, throwing a part-named error when used outside an
+* `AlertDialog.Root`. `use()` (not `useContext`) per the React 19 substrate convention.
+*/
+function useAlertDialogContext(part) {
+	const value = use(AlertDialogContext);
+	if (value === null) throw new Error(`AlertDialog.${part} must be rendered inside an AlertDialog.Root.`);
+	return value;
+}
+//#endregion
+export { AlertDialogContext, useAlertDialogContext };