@stridge/noctis 1.0.0-beta.0

package/dist/components/menubar/menubar.props.js

@@ -0,0 +1,45 @@
+import { MENUBAR_SLOTS } from "./menubar.slots.js";
+//#region src/components/menubar/menubar.props.ts
+/**
+* The D12 unified variant contract for Menubar — a per-part set of `props(...)` builders that each
+* return a **spreadable props object** of the form `{ "data-slot": "noctis-menubar-<part>", ...dataAttrs }`,
+* derived from the part's variant/state inputs.
+*
+* Under the single-`data-slot` anchor model the `data-slot` is the only styling hook needed —
+* `menubar.css` keys every rule off it — so spreading a part's `props()` onto a *foreign* element
+* styles it as that part:
+*
+*     <div {...Menubar.Root.props({ size: "md" })}>…</div>
+*     // → <div data-slot="noctis-menubar" data-size="md">
+*     <button {...Menubar.Trigger.props({ open: true })}>File</button>
+*     // → <button data-slot="noctis-menubar-trigger" data-popup-open="">
+*
+* The escape hatch carries no className (styling is attribute-driven); 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` → `variantSchema`) so non-React /
+* agent consumers can hand-write the markup from the docs.
+*/
+/** 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 (bar) prop bag: the slot anchor plus the `data-size` axis the trigger metrics re-point off. */
+function rootProps({ size = "md", className } = {}) {
+	return withClassName({
+		"data-slot": MENUBAR_SLOTS.root,
+		"data-size": size
+	}, className);
+}
+/** Trigger prop bag: the slot anchor plus the `data-popup-open`/`data-highlighted`/`data-disabled` state. */
+function triggerProps({ open, highlighted, disabled, className } = {}) {
+	return withClassName({
+		"data-slot": MENUBAR_SLOTS.trigger,
+		"data-popup-open": flag(open),
+		"data-highlighted": flag(highlighted),
+		"data-disabled": flag(disabled)
+	}, className);
+}
+//#endregion
+export { rootProps, triggerProps };

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

@@ -0,0 +1,26 @@
+//#region src/components/menubar/menubar.slots.d.ts
+/**
+ * The `data-*` hooks `Menubar` 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 Menubar/Menu — pair a slot with
+ * a state to target, say, the trigger only while its menu is open.
+ */
+declare enum MenubarDataAttributes {
+  /** The bar element (and, with `data-slot=noctis-menubar-trigger`, each top-level trigger). */
+  slot = "data-slot",
+  /** The bar's layout axis (`horizontal`/`vertical`), mirroring the root's `orientation` prop. */
+  orientation = "data-orientation",
+  /** The bar's size step (`sm`/`md`/`lg`), driving the trigger metrics re-point. */
+  size = "data-size",
+  /** Present on the bar while any of its menus is open. */
+  hasSubmenuOpen = "data-has-submenu-open",
+  /** Present on a top-level trigger whose menu is open. */
+  popupOpen = "data-popup-open",
+  /** Present on the top-level trigger the pointer or keyboard is currently over. */
+  highlighted = "data-highlighted",
+  /** Present on a disabled top-level trigger. */
+  disabled = "data-disabled",
+  /** Present on the icon-only overflow trigger (`Menubar.Overflow`); squares it off for the lone glyph. */
+  overflow = "data-overflow"
+}
+//#endregion
+export { MenubarDataAttributes };

package/dist/components/menubar/menubar.slots.js

