@stridge/noctis 1.0.0-beta.0

package/dist/components/checkbox/checkbox-group.d.ts

@@ -0,0 +1,46 @@
+import { checkbox_group_d_exports } from "../../primitives/checkbox-group.js";
+import { groupProps } from "./checkbox.props.js";
+import { ReactElement } from "react";
+
+//#region src/components/checkbox/checkbox-group.d.ts
+/** Layout axis of a `CheckboxGroup` — `vertical` stacks its children, `horizontal` lays them in a row. */
+type CheckboxGroupOrientation = "vertical" | "horizontal";
+/**
+ * Shares one ticked-value list across a set of `Checkbox.Root`s. Works controlled (`value` +
+ * `onValueChange`) or uncontrolled (`defaultValue`); each child checkbox identifies itself with its
+ * `name`/`value`. The render stamps the group slot + `data-orientation` axis the precompiled CSS keys
+ * off — it lays its children out with the `--noctis-checkbox-group-gap` seam — and forwards `className`
+ * verbatim. `CheckboxGroup.props()` is the same mapping as a spreadable static for the escape-hatch
+ * path (D12).
+ *
+ * A single-part component: its props and shape types live on the matching `CheckboxGroup` namespace.
+ */
+declare function CheckboxGroupImpl({
+  orientation,
+  className,
+  ...props
+}: CheckboxGroup.Props): ReactElement;
+/**
+ * A group of related checkboxes sharing one selected-value list. `CheckboxGroup.props()` → its
+ * spreadable prop bag for the escape-hatch path (D12).
+ */
+declare const CheckboxGroup: typeof CheckboxGroupImpl & {
+  props: typeof groupProps;
+};
+/** Per-part prop and shape types for the single-part `CheckboxGroup`; merges with the value above. */
+declare namespace CheckboxGroup {
+  /** Layout axis — `vertical` (default) stacks the children, `horizontal` lays them in a row. */
+  type Orientation = CheckboxGroupOrientation;
+  /** Props for {@link CheckboxGroup}. */
+  type Props = Omit<checkbox_group_d_exports.CheckboxGroup.Props, "className"> & {
+    /**
+     * Layout axis — `horizontal` lays the children in a row. Stamped as `data-orientation`.
+     * @default "vertical"
+     */
+    orientation?: CheckboxGroupOrientation; /** Classes merged onto the group. */
+    className?: string;
+  };
+  type State = checkbox_group_d_exports.CheckboxGroup.State;
+}
+//#endregion
+export { CheckboxGroup };

package/dist/components/checkbox/checkbox-group.js

@@ -0,0 +1,31 @@
+"use client";
+import { CHECKBOX_SLOTS } from "./checkbox.slots.js";
+import { groupProps } from "./checkbox.props.js";
+import { checkbox_group_exports } from "../../primitives/checkbox-group.js";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/checkbox/checkbox-group.tsx
+/**
+* Shares one ticked-value list across a set of `Checkbox.Root`s. Works controlled (`value` +
+* `onValueChange`) or uncontrolled (`defaultValue`); each child checkbox identifies itself with its
+* `name`/`value`. The render stamps the group slot + `data-orientation` axis the precompiled CSS keys
+* off — it lays its children out with the `--noctis-checkbox-group-gap` seam — and forwards `className`
+* verbatim. `CheckboxGroup.props()` is the same mapping as a spreadable static for the escape-hatch
+* path (D12).
+*
+* A single-part component: its props and shape types live on the matching `CheckboxGroup` namespace.
+*/
+function CheckboxGroupImpl({ orientation = "vertical", className, ...props }) {
+	return /* @__PURE__ */ jsx(checkbox_group_exports.CheckboxGroup, {
+		"data-slot": CHECKBOX_SLOTS.group,
+		"data-orientation": orientation,
+		className,
+		...props
+	});
+}
+/**
+* A group of related checkboxes sharing one selected-value list. `CheckboxGroup.props()` → its
+* spreadable prop bag for the escape-hatch path (D12).
+*/
+const CheckboxGroup = Object.assign(CheckboxGroupImpl, { props: groupProps });
+//#endregion
+export { CheckboxGroup };

package/dist/components/checkbox/checkbox.context.js