@@ -0,0 +1,40 @@
+//#region src/components/menubar/menubar.slots.ts
+/**
+* The slot vocabulary every `Menubar` part stamps as its `data-slot`. The authored source the
+* orchestration file reads from, prefixed `noctis-{component}-{part}` (the precompiled `menubar.css`
+* keys every rule off these anchors); SLOTS.md still generates from the token-graph declarations.
+*
+* The menus that drop from each trigger are the on-main `Menu` component's parts — Menubar owns only
+* the bar (`root`) and its top-level `trigger`s; the popup content, items, groups, separators, and
+* shortcuts are stamped and styled by `Menu`/`menu.css` (one visual language).
+*/
+const MENUBAR_SLOTS = {
+	root: "noctis-menubar",
+	trigger: "noctis-menubar-trigger"
+};
+/**
+* The `data-*` hooks `Menubar` 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 Menubar/Menu — pair a slot with
+* a state to target, say, the trigger only while its menu is open.
+*/
+let MenubarDataAttributes = /* @__PURE__ */ function(MenubarDataAttributes) {
+	/** The bar element (and, with `data-slot=noctis-menubar-trigger`, each top-level trigger). */
+	MenubarDataAttributes["slot"] = "data-slot";
+	/** The bar's layout axis (`horizontal`/`vertical`), mirroring the root's `orientation` prop. */
+	MenubarDataAttributes["orientation"] = "data-orientation";
+	/** The bar's size step (`sm`/`md`/`lg`), driving the trigger metrics re-point. */
+	MenubarDataAttributes["size"] = "data-size";
+	/** Present on the bar while any of its menus is open. */
+	MenubarDataAttributes["hasSubmenuOpen"] = "data-has-submenu-open";
+	/** Present on a top-level trigger whose menu is open. */
+	MenubarDataAttributes["popupOpen"] = "data-popup-open";
+	/** Present on the top-level trigger the pointer or keyboard is currently over. */
+	MenubarDataAttributes["highlighted"] = "data-highlighted";
+	/** Present on a disabled top-level trigger. */
+	MenubarDataAttributes["disabled"] = "data-disabled";
+	/** Present on the icon-only overflow trigger (`Menubar.Overflow`); squares it off for the lone glyph. */
+	MenubarDataAttributes["overflow"] = "data-overflow";
+	return MenubarDataAttributes;
+}({});
+//#endregion
+export { MENUBAR_SLOTS, MenubarDataAttributes };

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

@@ -0,0 +1,2 @@
+import { Meter } from "./meter.js";
+import { MeterDataAttributes } from "./meter.slots.js";

package/dist/components/meter/meter.context.d.ts

@@ -0,0 +1,9 @@
+//#region src/components/meter/meter.context.d.ts
+/** Status tint of the reading — `neutral` by default; the others tint the indicator to a status role. */
+type MeterTone = "neutral" | "success" | "warning" | "danger";
+/** Track thickness — `sm` or `md`. */
+type MeterSize = "sm" | "md";
+/** Caption placement — `top` (header row above the track) or `side` (inline beside it). */
+type MeterLabels = "top" | "side";
+//#endregion
+export { MeterLabels, MeterSize, MeterTone };

package/dist/components/meter/meter.context.js

@@ -0,0 +1,13 @@
+"use client";
+import { createContext, use } from "react";
+//#region src/components/meter/meter.context.ts
+const MeterContext = createContext(null);
+const MeterProvider = MeterContext.Provider;
+/** Read the meter context, throwing a named error when a part renders outside `Meter.Root`. */
+function useMeterContext(part) {
+	const context = use(MeterContext);
+	if (context === null) throw new Error(`Meter.${part} must be rendered inside <Meter.Root>.`);
+	return context;
+}
+//#endregion
+export { MeterProvider, useMeterContext };

package/dist/components/meter/meter.d.ts

@@ -0,0 +1,163 @@
+import { Meter as Meter$1 } from "../../primitives/meter/meter.js";
+import { MeterLabels, MeterSize, MeterTone } from "./meter.context.js";
+import { MeterPartProps, MeterRootPropsArgs, indicatorProps, labelProps, rootProps, trackProps, valueProps } from "./meter.props.js";
+import { ReactElement, ReactNode } from "react";
+
+//#region src/components/meter/meter.d.ts
+/**
+ * Owns the measured value and shares the resolved `tone`/`size`/`labels` with the bar. Pass `value`
+ * (and optionally `min`/`max`, default `0`–`100`) for the reading. Tone is resolved in this order:
+ * an explicit `tone` wins; otherwise, when `optimum` is set, it is derived from the HTML `<meter>`
+ * threshold zones (`low`/`high`/`optimum`); otherwise it stays `neutral`. Compose `Meter.Track`
+ * (holding a `Meter.Indicator`) with optional `Meter.Label` + `Meter.Value`.
+ */
+declare function MeterRoot({
+  tone,
+  size,
+  labels,
+  low,
+  high,
+  optimum,
+  thickness,
+  value,
+  min,
+  max,
+  getAriaValueText,
+  "aria-valuetext": ariaValueText,
+  className,
+  style,
+  children,
+  ...props
+}: Meter.Root.Props): ReactElement;
+/** The groove the indicator fills against. Holds a single `Meter.Indicator`. */
+declare function MeterTrack({
+  className,
+  ...props
+}: Meter.Track.Props): ReactElement;
+/** The filled portion, sized to the value by Base UI; its fill colour follows the root's `tone`. */
+declare function MeterIndicator({
+  className,
+  ...props
+}: Meter.Indicator.Props): ReactElement;
+/** The meter's visible caption. Pair it with a `Meter.Value` in a row for a labelled reading. */
+declare function MeterLabel({
+  className,
+  ...props
+}: Meter.Label.Props): ReactElement;
+/** The formatted value text, localized via the injected locale. Pass `format` on the root to style it. */
+declare function MeterValue({
+  className,
+  ...props
+}: Meter.Value.Props): ReactElement;
+/**
+ * A meter: a static measurement shown as a filled bar within a known range — disk usage, battery,
+ * a score, remaining quota. Unlike a progress bar it reports a settled reading, not an ongoing task.
+ * Declare `low`/`high`/`optimum` and the fill tone is *derived* from the HTML `<meter>` zone model
+ * (`success`/`warning`/`danger`), so consumers stop hand-writing traffic-light logic; an explicit
+ * `tone` still overrides. Built on Base UI's Meter, so the value carries the correct `meter` role and
+ * `aria-valuenow` for assistive tech, the readout formats for the reader's locale, and the fill is
+ * RTL-aware; when a status tone is in play it also defaults a localized `aria-valuetext` so the status
+ * is announced, not just shown.
+ *
+ * Compose from parts: `Meter.Root` owns the value and the shared `tone`/`size`/`labels`, `Meter.Track`
+ * holds a single `Meter.Indicator`, and optional `Meter.Label` + `Meter.Value` caption the reading —
+ * the root lays them out above (`labels="top"`) or beside (`labels="side"`) the track.
+ *
+ * The runtime compound is a plain object (kept tree-shakeable); per-part prop and state types are
+ * exposed through the matching `Meter` namespace — e.g. `Meter.Value.Props`.
+ */
+declare const Meter: {
+  /** Owns the value and the shared tone/size/labels. `Meter.Root.props({ tone, size, labels })` → its spreadable prop bag. */Root: typeof MeterRoot & {
+    props: typeof rootProps;
+  }; /** The bar groove. `Meter.Track.props()` → its spreadable prop bag. */
+  Track: typeof MeterTrack & {
+    props: typeof trackProps;
+  }; /** The filled portion. `Meter.Indicator.props()` → its spreadable prop bag. */
+  Indicator: typeof MeterIndicator & {
+    props: typeof indicatorProps;
+  }; /** The caption label. `Meter.Label.props()` → its spreadable prop bag. */
+  Label: typeof MeterLabel & {
+    props: typeof labelProps;
+  }; /** The formatted value text. `Meter.Value.props()` → its spreadable prop bag. */
+  Value: typeof MeterValue & {
+    props: typeof valueProps;
+  };
+};
+/**
+ * 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 `Meter` object above, so `Meter.Value` is the component
+ * value while `Meter.Value.Props` is its prop type.
+ */
+declare namespace Meter {
+  /** Status tint of the reading — `neutral`, `success`, `warning`, or `danger`. */
+  type Tone = MeterTone;
+  /** Track thickness — `sm` or `md`. */
+  type Size = MeterSize;
+  /** Caption placement — `top` or `side`. */
+  type Labels = MeterLabels;
+  /** The spreadable data-attribute prop bag every `Meter.*.props()` returns (D12). */
+  type PartProps = MeterPartProps;
+  namespace Root {
+    type Props = Omit<Meter$1.Root.Props, "className" | "children"> & {
+      /**
+       * Status tint of the reading. Wins over any threshold-derived tone; omit it to derive the
+       * tone from `optimum` (or to stay `neutral` when no thresholds are set).
+       */
+      tone?: MeterTone;
+      /**
+       * Track thickness preset.
+       * @default "md"
+       */
+      size?: MeterSize;
+      /**
+       * Caption placement — a header row above the track (`top`) or inline beside it (`side`).
+       * @default "top"
+       */
+      labels?: MeterLabels;
+      /**
+       * The low boundary of the threshold model (HTML `<meter>` parity).
+       * @default min
+       */
+      low?: number;
+      /**
+       * The high boundary of the threshold model; also where the optional marker is drawn.
+       * @default max
+       */
+      high?: number;
+      /**
+       * The ideal point. Setting it turns on tone derivation: its position relative to
+       * `low`/`high` decides which region is healthy, so the fill turns `success`/`warning`/
+       * `danger` automatically. An explicit `tone` overrides the derived one.
+       */
+      optimum?: number;
+      /**
+       * An explicit track thickness, overriding the `size` preset (and the radius-aware default).
+       * A number is treated as `px`; a string is any CSS length. Writes the public track
+       * block-size override var.
+       */
+      thickness?: number | string; /** `Meter.Label`, `Meter.Value`, and the `Meter.Track`. */
+      children?: ReactNode; /** Classes merged onto the root. */
+      className?: string;
+    };
+    /** Argument to the `Meter.Root.props(...)` escape-hatch helper. */
+    type PropsArgs = MeterRootPropsArgs;
+  }
+  namespace Track {
+    type Props = Meter$1.Track.Props;
+    type State = Meter$1.Track.State;
+  }
+  namespace Indicator {
+    type Props = Meter$1.Indicator.Props;
+    type State = Meter$1.Indicator.State;
+  }
+  namespace Label {
+    type Props = Meter$1.Label.Props;
+    type State = Meter$1.Label.State;
+  }
+  namespace Value {
+    type Props = Meter$1.Value.Props;
+    type State = Meter$1.Value.State;
+  }
+}
+//#endregion
+export { Meter };