@@ -0,0 +1,15 @@
+"use client";
+import { createContext, use } from "react";
+//#region src/components/checkbox/checkbox.context.ts
+const CheckboxFieldContext = createContext(null);
+const CheckboxFieldProvider = CheckboxFieldContext.Provider;
+/**
+* Read the enclosing `Checkbox.Field` size, or `null` when a checkbox renders standalone. A
+* `Checkbox.Root` inside a field inherits this size unless it sets its own, so one `size` on the field
+* sizes the whole row.
+*/
+function useCheckboxFieldContext() {
+	return use(CheckboxFieldContext);
+}
+//#endregion
+export { CheckboxFieldProvider, useCheckboxFieldContext };

package/dist/components/checkbox/checkbox.d.ts

@@ -0,0 +1,130 @@
+import { checkbox_d_exports } from "../../primitives/checkbox.js";
+import { field_d_exports } from "../../primitives/field.js";
+import { CheckboxPartProps, fieldProps, indicatorProps, labelProps, rootProps } from "./checkbox.props.js";
+import { ReactElement } from "react";
+
+//#region src/components/checkbox/checkbox.d.ts
+/** Control size — `sm`, `md`, or `lg`. The default `md` box is `1.125rem`. */
+type CheckboxSize = "sm" | "md" | "lg";
+/**
+ * A single toggleable box. Built on Base UI's Checkbox, so it is fully keyboard-operable (Space
+ * toggles), exposes the hidden `<input>` for forms, and supports the indeterminate state. The render
+ * stamps the slot + `data-size` axis the precompiled CSS keys off; `className` is a consumer
+ * passthrough. `Checkbox.Root.props(...)` is the same mapping as a spreadable static for the
+ * escape-hatch path (D12) — see `checkbox.props.ts`.
+ *
+ * A box inside a `Checkbox.Field` inherits the field's size unless it sets its own. Read-only, invalid,
+ * and required states flow from Base UI's Field integration (`data-readonly`/`data-invalid`/
+ * `data-required`) — no wrapper prop needed. For a labelled control, compose `Checkbox.Field` +
+ * `Checkbox.Label`; the row holds the `--noctis-checkbox-field-gap` seam.
+ */
+declare function CheckboxRootImpl({
+  size,
+  className,
+  children,
+  ...props
+}: Checkbox.Root.Props): ReactElement;
+/**
+ * The glyph that marks the box. Mounted while ticked or mixed: it shows a check when ticked and a
+ * minus when indeterminate (the CSS cross-fades the two off the box's `data-indeterminate`). Render it
+ * once inside `Checkbox.Root` — `Checkbox.Root` mounts a default `Indicator` when given no children, so
+ * the common case needs no explicit part.
+ */
+declare function CheckboxIndicator({
+  className,
+  ...props
+}: Checkbox.Indicator.Props): ReactElement;
+/**
+ * The labelled row — pairs a `Checkbox.Label` with a `Checkbox.Root` so the whole pairing reads as one
+ * control. Renders Base UI's `Field.Root`, which links the label to the box (clicking the label toggles
+ * it, the label becomes the accessible name) and feeds the box its validity state. Lay the label and
+ * box in either DOM order; the row mirrors under RTL by construction and holds the box↔label gap seam.
+ *
+ *     <Checkbox.Field>
+ *         <Checkbox.Root />
+ *         <Checkbox.Label>Subscribe to updates</Checkbox.Label>
+ *     </Checkbox.Field>
+ */
+declare function CheckboxField({
+  size,
+  className,
+  children,
+  ...props
+}: Checkbox.Field.Props): ReactElement;
+/**
+ * The visible label that names a checkbox inside a `Checkbox.Field`. Renders Base UI's `Field.Label`, so
+ * clicking it toggles the box and its text supplies the accessible name (no `aria-label` needed). It
+ * mirrors the field's disabled and invalid state through `data-disabled`/`data-invalid`.
+ */
+declare function CheckboxLabel({
+  className,
+  children,
+  ...props
+}: Checkbox.Label.Props): ReactElement;
+/**
+ * A checkbox: a square box that toggles a boolean, with an optional indeterminate (mixed) state and a
+ * check / minus glyph that draws in. Three sizes (`sm` / `md` / `lg`). Built on Base UI's Checkbox, so
+ * Space toggles, the hidden `<input>` integrates with forms, focus shows a visible ring, and the glyph
+ * draw-in respects `prefers-reduced-motion`.
+ *
+ * Compose from parts: `Checkbox.Root` owns the checked state and the shared `size`, `Checkbox.Indicator`
+ * holds the glyph (mounted by default — pass an explicit `Indicator` only to customise it), and
+ * `Checkbox.Field` + `Checkbox.Label` add a labelled row that wires the label to the box and surfaces
+ * its read-only / invalid state.
+ *
+ * The runtime compound is a plain object (kept tree-shakeable); per-part prop and state types are
+ * exposed through the matching `Checkbox` namespace — e.g. `Checkbox.Root.Props`.
+ */
+declare const Checkbox: {
+  /** The box. `Checkbox.Root.props({ size, checked, indeterminate, disabled, readonly, invalid, required })` → its spreadable prop bag. */Root: typeof CheckboxRootImpl & {
+    props: typeof rootProps;
+  }; /** The check / minus glyph. `Checkbox.Indicator.props()` → its spreadable prop bag. */
+  Indicator: typeof CheckboxIndicator & {
+    props: typeof indicatorProps;
+  }; /** The labelled row pairing a box with its label. `Checkbox.Field.props({ size })` → its spreadable prop bag. */
+  Field: typeof CheckboxField & {
+    props: typeof fieldProps;
+  }; /** The box's visible accessible name. `Checkbox.Label.props({ disabled, invalid })` → its spreadable prop bag. */
+  Label: typeof CheckboxLabel & {
+    props: typeof labelProps;
+  };
+};
+/**
+ * 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 `Checkbox` object above, so `Checkbox.Root` is the
+ * component value while `Checkbox.Root.Props` is its prop type.
+ */
+declare namespace Checkbox {
+  /** Control size — `sm`, `md`, or `lg`. */
+  type Size = CheckboxSize;
+  /** The spreadable data-attribute prop bag every `Checkbox.*.props()` returns (D12). */
+  type PartProps = CheckboxPartProps;
+  namespace Root {
+    type Props = Omit<checkbox_d_exports.Checkbox.Root.Props, "className"> & {
+      /**
+       * Control size — re-points the box and indicator metrics. Falls back to an enclosing
+       * `Checkbox.Field`'s size, then `md`.
+       */
+      size?: CheckboxSize; /** Classes merged onto the box. */
+      className?: string;
+    };
+    type State = checkbox_d_exports.Checkbox.Root.State;
+  }
+  namespace Indicator {
+    type Props = checkbox_d_exports.Checkbox.Indicator.Props;
+    type State = checkbox_d_exports.Checkbox.Indicator.State;
+  }
+  namespace Field {
+    /** Props for {@link Checkbox.Field} — Base UI's `Field.Root` plus the Noctis `size` axis. */
+    interface Props extends field_d_exports.Field.Root.Props {
+      /** Row size — scales the label text and cascades to the box inside. Defaults to `md`. */
+      size?: CheckboxSize;
+    }
+  }
+  namespace Label {
+    /** Props for {@link Checkbox.Label} — Base UI's `Field.Label`, the box's visible accessible name. */
+    type Props = field_d_exports.Field.Label.Props;
+  }
+}
+//#endregion
+export { Checkbox };