package/dist/components/meter/meter.js

@@ -0,0 +1,121 @@
+"use client";
+import { useNoctisStringFormatter } from "../../core/use-injected-labels.js";
+import { deriveThresholdTone } from "../../core/derive-threshold-tone.js";
+import { Meter as Meter$1 } from "../../primitives/meter/meter.js";
+import { MeterProvider, useMeterContext } from "./meter.context.js";
+import { indicatorProps, labelProps, rootProps, trackProps, valueProps } from "./meter.props.js";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/meter/meter.tsx
+/**
+* Owns the measured value and shares the resolved `tone`/`size`/`labels` with the bar. Pass `value`
+* (and optionally `min`/`max`, default `0`–`100`) for the reading. Tone is resolved in this order:
+* an explicit `tone` wins; otherwise, when `optimum` is set, it is derived from the HTML `<meter>`
+* threshold zones (`low`/`high`/`optimum`); otherwise it stays `neutral`. Compose `Meter.Track`
+* (holding a `Meter.Indicator`) with optional `Meter.Label` + `Meter.Value`.
+*/
+function MeterRoot({ tone, size = "md", labels = "top", low, high, optimum, thickness, value, min = 0, max = 100, getAriaValueText, "aria-valuetext": ariaValueText, className, style, children, ...props }) {
+	const formatter = useNoctisStringFormatter();
+	const resolvedTone = tone ?? (optimum !== void 0 && typeof value === "number" ? deriveThresholdTone({
+		value,
+		min,
+		max,
+		low,
+		high,
+		optimum
+	}) : "neutral");
+	const autoValueText = resolvedTone !== "neutral" && ariaValueText === void 0 && getAriaValueText === void 0 ? (formattedValue) => formatter.format("meter.valueText", {
+		value: formattedValue,
+		status: resolvedTone
+	}) : void 0;
+	const showMarker = optimum !== void 0 && high !== void 0 && high > min && high < max;
+	const rootStyle = {
+		...thickness !== void 0 && { "--noctis-meter-track-block-size": typeof thickness === "number" ? `${thickness}px` : thickness },
+		...showMarker && { "--meter-threshold": `${(high - min) / (max - min) * 100}%` },
+		...style
+	};
+	const valueTextProps = ariaValueText !== void 0 ? { "aria-valuetext": ariaValueText } : getAriaValueText ? { getAriaValueText } : autoValueText ? { getAriaValueText: autoValueText } : {};
+	return /* @__PURE__ */ jsx(Meter$1.Root, {
+		"data-tone": resolvedTone,
+		"data-size": size,
+		"data-labels": labels,
+		"data-threshold-marker": showMarker ? "" : void 0,
+		value,
+		min,
+		max,
+		className,
+		style: rootStyle,
+		...valueTextProps,
+		...props,
+		children: /* @__PURE__ */ jsx(MeterProvider, {
+			value: {
+				tone: resolvedTone,
+				size,
+				labels
+			},
+			children
+		})
+	});
+}
+/** The groove the indicator fills against. Holds a single `Meter.Indicator`. */
+function MeterTrack({ className, ...props }) {
+	useMeterContext("Track");
+	return /* @__PURE__ */ jsx(Meter$1.Track, {
+		className,
+		...props
+	});
+}
+/** The filled portion, sized to the value by Base UI; its fill colour follows the root's `tone`. */
+function MeterIndicator({ className, ...props }) {
+	useMeterContext("Indicator");
+	return /* @__PURE__ */ jsx(Meter$1.Indicator, {
+		className,
+		...props
+	});
+}
+/** The meter's visible caption. Pair it with a `Meter.Value` in a row for a labelled reading. */
+function MeterLabel({ className, ...props }) {
+	useMeterContext("Label");
+	return /* @__PURE__ */ jsx(Meter$1.Label, {
+		className,
+		...props
+	});
+}
+/** The formatted value text, localized via the injected locale. Pass `format` on the root to style it. */
+function MeterValue({ className, ...props }) {
+	useMeterContext("Value");
+	return /* @__PURE__ */ jsx(Meter$1.Value, {
+		className,
+		...props
+	});
+}
+/**
+* A meter: a static measurement shown as a filled bar within a known range — disk usage, battery,
+* a score, remaining quota. Unlike a progress bar it reports a settled reading, not an ongoing task.
+* Declare `low`/`high`/`optimum` and the fill tone is *derived* from the HTML `<meter>` zone model
+* (`success`/`warning`/`danger`), so consumers stop hand-writing traffic-light logic; an explicit
+* `tone` still overrides. Built on Base UI's Meter, so the value carries the correct `meter` role and
+* `aria-valuenow` for assistive tech, the readout formats for the reader's locale, and the fill is
+* RTL-aware; when a status tone is in play it also defaults a localized `aria-valuetext` so the status
+* is announced, not just shown.
+*
+* Compose from parts: `Meter.Root` owns the value and the shared `tone`/`size`/`labels`, `Meter.Track`
+* holds a single `Meter.Indicator`, and optional `Meter.Label` + `Meter.Value` caption the reading —
+* the root lays them out above (`labels="top"`) or beside (`labels="side"`) the track.
+*
+* The runtime compound is a plain object (kept tree-shakeable); per-part prop and state types are
+* exposed through the matching `Meter` namespace — e.g. `Meter.Value.Props`.
+*/
+const Meter = {
+	/** Owns the value and the shared tone/size/labels. `Meter.Root.props({ tone, size, labels })` → its spreadable prop bag. */
+	Root: Object.assign(MeterRoot, { props: rootProps }),
+	/** The bar groove. `Meter.Track.props()` → its spreadable prop bag. */
+	Track: Object.assign(MeterTrack, { props: trackProps }),
+	/** The filled portion. `Meter.Indicator.props()` → its spreadable prop bag. */
+	Indicator: Object.assign(MeterIndicator, { props: indicatorProps }),
+	/** The caption label. `Meter.Label.props()` → its spreadable prop bag. */
+	Label: Object.assign(MeterLabel, { props: labelProps }),
+	/** The formatted value text. `Meter.Value.props()` → its spreadable prop bag. */
+	Value: Object.assign(MeterValue, { props: valueProps })
+};
+//#endregion
+export { Meter };

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

@@ -0,0 +1,50 @@
+import { MeterLabels, MeterSize, MeterTone } from "./meter.context.js";
+
+//#region src/components/meter/meter.props.d.ts
+/** A spreadable data-attribute prop bag — the shape every `Meter.*.props()` returns. */
+type MeterPartProps = {
+  /** The slot value the matching `meter.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 carrying a value, or absent (`undefined`) when it does not apply. */
+  [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 `Meter.Root.props(...)` — the reading's tone, track size, and caption placement, stamped on the root. */
+interface MeterRootPropsArgs extends BasePropsArgs {
+  /** Status tint of the reading (the resolved tone, after any threshold derivation). @default "neutral" */
+  tone?: MeterTone;
+  /** Track thickness — `sm` or `md`. @default "md" */
+  size?: MeterSize;
+  /** Caption placement — `top` or `side`. @default "top" */
+  labels?: MeterLabels;
+}
+/** Argument to a stateless part's `.props(...)` — no axes of its own; look flows from the root. */
+type MeterStatelessPropsArgs = BasePropsArgs;
+/** Root prop bag: `data-slot` plus the `data-tone`/`data-size`/`data-labels` the descendant rules read. */
+declare function rootProps({
+  tone,
+  size,
+  labels,
+  className
+}?: MeterRootPropsArgs): MeterPartProps;
+/** Track prop bag: just the slot anchor (its fill/thickness flow from the root). */
+declare function trackProps({
+  className
+}?: MeterStatelessPropsArgs): MeterPartProps;
+/** Indicator prop bag: just the slot anchor (its fill colour flows from the root tone). */
+declare function indicatorProps({
+  className
+}?: MeterStatelessPropsArgs): MeterPartProps;
+/** Label prop bag: just the slot anchor. */
+declare function labelProps({
+  className
+}?: MeterStatelessPropsArgs): MeterPartProps;
+/** Value prop bag: just the slot anchor. */
+declare function valueProps({
+  className
+}?: MeterStatelessPropsArgs): MeterPartProps;
+//#endregion
+export { MeterPartProps, MeterRootPropsArgs, indicatorProps, labelProps, rootProps, trackProps, valueProps };

package/dist/components/meter/meter.props.js

@@ -0,0 +1,33 @@
+import { METER_SLOTS } from "./meter.slots.js";
+//#region src/components/meter/meter.props.ts
+const withClassName = (bag, className) => className === void 0 ? bag : {
+	...bag,
+	className
+};
+/** Root prop bag: `data-slot` plus the `data-tone`/`data-size`/`data-labels` the descendant rules read. */
+function rootProps({ tone = "neutral", size = "md", labels = "top", className } = {}) {
+	return withClassName({
+		"data-slot": METER_SLOTS.root,
+		"data-tone": tone,
+		"data-size": size,
+		"data-labels": labels
+	}, className);
+}
+/** Track prop bag: just the slot anchor (its fill/thickness flow from the root). */
+function trackProps({ className } = {}) {
+	return withClassName({ "data-slot": METER_SLOTS.track }, className);
+}
+/** Indicator prop bag: just the slot anchor (its fill colour flows from the root tone). */
+function indicatorProps({ className } = {}) {
+	return withClassName({ "data-slot": METER_SLOTS.indicator }, className);
+}
+/** Label prop bag: just the slot anchor. */
+function labelProps({ className } = {}) {
+	return withClassName({ "data-slot": METER_SLOTS.label }, className);
+}
+/** Value prop bag: just the slot anchor. */
+function valueProps({ className } = {}) {
+	return withClassName({ "data-slot": METER_SLOTS.value }, className);
+}
+//#endregion
+export { indicatorProps, labelProps, rootProps, trackProps, valueProps };

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

@@ -0,0 +1,18 @@
+//#region src/components/meter/meter.slots.d.ts
+/**
+ * The `data-*` hooks `Meter` stamps on its parts, for host-side styling and tests. The slot value
+ * marks each rendered element; the root also carries the `tone` and `size` axes the track and
+ * indicator rules key off — pair a slot with an axis to target, say, only a warning indicator.
+ */
+declare enum MeterDataAttributes {
+  /** The root meter element. */
+  slot = "data-slot",
+  /** `neutral` | `success` | `warning` | `danger` — the reading's status tint, stamped on the root. */
+  tone = "data-tone",
+  /** `sm` | `md` — the track thickness, stamped on the root. */
+  size = "data-size",
+  /** `top` | `side` — the caption placement relative to the track, stamped on the root. */
+  labels = "data-labels"
+}
+//#endregion
+export { MeterDataAttributes };

package/dist/components/meter/meter.slots.js

@@ -0,0 +1,31 @@
+//#region src/components/meter/meter.slots.ts
+/**
+* The slot vocabulary every `Meter` 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.
+*/
+const METER_SLOTS = {
+	root: "noctis-meter",
+	track: "noctis-meter-track",
+	indicator: "noctis-meter-indicator",
+	label: "noctis-meter-label",
+	value: "noctis-meter-value"
+};
+/**
+* The `data-*` hooks `Meter` stamps on its parts, for host-side styling and tests. The slot value
+* marks each rendered element; the root also carries the `tone` and `size` axes the track and
+* indicator rules key off — pair a slot with an axis to target, say, only a warning indicator.
+*/
+let MeterDataAttributes = /* @__PURE__ */ function(MeterDataAttributes) {
+	/** The root meter element. */
+	MeterDataAttributes["slot"] = "data-slot";
+	/** `neutral` | `success` | `warning` | `danger` — the reading's status tint, stamped on the root. */
+	MeterDataAttributes["tone"] = "data-tone";
+	/** `sm` | `md` — the track thickness, stamped on the root. */
+	MeterDataAttributes["size"] = "data-size";
+	/** `top` | `side` — the caption placement relative to the track, stamped on the root. */
+	MeterDataAttributes["labels"] = "data-labels";
+	return MeterDataAttributes;
+}({});
+//#endregion
+export { METER_SLOTS, MeterDataAttributes };

package/dist/components/navigation-menu/index.d.ts

@@ -0,0 +1,2 @@
+import { NavigationMenu } from "./navigation-menu.js";
+import { NavigationMenuDataAttributes } from "./navigation-menu.slots.js";