package/dist/components/checkbox/checkbox.js

@@ -0,0 +1,117 @@
+"use client";
+import { CheckIcon, MinusIcon } from "../../icons/glyphs.js";
+import { checkbox_exports } from "../../primitives/checkbox.js";
+import { field_exports } from "../../primitives/field.js";
+import { CheckboxFieldProvider, useCheckboxFieldContext } from "./checkbox.context.js";
+import { CHECKBOX_SLOTS } from "./checkbox.slots.js";
+import { fieldProps, indicatorProps, labelProps, rootProps } from "./checkbox.props.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/components/checkbox/checkbox.tsx
+/**
+* A single toggleable box. Built on Base UI's Checkbox, so it is fully keyboard-operable (Space
+* toggles), exposes the hidden `<input>` for forms, and supports the indeterminate state. The render
+* stamps the slot + `data-size` axis the precompiled CSS keys off; `className` is a consumer
+* passthrough. `Checkbox.Root.props(...)` is the same mapping as a spreadable static for the
+* escape-hatch path (D12) — see `checkbox.props.ts`.
+*
+* A box inside a `Checkbox.Field` inherits the field's size unless it sets its own. Read-only, invalid,
+* and required states flow from Base UI's Field integration (`data-readonly`/`data-invalid`/
+* `data-required`) — no wrapper prop needed. For a labelled control, compose `Checkbox.Field` +
+* `Checkbox.Label`; the row holds the `--noctis-checkbox-field-gap` seam.
+*/
+function CheckboxRootImpl({ size, className, children, ...props }) {
+	const field = useCheckboxFieldContext();
+	const resolvedSize = size ?? field?.size ?? "md";
+	return /* @__PURE__ */ jsx(checkbox_exports.Checkbox.Root, {
+		"data-slot": CHECKBOX_SLOTS.root,
+		"data-size": resolvedSize,
+		className,
+		...props,
+		children: children ?? /* @__PURE__ */ jsx(CheckboxIndicator, {})
+	});
+}
+/**
+* The glyph that marks the box. Mounted while ticked or mixed: it shows a check when ticked and a
+* minus when indeterminate (the CSS cross-fades the two off the box's `data-indeterminate`). Render it
+* once inside `Checkbox.Root` — `Checkbox.Root` mounts a default `Indicator` when given no children, so
+* the common case needs no explicit part.
+*/
+function CheckboxIndicator({ className, ...props }) {
+	return /* @__PURE__ */ jsxs(checkbox_exports.Checkbox.Indicator, {
+		"data-slot": CHECKBOX_SLOTS.indicator,
+		keepMounted: true,
+		className,
+		...props,
+		children: [/* @__PURE__ */ jsx(CheckIcon, {
+			"aria-hidden": true,
+			focusable: false,
+			"data-checkbox-glyph": "check"
+		}), /* @__PURE__ */ jsx(MinusIcon, {
+			"aria-hidden": true,
+			focusable: false,
+			"data-checkbox-glyph": "indeterminate"
+		})]
+	});
+}
+/**
+* The labelled row — pairs a `Checkbox.Label` with a `Checkbox.Root` so the whole pairing reads as one
+* control. Renders Base UI's `Field.Root`, which links the label to the box (clicking the label toggles
+* it, the label becomes the accessible name) and feeds the box its validity state. Lay the label and
+* box in either DOM order; the row mirrors under RTL by construction and holds the box↔label gap seam.
+*
+*     <Checkbox.Field>
+*         <Checkbox.Root />
+*         <Checkbox.Label>Subscribe to updates</Checkbox.Label>
+*     </Checkbox.Field>
+*/
+function CheckboxField({ size = "md", className, children, ...props }) {
+	return /* @__PURE__ */ jsx(CheckboxFieldProvider, {
+		value: { size },
+		children: /* @__PURE__ */ jsx(field_exports.Field.Root, {
+			"data-slot": CHECKBOX_SLOTS.field,
+			"data-size": size,
+			className,
+			...props,
+			children
+		})
+	});
+}
+/**
+* The visible label that names a checkbox inside a `Checkbox.Field`. Renders Base UI's `Field.Label`, so
+* clicking it toggles the box and its text supplies the accessible name (no `aria-label` needed). It
+* mirrors the field's disabled and invalid state through `data-disabled`/`data-invalid`.
+*/
+function CheckboxLabel({ className, children, ...props }) {
+	return /* @__PURE__ */ jsx(field_exports.Field.Label, {
+		"data-slot": CHECKBOX_SLOTS.label,
+		className,
+		...props,
+		children
+	});
+}
+/**
+* A checkbox: a square box that toggles a boolean, with an optional indeterminate (mixed) state and a
+* check / minus glyph that draws in. Three sizes (`sm` / `md` / `lg`). Built on Base UI's Checkbox, so
+* Space toggles, the hidden `<input>` integrates with forms, focus shows a visible ring, and the glyph
+* draw-in respects `prefers-reduced-motion`.
+*
+* Compose from parts: `Checkbox.Root` owns the checked state and the shared `size`, `Checkbox.Indicator`
+* holds the glyph (mounted by default — pass an explicit `Indicator` only to customise it), and
+* `Checkbox.Field` + `Checkbox.Label` add a labelled row that wires the label to the box and surfaces
+* its read-only / invalid state.
+*
+* The runtime compound is a plain object (kept tree-shakeable); per-part prop and state types are
+* exposed through the matching `Checkbox` namespace — e.g. `Checkbox.Root.Props`.
+*/
+const Checkbox = {
+	/** The box. `Checkbox.Root.props({ size, checked, indeterminate, disabled, readonly, invalid, required })` → its spreadable prop bag. */
+	Root: Object.assign(CheckboxRootImpl, { props: rootProps }),
+	/** The check / minus glyph. `Checkbox.Indicator.props()` → its spreadable prop bag. */
+	Indicator: Object.assign(CheckboxIndicator, { props: indicatorProps }),
+	/** The labelled row pairing a box with its label. `Checkbox.Field.props({ size })` → its spreadable prop bag. */
+	Field: Object.assign(CheckboxField, { props: fieldProps }),
+	/** The box's visible accessible name. `Checkbox.Label.props({ disabled, invalid })` → its spreadable prop bag. */
+	Label: Object.assign(CheckboxLabel, { props: labelProps })
+};
+//#endregion
+export { Checkbox };

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

@@ -0,0 +1,84 @@
+import { CheckboxGroup } from "./checkbox-group.js";
+import { Checkbox } from "./checkbox.js";
+
+//#region src/components/checkbox/checkbox.props.d.ts
+/** A spreadable data-attribute prop bag — the shape every `Checkbox.*.props()` returns. */
+type CheckboxPartProps = {
+  /** The slot value the matching `checkbox.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 `Checkbox.props(...)` — the box's size axis plus its checked / indeterminate / disabled / read-only / invalid state. */
+interface CheckboxPropsArgs extends BasePropsArgs {
+  /** Control size — stamped as `data-size`, re-points the box and indicator size internals. @default "md" */
+  size?: Checkbox.Size;
+  /** Whether the box is ticked (draws the accent fill via `data-checked`). */
+  checked?: boolean;
+  /** Whether the box is in the mixed state (draws the indeterminate glyph via `data-indeterminate`). */
+  indeterminate?: boolean;
+  /** Whether the box is disabled (drives the dimmed affordance via `data-disabled`). */
+  disabled?: boolean;
+  /** Whether the box is read-only (drops the pointer and hover affordance via `data-readonly`). */
+  readonly?: boolean;
+  /** Whether the box is invalid (paints the danger border via `data-invalid`). */
+  invalid?: boolean;
+  /** Whether the box is required (surfaced for form/validation hooks via `data-required`). */
+  required?: boolean;
+}
+/** Argument to `Checkbox.Indicator.props(...)` — the glyph carries no axes of its own; its size flows from the box. */
+type CheckboxIndicatorPropsArgs = BasePropsArgs;
+/** Argument to `CheckboxGroup.props(...)` — the group lays its children out along its orientation axis. */
+interface CheckboxGroupPropsArgs extends BasePropsArgs {
+  /** Layout axis — stamped as `data-orientation`; `horizontal` lays the children in a row. @default "vertical" */
+  orientation?: CheckboxGroup.Orientation;
+}
+/** Argument to `Checkbox.Field.props(...)` — the row pairs a box with its label; its size scales both. */
+interface CheckboxFieldPropsArgs extends BasePropsArgs {
+  /** Row size — stamped as `data-size`, scales the label text and cascades to the box inside. @default "md" */
+  size?: Checkbox.Size;
+}
+/** Argument to `Checkbox.Label.props(...)` — the label mirrors the field's disabled / invalid state. */
+interface CheckboxLabelPropsArgs extends BasePropsArgs {
+  /** Whether the field is disabled (dims the label and drops its pointer via `data-disabled`). */
+  disabled?: boolean;
+  /** Whether the field is invalid (recolours the label to danger via `data-invalid`). */
+  invalid?: boolean;
+}
+/** Box prop bag: slot anchor plus the `data-size` axis and the `data-checked`/`data-indeterminate`/`data-disabled`/`data-readonly`/`data-invalid`/`data-required` state. */
+declare function rootProps({
+  size,
+  checked,
+  indeterminate,
+  disabled,
+  readonly,
+  invalid,
+  required,
+  className
+}?: CheckboxPropsArgs): CheckboxPartProps;
+/** Indicator prop bag: just the slot anchor (the glyph size flows from the slot). */
+declare function indicatorProps({
+  className
+}?: CheckboxIndicatorPropsArgs): CheckboxPartProps;
+/** Group prop bag: slot anchor plus the `data-orientation` axis the row/column layout keys off. */
+declare function groupProps({
+  orientation,
+  className
+}?: CheckboxGroupPropsArgs): CheckboxPartProps;
+/** Field prop bag: slot anchor plus the `data-size` axis that scales the label and cascades to the box. */
+declare function fieldProps({
+  size,
+  className
+}?: CheckboxFieldPropsArgs): CheckboxPartProps;
+/** Label prop bag: slot anchor plus the `data-disabled`/`data-invalid` that mirror the field state. */
+declare function labelProps({
+  disabled,
+  invalid,
+  className
+}?: CheckboxLabelPropsArgs): CheckboxPartProps;
+//#endregion
+export { CheckboxPartProps, fieldProps, groupProps, indicatorProps, labelProps, rootProps };

package/dist/components/checkbox/checkbox.props.js

@@ -0,0 +1,49 @@
+import { CHECKBOX_SLOTS } from "./checkbox.slots.js";
+//#region src/components/checkbox/checkbox.props.ts
+/** 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
+};
+/** Box prop bag: slot anchor plus the `data-size` axis and the `data-checked`/`data-indeterminate`/`data-disabled`/`data-readonly`/`data-invalid`/`data-required` state. */
+function rootProps({ size = "md", checked, indeterminate, disabled, readonly, invalid, required, className } = {}) {
+	return withClassName({
+		"data-slot": CHECKBOX_SLOTS.root,
+		"data-size": size,
+		"data-checked": flag(checked),
+		"data-indeterminate": flag(indeterminate),
+		"data-disabled": flag(disabled),
+		"data-readonly": flag(readonly),
+		"data-invalid": flag(invalid),
+		"data-required": flag(required)
+	}, className);
+}
+/** Indicator prop bag: just the slot anchor (the glyph size flows from the slot). */
+function indicatorProps({ className } = {}) {
+	return withClassName({ "data-slot": CHECKBOX_SLOTS.indicator }, className);
+}
+/** Group prop bag: slot anchor plus the `data-orientation` axis the row/column layout keys off. */
+function groupProps({ orientation = "vertical", className } = {}) {
+	return withClassName({
+		"data-slot": CHECKBOX_SLOTS.group,
+		"data-orientation": orientation
+	}, className);
+}
+/** Field prop bag: slot anchor plus the `data-size` axis that scales the label and cascades to the box. */
+function fieldProps({ size = "md", className } = {}) {
+	return withClassName({
+		"data-slot": CHECKBOX_SLOTS.field,
+		"data-size": size
+	}, className);
+}
+/** Label prop bag: slot anchor plus the `data-disabled`/`data-invalid` that mirror the field state. */
+function labelProps({ disabled, invalid, className } = {}) {
+	return withClassName({
+		"data-slot": CHECKBOX_SLOTS.label,
+		"data-disabled": flag(disabled),
+		"data-invalid": flag(invalid)
+	}, className);
+}
+//#endregion
+export { fieldProps, groupProps, indicatorProps, labelProps, rootProps };

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

@@ -0,0 +1,27 @@
+//#region src/components/checkbox/checkbox.slots.d.ts
+/**
+ * The state attributes Base UI stamps on a checkbox, surfaced for the docs attributes table. Each
+ * member's value is the attribute name; its JSDoc is the description docgen renders.
+ */
+declare enum CheckboxDataAttributes {
+  /** The styling/testing hook — the slot name the precompiled CSS keys off. */
+  slot = "data-slot",
+  /** Stamps the size axis (`sm` / `md` / `lg`) on the box, re-pointing the size internals. */
+  size = "data-size",
+  /** Present on the box and indicator while the checkbox is ticked. */
+  checked = "data-checked",
+  /** Present on the box and indicator while the checkbox is not ticked. */
+  unchecked = "data-unchecked",
+  /** Present while the checkbox is in the mixed (indeterminate) state. */
+  indeterminate = "data-indeterminate",
+  /** Present while the checkbox is disabled. */
+  disabled = "data-disabled",
+  /** Present while the checkbox is read-only — valid and announced, but not editable. */
+  readonly = "data-readonly",
+  /** Present while the checkbox is in an invalid state (also honours `aria-invalid`). */
+  invalid = "data-invalid",
+  /** Stamps the group's layout axis (`vertical` / `horizontal`) on `noctis-checkbox-group`. */
+  orientation = "data-orientation"
+}
+//#endregion
+export { CheckboxDataAttributes };

package/dist/components/checkbox/checkbox.slots.js

@@ -0,0 +1,40 @@
+//#region src/components/checkbox/checkbox.slots.ts
+/**
+* The slot vocabulary every `Checkbox` part stamps as its `data-slot`. The authored source the
+* orchestration files read from, kebab-cased `{component}-{part}`; SLOTS.md still generates from the
+* token-graph declarations.
+*/
+const CHECKBOX_SLOTS = {
+	root: "noctis-checkbox",
+	indicator: "noctis-checkbox-indicator",
+	group: "noctis-checkbox-group",
+	field: "noctis-checkbox-field",
+	label: "noctis-checkbox-label"
+};
+/**
+* The state attributes Base UI stamps on a checkbox, surfaced for the docs attributes table. Each
+* member's value is the attribute name; its JSDoc is the description docgen renders.
+*/
+let CheckboxDataAttributes = /* @__PURE__ */ function(CheckboxDataAttributes) {
+	/** The styling/testing hook — the slot name the precompiled CSS keys off. */
+	CheckboxDataAttributes["slot"] = "data-slot";
+	/** Stamps the size axis (`sm` / `md` / `lg`) on the box, re-pointing the size internals. */
+	CheckboxDataAttributes["size"] = "data-size";
+	/** Present on the box and indicator while the checkbox is ticked. */
+	CheckboxDataAttributes["checked"] = "data-checked";
+	/** Present on the box and indicator while the checkbox is not ticked. */
+	CheckboxDataAttributes["unchecked"] = "data-unchecked";
+	/** Present while the checkbox is in the mixed (indeterminate) state. */
+	CheckboxDataAttributes["indeterminate"] = "data-indeterminate";
+	/** Present while the checkbox is disabled. */
+	CheckboxDataAttributes["disabled"] = "data-disabled";
+	/** Present while the checkbox is read-only — valid and announced, but not editable. */
+	CheckboxDataAttributes["readonly"] = "data-readonly";
+	/** Present while the checkbox is in an invalid state (also honours `aria-invalid`). */
+	CheckboxDataAttributes["invalid"] = "data-invalid";
+	/** Stamps the group's layout axis (`vertical` / `horizontal`) on `noctis-checkbox-group`. */
+	CheckboxDataAttributes["orientation"] = "data-orientation";
+	return CheckboxDataAttributes;
+}({});
+//#endregion
+export { CHECKBOX_SLOTS, CheckboxDataAttributes };

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

@@ -0,0 +1,3 @@
+import { CheckboxGroup } from "./checkbox-group.js";
+import { Checkbox } from "./checkbox.js";
+import { CheckboxDataAttributes } from "./checkbox.slots.js";

package/dist/components/code-block/brand-logo.d.ts

@@ -0,0 +1,37 @@
+import { ReactElement } from "react";
+
+//#region src/components/code-block/brand-logo.d.ts
+/** The package managers with an official multi-colour brand glyph. */
+type PackageManager = "pnpm" | "npm" | "yarn" | "bun" | "deno";
+/**
+ * The brand glyph for a fenced-code language or a package manager — one component for both, so a
+ * `CodeBlock.Tab`'s leading mark reads consistently whether the strip is languages or managers.
+ * Resolves in order: an official multi-colour package-manager mark (pnpm, npm, yarn, bun, deno), then a
+ * Simple Icons language mark (recoloured to stay legible on the dark well), then a muted terminal glyph
+ * so every tab keeps a leading icon. Reads `label` first (an explicit `Node.js` beats the raw `ts`
+ * fence id), then `name`.
+ *
+ * @see {@link BrandLogo.Props}
+ */
+declare function BrandLogo({
+  name,
+  label,
+  size,
+  className,
+  ...rest
+}: BrandLogo.Props): ReactElement;
+/**
+ * Per-part prop types. Types-only — merges with the `BrandLogo` function above, so `BrandLogo` is the
+ * component value while `BrandLogo.Props` is its prop type.
+ */
+declare namespace BrandLogo {
+  type Props = {
+    /** The thing to badge — a Shiki language id (`bash`, `ts`) or a package manager (`pnpm`, `npm`). */name?: string; /** Author-facing label (`Node.js`, `cURL`); preferred over `name`. */
+    label?: string; /** Square edge length in px. Defaults to 14 to match the tab text size. */
+    size?: number; /** Merged onto the glyph's class list. */
+    className?: string; /** Forwarded onto the rendered glyph — e.g. the `data-code-block-logo` hook a header logo carries. */
+    [attr: `data-${string}`]: string | undefined;
+  };
+}
+//#endregion
+export { BrandLogo, PackageManager };