bitboss-ui 3.0.0-beta.63 → 3.0.0-beta.64

package/dist/types/AlertVariant.d.ts

@@ -14,6 +14,20 @@ export interface AlertVariantRegistry {
     warning: true;
 }
 export type AlertVariantFromRegistry = keyof AlertVariantRegistry;
+/**
+ * The built-in names as a literal union (Q76.7). The `pt:<part>:<variant>`
+ * ATTRIBUTE props are declared from it when the library is built; an app's
+ * own names are declared by the component's `variantPt()` mixin and typed by
+ * its `PtVariantAttrs` member, both from the registry.
+ *
+ * @state outline - Component-wide: `variant: 'outline'`. Merged after the part's base entry and before its states, so the real states still win.
+ * @state primary - Component-wide: `variant: 'primary'`. Below the real states, like every variant.
+ * @state destructive - Component-wide: `variant: 'destructive'`. Below the real states, like every variant.
+ * @state warning - Component-wide: `variant: 'warning'`. Below the real states, like every variant.
+ */
+export type AlertVariantBuiltIn = 'outline' | 'primary' | 'destructive' | 'warning';
+/** The built-in names at runtime, for the passthrough resolver. */
+export declare const ALERT_VARIANTS: readonly ["outline", "primary", "destructive", "warning"];
 /**
  * Variant type for `BbAlert.variant`.
  *

package/dist/types/AlertVariant.js

@@ -0,0 +1,9 @@
+//#region src/types/AlertVariant.ts
+var e = [
+	"outline",
+	"primary",
+	"destructive",
+	"warning"
+];
+//#endregion
+export { e as ALERT_VARIANTS };

package/dist/types/BadgeVariant.d.ts

@@ -14,6 +14,20 @@ export interface BadgeVariantRegistry {
     outline: true;
 }
 export type BadgeVariantFromRegistry = keyof BadgeVariantRegistry;
+/**
+ * The built-in names as a literal union (Q76.7). The `pt:<part>:<variant>`
+ * ATTRIBUTE props are declared from it when the library is built; an app's
+ * own names are declared by the component's `variantPt()` mixin and typed by
+ * its `PtVariantAttrs` member, both from the registry.
+ *
+ * @state primary - Component-wide: `variant: 'primary'`. Merged after the part's base entry and before its states, so the real states still win.
+ * @state secondary - Component-wide: `variant: 'secondary'`. Below the real states, like every variant.
+ * @state destructive - Component-wide: `variant: 'destructive'`. Below the real states, like every variant.
+ * @state outline - Component-wide: `variant: 'outline'`. Below the real states, like every variant.
+ */
+export type BadgeVariantBuiltIn = 'primary' | 'secondary' | 'destructive' | 'outline';
+/** The built-in names at runtime, for the passthrough resolver. */
+export declare const BADGE_VARIANTS: readonly ["primary", "secondary", "destructive", "outline"];
 /**
  * Variant type for `BbBadge.variant`.
  *

package/dist/types/BadgeVariant.js

@@ -0,0 +1,9 @@
+//#region src/types/BadgeVariant.ts
+var e = [
+	"primary",
+	"secondary",
+	"destructive",
+	"outline"
+];
+//#endregion
+export { e as BADGE_VARIANTS };

package/dist/types/ButtonVariant.d.ts

@@ -16,6 +16,22 @@ export interface ButtonVariantRegistry {
     link: true;
 }
 export type ButtonVariantFromRegistry = keyof ButtonVariantRegistry;
+/**
+ * The built-in names as a literal union (Q76.7). The `pt:<part>:<variant>`
+ * ATTRIBUTE props are declared from it when the library is built; an app's
+ * own names are declared by the component's `variantPt()` mixin and typed by
+ * its `PtVariantAttrs` member, both from the registry.
+ *
+ * @state primary - Component-wide: `variant="primary"`. Merged after the part's base entry and before its states, so `disabled` / `loading` still win.
+ * @state outline - Component-wide: `variant="outline"`. Below the real states, like every variant.
+ * @state secondary - Component-wide: `variant="secondary"`. Below the real states, like every variant.
+ * @state ghost - Component-wide: `variant="ghost"`. Below the real states, like every variant.
+ * @state destructive - Component-wide: `variant="destructive"`. Keeps the red under a base `pt`: `pt:root:destructive`.
+ * @state link - Component-wide: `variant="link"`. Below the real states, like every variant.
+ */
+export type ButtonVariantBuiltIn = 'primary' | 'outline' | 'secondary' | 'ghost' | 'destructive' | 'link';
+/** The built-in names at runtime, for the passthrough resolver. */
+export declare const BUTTON_VARIANTS: readonly ["primary", "outline", "secondary", "ghost", "destructive", "link"];
 /**
  * Variant type for `BbButton.variant`.
  *

package/dist/types/ButtonVariant.js

@@ -0,0 +1,11 @@
+//#region src/types/ButtonVariant.ts
+var e = [
+	"primary",
+	"outline",
+	"secondary",
+	"ghost",
+	"destructive",
+	"link"
+];
+//#endregion
+export { e as BUTTON_VARIANTS };

package/dist/types/CheckboxVariant.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The registered variant names: the built-in set, declared here, plus the
+ * app's own names, which the Vite plugin writes into the project's
+ * committed `bitboss-ui.d.ts` (`declare module 'bitboss-ui'`). Keys only;
+ * the value is always `true`, so a repeated default is never a conflict.
+ * The runtime list is `project-dts.ts`'s matching `DEFAULT_*` array, and
+ * a node test keeps the two equal.
+ * @internal
+ */
+export interface CheckboxVariantRegistry {
+    pill: true;
+    line: true;
+}
+export type CheckboxVariantFromRegistry = keyof CheckboxVariantRegistry;
+/**
+ * The built-in names as a literal union (Q76.7, Q76.11 d). The
+ * `pt:<part>:<variant>` ATTRIBUTE props are declared from it when the
+ * library is built; an app's own names are declared by the component's
+ * `variantPt()` mixin and typed by its `PtVariantAttrs` member, both from
+ * the registry.
+ *
+ * @state pill - On every part: `variant: 'pill'`. Merged after the part's base entry and before its states, so the real states still win.
+ * @state line - On every part: `variant: 'line'`. Below the real states, like every variant.
+ */
+export type CheckboxVariantBuiltIn = 'pill' | 'line';
+/** The built-in names at runtime, for the passthrough resolver. */
+export declare const CHECKBOX_VARIANTS: readonly ["pill", "line"];
+/**
+ * Variant type for the `variant` of `BbCheckboxGroup`: a tab-strip look on the
+ * group (Q76.11 d).
+ *
+ * Locked to registered variants — the built-in set (`pill`, `line`) plus
+ * any added via the vite plugin `checkboxVariants` option — so unknown names
+ * are a compile error. For a one-off, register it (recommended) or force it
+ * with a cast: the class `bb-checkbox-group__list--<variant>` is interpolated at
+ * runtime, so your CSS still applies.
+ */
+export type CheckboxVariantType = CheckboxVariantFromRegistry;

package/dist/types/CheckboxVariant.js

@@ -0,0 +1,4 @@
+//#region src/types/CheckboxVariant.ts
+var e = ["pill", "line"];
+//#endregion
+export { e as CHECKBOX_VARIANTS };

package/dist/types/CommonProps.d.ts

@@ -1,14 +1,15 @@
 import { ComponentPublicInstance } from 'vue';
 /**
- * An external element reference prop (activator/anchor): a DOM element, a Vue
- * component instance (its root element is resolved internally), or `null`.
+ * An external element reference prop (activator/anchor): a DOM element (an
+ * `<svg>` too, Q76.15), a Vue component instance (its root element is
+ * resolved internally), or `null`.
  *
  * The `Pick<…, '$el'>` arm keeps concretely typed component instances
  * assignable: instances with typed `$emit` signatures are not assignable to
  * the base `ComponentPublicInstance` type, but all of them expose `$el`,
  * which is what the internal DOM resolution consumes.
  */
-export type ElementOrComponentRef = HTMLElement | ComponentPublicInstance | Pick<ComponentPublicInstance, '$el'> | null;
+export type ElementOrComponentRef = HTMLElement | SVGElement | ComponentPublicInstance | Pick<ComponentPublicInstance, '$el'> | null;
 /**
  * Variant of {@link ElementOrComponentRef} for boundary props, which
  * additionally accept a CSS selector string.

package/dist/types/Config.d.ts

@@ -198,6 +198,13 @@ export type ResolvedConfig = Omit<EditableConfig, 'iconDefaultSizes' | 'dialogDe
         toast: Readonly<Record<string, string>>;
         alert: Readonly<Record<string, string>>;
     }>;
+    /**
+     * The app's OWN variant names per build-plugin option (`buttonVariants`,
+     * …), the built-ins left out. Build-time only, like `pt`: the components
+     * declare `pt:<part>:<name>` props from it (Q76.7), and the passthrough
+     * dev check knows the names.
+     */
+    readonly variantNames: Readonly<Record<string, readonly string[]>>;
 };
 /**
  * What `app.use(bitbossUiPlugin, …)` accepts: per-app runtime overrides of the

package/dist/types/ConfirmVariant.d.ts

@@ -12,6 +12,18 @@ export interface ConfirmVariantRegistry {
     destructive: true;
 }
 export type ConfirmVariantFromRegistry = keyof ConfirmVariantRegistry;
+/**
+ * The built-in names as a literal union (Q76.7). The `pt:<part>:<variant>`
+ * ATTRIBUTE props are declared from it when the library is built; an app's
+ * own names are declared by the component's `variantPt()` mixin and typed by
+ * its `PtVariantAttrs` member, both from the registry.
+ *
+ * @state default - Component-wide, from the message: `variant: 'default'`. Merged after the part's base entry and before its states, so the real states still win.
+ * @state destructive - Component-wide, from the message: `variant: 'destructive'`. Below the real states, like every variant.
+ */
+export type ConfirmVariantBuiltIn = 'default' | 'destructive';
+/** The built-in names at runtime, for the passthrough resolver. */
+export declare const CONFIRM_VARIANTS: readonly ["default", "destructive"];
 /**
  * Variant type for `BbConfirmMessage.variant`.
  *

package/dist/types/ConfirmVariant.js

@@ -0,0 +1,4 @@
+//#region src/types/ConfirmVariant.ts
+var e = ["default", "destructive"];
+//#endregion
+export { e as CONFIRM_VARIANTS };

package/dist/types/DropdownItemVariant.d.ts

@@ -12,6 +12,18 @@ export interface DropdownItemVariantRegistry {
     destructive: true;
 }
 export type DropdownItemVariantFromRegistry = keyof DropdownItemVariantRegistry;
+/**
+ * The built-in names as a literal union (Q76.7). The `pt:<part>:<variant>`
+ * ATTRIBUTE props are declared from it when the library is built; an app's
+ * own names are declared by the component's `variantPt()` mixin and typed by
+ * its `PtVariantAttrs` member, both from the registry.
+ *
+ * @state default - Per entry, on the entry parts: an entry with `variant: 'default'` or none. Merged after the part's base entry and before its states, so the real states still win.
+ * @state destructive - Per entry, on the entry parts: `variant: 'destructive'`. Below the real states, like every variant.
+ */
+export type DropdownItemVariantBuiltIn = 'default' | 'destructive';
+/** The built-in names at runtime, for the passthrough resolver. */
+export declare const DROPDOWN_ITEM_VARIANTS: readonly ["default", "destructive"];
 /**
  * Variant type for a dropdown `Item.variant`.
  *

package/dist/types/DropdownItemVariant.js

@@ -0,0 +1,4 @@
+//#region src/types/DropdownItemVariant.ts
+var e = ["default", "destructive"];
+//#endregion
+export { e as DROPDOWN_ITEM_VARIANTS };

package/dist/types/IndicatorVariant.d.ts

@@ -15,6 +15,21 @@ export interface IndicatorVariantRegistry {
     destructive: true;
 }
 export type IndicatorVariantFromRegistry = keyof IndicatorVariantRegistry;
+/**
+ * The built-in names as a literal union (Q76.7). The `pt:<part>:<variant>`
+ * ATTRIBUTE props are declared from it when the library is built; an app's
+ * own names are declared by the component's `variantPt()` mixin and typed by
+ * its `PtVariantAttrs` member, both from the registry.
+ *
+ * @state default - Component-wide: `variant: 'default'`. Merged after the part's base entry and before its states, so the real states still win.
+ * @state success - Component-wide: `variant: 'success'`. Below the real states, like every variant.
+ * @state info - Component-wide: `variant: 'info'`. Below the real states, like every variant.
+ * @state warning - Component-wide: `variant: 'warning'`. Below the real states, like every variant.
+ * @state destructive - Component-wide: `variant: 'destructive'`. Below the real states, like every variant.
+ */
+export type IndicatorVariantBuiltIn = 'default' | 'success' | 'info' | 'warning' | 'destructive';
+/** The built-in names at runtime, for the passthrough resolver. */
+export declare const INDICATOR_VARIANTS: readonly ["default", "success", "info", "warning", "destructive"];
 /**
  * Variant type for a `BbIndicator`'s `variant`.
  *

package/dist/types/IndicatorVariant.js

@@ -0,0 +1,10 @@
+//#region src/types/IndicatorVariant.ts
+var e = [
+	"default",
+	"success",
+	"info",
+	"warning",
+	"destructive"
+];
+//#endregion
+export { e as INDICATOR_VARIANTS };

package/dist/types/InputVariant.d.ts

@@ -13,6 +13,19 @@ export interface InputVariantRegistry {
     ghost: true;
 }
 export type InputVariantFromRegistry = keyof InputVariantRegistry;
+/**
+ * The built-in names as a literal union (Q76.7). The `pt:<part>:<variant>`
+ * ATTRIBUTE props are declared from it when the library is built; an app's
+ * own names are declared by the component's `variantPt()` mixin and typed by
+ * its `PtVariantAttrs` member, both from the registry.
+ *
+ * @state outline - On the field's parts: `variant: 'outline'`. Merged after the part's base entry and before its states, so the real states still win.
+ * @state secondary - On the field's parts: `variant: 'secondary'`. Below the real states, like every variant.
+ * @state ghost - On the field's parts: `variant: 'ghost'`. Below the real states, like every variant.
+ */
+export type InputVariantBuiltIn = 'outline' | 'secondary' | 'ghost';
+/** The built-in names at runtime, for the passthrough resolver. */
+export declare const INPUT_VARIANTS: readonly ["outline", "secondary", "ghost"];
 /**
  * Variant type for the `variant` prop of every text-like form control
  * (`BbTextInput`, `BbTextarea`, `BbNumberInput`, `BbSelect`, `BbTag`,

package/dist/types/InputVariant.js

@@ -0,0 +1,8 @@
+//#region src/types/InputVariant.ts
+var e = [
+	"outline",
+	"secondary",
+	"ghost"
+];
+//#endregion
+export { e as INPUT_VARIANTS };

package/dist/types/RadioVariant.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The registered variant names: the built-in set, declared here, plus the
+ * app's own names, which the Vite plugin writes into the project's
+ * committed `bitboss-ui.d.ts` (`declare module 'bitboss-ui'`). Keys only;
+ * the value is always `true`, so a repeated default is never a conflict.
+ * The runtime list is `project-dts.ts`'s matching `DEFAULT_*` array, and
+ * a node test keeps the two equal.
+ * @internal
+ */
+export interface RadioVariantRegistry {
+    pill: true;
+    line: true;
+}
+export type RadioVariantFromRegistry = keyof RadioVariantRegistry;
+/**
+ * The built-in names as a literal union (Q76.7, Q76.11 d). The
+ * `pt:<part>:<variant>` ATTRIBUTE props are declared from it when the
+ * library is built; an app's own names are declared by the component's
+ * `variantPt()` mixin and typed by its `PtVariantAttrs` member, both from
+ * the registry.
+ *
+ * @state pill - On every part: `variant: 'pill'`. Merged after the part's base entry and before its states, so the real states still win.
+ * @state line - On every part: `variant: 'line'`. Below the real states, like every variant.
+ */
+export type RadioVariantBuiltIn = 'pill' | 'line';
+/** The built-in names at runtime, for the passthrough resolver. */
+export declare const RADIO_VARIANTS: readonly ["pill", "line"];
+/**
+ * Variant type for the `variant` of `BbRadioGroup`: a tab-strip look on the
+ * group (Q76.11 d).
+ *
+ * Locked to registered variants — the built-in set (`pill`, `line`) plus
+ * any added via the vite plugin `radioVariants` option — so unknown names
+ * are a compile error. For a one-off, register it (recommended) or force it
+ * with a cast: the class `bb-radio-group__list--<variant>` is interpolated at
+ * runtime, so your CSS still applies.
+ */
+export type RadioVariantType = RadioVariantFromRegistry;

package/dist/types/RadioVariant.js

@@ -0,0 +1,4 @@
+//#region src/types/RadioVariant.ts
+var e = ["pill", "line"];
+//#endregion
+export { e as RADIO_VARIANTS };

package/dist/types/TabsVariant.d.ts

@@ -13,6 +13,19 @@ export interface TabsVariantRegistry {
     none: true;
 }
 export type TabsVariantFromRegistry = keyof TabsVariantRegistry;
+/**
+ * The built-in names as a literal union (Q76.7). The `pt:<part>:<variant>`
+ * ATTRIBUTE props are declared from it when the library is built; an app's
+ * own names are declared by the component's `variantPt()` mixin and typed by
+ * its `PtVariantAttrs` member, both from the registry.
+ *
+ * @state pill - On the strip's parts: `variant: 'pill'`. Merged after the part's base entry and before its states, so the real states still win.
+ * @state line - On the strip's parts: `variant: 'line'`. Below the real states, like every variant.
+ * @state none - On the strip's parts: `variant: 'none'`. Below the real states, like every variant.
+ */
+export type TabsVariantBuiltIn = 'pill' | 'line' | 'none';
+/** The built-in names at runtime, for the passthrough resolver. */
+export declare const TABS_VARIANTS: readonly ["pill", "line", "none"];
 /**
  * Variant type for the `variant` of `BbTabs` / `BbTabsList`.
  *

package/dist/types/TabsVariant.js

@@ -0,0 +1,8 @@
+//#region src/types/TabsVariant.ts
+var e = [
+	"pill",
+	"line",
+	"none"
+];
+//#endregion
+export { e as TABS_VARIANTS };

package/dist/types/ToastVariant.d.ts

@@ -15,6 +15,21 @@ export interface ToastVariantRegistry {
     destructive: true;
 }
 export type ToastVariantFromRegistry = keyof ToastVariantRegistry;
+/**
+ * The built-in names as a literal union (Q76.7). The `pt:<part>:<variant>`
+ * ATTRIBUTE props are declared from it when the library is built; an app's
+ * own names are declared by the component's `variantPt()` mixin and typed by
+ * its `PtVariantAttrs` member, both from the registry.
+ *
+ * @state default - Per toast, on its card parts: `variant: 'default'`. Merged after the part's base entry and before its states, so the real states still win.
+ * @state success - Per toast, on its card parts: `variant: 'success'`. Below the real states, like every variant.
+ * @state info - Per toast, on its card parts: `variant: 'info'`. Below the real states, like every variant.
+ * @state warning - Per toast, on its card parts: `variant: 'warning'`. Below the real states, like every variant.
+ * @state destructive - Per toast, on its card parts: `variant: 'destructive'`. Below the real states, like every variant.
+ */
+export type ToastVariantBuiltIn = 'default' | 'success' | 'info' | 'warning' | 'destructive';
+/** The built-in names at runtime, for the passthrough resolver. */
+export declare const TOAST_VARIANTS: readonly ["default", "success", "info", "warning", "destructive"];
 /**
  * Variant type for a toast's `variant`.
  *

package/dist/types/ToastVariant.js

@@ -0,0 +1,10 @@
+//#region src/types/ToastVariant.ts
+var e = [
+	"default",
+	"success",
+	"info",
+	"warning",
+	"destructive"
+];
+//#endregion
+export { e as TOAST_VARIANTS };

package/dist/types/TooltipVariant.d.ts

@@ -12,6 +12,18 @@ export interface TooltipVariantRegistry {
     destructive: true;
 }
 export type TooltipVariantFromRegistry = keyof TooltipVariantRegistry;
+/**
+ * The built-in names as a literal union (Q76.7). The `pt:<part>:<variant>`
+ * ATTRIBUTE props are declared from it when the library is built; an app's
+ * own names are declared by the component's `variantPt()` mixin and typed by
+ * its `PtVariantAttrs` member, both from the registry.
+ *
+ * @state default - Component-wide: `variant: 'default'`. Merged after the part's base entry and before its states, so the real states still win.
+ * @state destructive - Component-wide: `variant: 'destructive'`. Below the real states, like every variant.
+ */
+export type TooltipVariantBuiltIn = 'default' | 'destructive';
+/** The built-in names at runtime, for the passthrough resolver. */
+export declare const TOOLTIP_VARIANTS: readonly ["default", "destructive"];
 /**
  * Variant type for `BbTooltip.variant`.
  *

package/dist/types/TooltipVariant.js

@@ -0,0 +1,4 @@
+//#region src/types/TooltipVariant.ts
+var e = ["default", "destructive"];
+//#endregion
+export { e as TOOLTIP_VARIANTS };

package/dist/types/passthrough.d.ts

@@ -19,7 +19,8 @@
  * NOTHING HERE IS IMPORTABLE from 'bitboss-ui', by ruling (Q52.7): no
  * `import type { PtValue }`, no deep import of this file. In app code, type a
  * `pt` value through the component it is for. The object form's keys drop the
- * `pt:` prefix, and a per-item function gets `{ item, <state>: boolean, … }`:
+ * `pt:` prefix, and a per-item function gets `{ item, <state>: boolean, … }`
+ * (plus `variant` where the row has one, `known` on a select's rows):
  *
  *   export const invoicePt = {
  *     row: ({ item, highlighted }) => item.overdue && !highlighted && 'bg-red-50',
@@ -49,7 +50,8 @@ export type PtValue = string | {
  * A per-item passthrough function — what a ROW part (`item`, `option`, `row`
  * and their `itemText` / `itemIcon` / `itemDescription`) accepts on the
  * instance beside a plain `PtValue`: called once per rendered row with that
- * row's raw `item` and one boolean per state, its result is merged LAST
+ * row's raw `item`, one boolean per state and the row's facts (its `variant`),
+ * its result is merged LAST
  * (after every `part:state` entry) through the same `mergeProps` + deduper
  * path; a falsy result leaves the cached binding untouched. Allowed in the
  * `pt` object and the `:pt:<part>` attribute only — never on a `part:state`
@@ -66,18 +68,28 @@ export type PtValue = string | {
  * consumers on TypeScript 5.0–5.3 still read the declarations.
  */
 export type PtNoInfer<T> = [T][T extends unknown ? 0 : never];
-export type PtItemFn<Item, State extends string> = (ctx: PtItemCtx<Item, State>) => PtItemResult;
+export type PtItemFn<Item, State extends string, Variant extends string = never, Row = {
+    readonly item: Item;
+}> = (ctx: PtItemCtx<Item, State, Variant, Row>) => PtItemResult;
 /**
  * What a per-item function receives: the row's raw `item` — the element of
- * `items` this row renders — and one boolean per state of the component, on
- * for this row (the per-node ones and the component-level ones), so a
- * function destructures what it reads: `({ item, selected }) => …`. States
- * only: the component's props are in scope where the function is written.
+ * `items` this row renders — one boolean per state of the component, on for
+ * this row (the per-node ones and the component-level ones), and the row's
+ * facts: today its `variant`, a typed string, on a component whose rows have
+ * one (`({ item, variant, selected }) => variant === 'destructive' && …`). A
+ * function destructures what it reads. The component's props are in scope
+ * where the function is written, so they are not repeated here. `Row` is the
+ * `item` half when the row can be something else than an element of `items`:
+ * a select's `{ known, item }` (Q77.7), a `known-items` stand-in or the option.
  */
-export type PtItemCtx<Item, State extends string> = {
+export type PtItemCtx<Item, State extends string, Variant extends string = never, Row = {
     readonly item: Item;
-} & {
+}> = Row & {
     readonly [S in State]: boolean;
+} & PtItemFacts<Variant>;
+/** The per-row facts beside the states: `variant`, when the component's rows have one. */
+export type PtItemFacts<Variant extends string> = [Variant] extends [never] ? unknown : {
+    readonly variant: Variant;
 };
 /** What a per-item function returns: a value, or nothing (`false` / `null` / `undefined` leave the row as it was). */
 export type PtItemResult = PtValue | false | null | undefined;
@@ -88,10 +100,12 @@ export type PtItemResult = PtValue | false | null | undefined;
  * inline — the SFC resolver reads only a literal function type as `Function`,
  * see PASSTHROUGH.md T23.)
  */
-export type PtItemMap<Part extends string, ItemPart extends Part, State extends string, Item> = {
-    [K in Exclude<Part, ItemPart> | `${Part}:${State}`]?: PtValue;
+export type PtItemMap<Part extends string, ItemPart extends Part, State extends string, Item, Variant extends string = never, Row = {
+    readonly item: Item;
+}> = {
+    [K in Exclude<Part, ItemPart> | `${Part}:${State}` | `${ItemPart}:${Variant}`]?: PtValue;
 } & {
-    [K in ItemPart]?: PtValue | PtItemFn<Item, State>;
+    [K in ItemPart]?: PtValue | PtItemFn<Item, State, Variant, Row>;
 };
 /** What JSON can carry — the only thing a build-time map ships. */
 type PtJson = string | number | boolean | null | PtJson[] | {
@@ -111,6 +125,28 @@ export type PtDataValue = string | {
 export type PtDataMap<Part extends string, State extends string> = {
     [K in Part | `${Part}:${State}`]?: PtDataValue;
 };
+/**
+ * A build-time map's variant keys (Q76.7): `part:<variant>` for every
+ * registered name, an app's own included (`Variant` is `keyof` the registry).
+ */
+export type PtVariantDataMap<Part extends string, Variant extends string> = {
+    [K in `${Part}:${Variant}`]?: PtDataValue;
+};
+/** `brand-strong` → `brandStrong`: how Vue (and vue-tsc) store a kebab prop word. */
+export type PtCamelize<S extends string> = S extends `${infer Head}-${infer Tail}` ? `${Head}${PtCamelize<Capitalize<Tail>>}` : S;
+/**
+ * The `pt:<part>:<variant>` ATTRIBUTES of every registered variant (Q76.7
+ * part 2), an app's own names included (`Variant` is `keyof` the registry the
+ * app's `bitboss-ui.d.ts` augments). A component intersects it behind
+ * a `@vue-ignore` comment: Vue's SFC resolver cannot expand `keyof` an interface
+ * into runtime props, and does not need to — the built-in names are declared
+ * props, an app's own come from the `variantPt()` mixin at runtime. vue-tsc
+ * reads it, so `pt:item:warning="…"` type-checks once `warning` is
+ * registered, and a typo does not.
+ */
+export type PtVariantAttrs<Part extends string, Variant extends string> = {
+    [K in `pt:${Part}:${Variant | PtCamelize<Variant>}`]?: PtValue;
+};
 /** `part` or `part:state` — the key shape shared by the object form and the global map. */
 export type PtKey<Part extends string, State extends string> = Part | `${Part}:${State}`;
 /** The object form, `:pt="{ icon: '…', 'icon:loading': '…' }"`. */
@@ -160,7 +196,9 @@ export type PtBindings<Part extends string, State extends string = string> = Par
      * The third argument is the row's raw item, for a per-item function on
      * the part (`PtItemFn`); leave it out on a part that has no item.
      */
-    part?: (part: Part, states: Partial<Record<State, boolean>>, item?: unknown) => Record<string, unknown>;
+    part?: (part: Part, states: Partial<Record<State, boolean>>, item?: unknown, 
+    /** A per-node variant (a dropdown entry's). */
+    variant?: string) => Record<string, unknown>;
     /**
      * The host's attributes and listeners with the resolved `root` (a `class`
      * inside it), for an internal component that renders the host's root —
@@ -177,7 +215,7 @@ export type PtBindings<Part extends string, State extends string = string> = Par
  * an error shows red on a disabled field, a hover shows over a selection).
  * Enforced by `passthrough-ladder.node.test.ts`.
  */
-export declare const PT_STATE_LADDER: readonly ["hasValue", "value", "placeholder", "nearLimit", "atLimit", "empty", "outside", "today", "inRange", "sorted", "sortedDesc", "selected", "rangeStart", "rangeEnd", "checked", "indeterminate", "pressed", "readonly", "disabled", "warnings", "errors", "active", "expanded", "open", "fullscreen", "focused", "focusVisible", "highlighted", "loading"];
+export declare const PT_STATE_LADDER: readonly ["hasValue", "value", "placeholder", "nearLimit", "atLimit", "empty", "outside", "today", "inRange", "activeLink", "exactActiveLink", "sorted", "sortedDesc", "selected", "rangeStart", "rangeEnd", "checked", "indeterminate", "pressed", "readonly", "disabled", "warnings", "errors", "active", "expanded", "open", "fullscreen", "focused", "focusVisible", "highlighted", "loading"];
 export type PtState = (typeof PT_STATE_LADDER)[number];
 /**
  * The states every form control shares, in ladder order.
@@ -245,7 +283,7 @@ export declare const COUNTER_PT_STATES: readonly ["nearLimit", "atLimit"];
 export type FieldInputPtPart = 'box' | 'icon' | 'spinner' | 'prefix' | 'suffix' | 'clear';
 /**
  * The parts of a toggle (checkbox, radio, switch): no box, no affixes — the
- * drawn glyph is `icon`. The visually hidden native input is deliberately NOT a
+ * drawn glyph is `icon`. The invisible native input under it is deliberately NOT a
  * part (owner, 2026-09-14): it is never painted, and `input` beside `icon`
  * invited styling the wrong node.
  *
@@ -350,6 +388,36 @@ export type GroupPtMap<Item = any> = {
 } & {
     [K in GroupRowPtPart]?: PtValue | PtItemFn<Item, GroupPtState>;
 };
+/**
+ * A choice group's field parts (BbRadioGroup, BbCheckboxGroup): an option
+ * group's, plus the `variant="pill" | "line"` indicator (Q76.11 d).
+ *
+ * @part root - The group's container (the fieldset).
+ * @part legend - The group's heading — the fieldset `<legend>` (the `legend` prop).
+ * @part description - The muted line under the legend (the `description` prop).
+ * @part message - The errors / warnings line. A node of its own: it can show at the same time as `hint`.
+ * @part hint - The helper line (the `hint` prop), shown on focus, or always with `persistent-hint`.
+ * @part list - The node that lays the rows out (flex + wrap, gaps on `--gap` / `--row-gap`): `pt:list="grid grid-cols-3"` re-lays them, `pt:list="[--gap:8px]"` tightens them. With a `variant`, the tab strip. Takes the group-wide states only.
+ * @part indicator - With a `variant`: the shape under the checked option, BbTabs' indicator — the sliding pill or bar of a radio group, a checkbox group's pill per run of adjacent picks (or bar per pick). Takes the group-wide states only.
+ */
+export type ChoiceFieldPtPart = 'root' | 'legend' | 'description' | 'message' | 'hint' | 'list' | 'indicator';
+/**
+ * A choice group's parts: an option group's, plus `indicator`.
+ *
+ * @part indicator - With a `variant`: the shape under the checked option, BbTabs' indicator — the sliding pill or bar of a radio group, a checkbox group's pill per run of adjacent picks (or bar per pick). Takes the group-wide states only.
+ */
+export type ChoicePtPart = GroupPtPart | 'indicator';
+export declare const CHOICE_PT_PARTS: readonly ["root", "legend", "description", "message", "hint", "list", "item", "icon", "label", "itemDescription", "indicator"];
+/**
+ * The object form of a choice group's `pt`: an option group's keys and the
+ * `indicator`. Each group adds its `variant` as a state on every part
+ * (Q76.7), from its own registry.
+ */
+export type ChoicePtMap<Item = any> = {
+    [K in ChoiceFieldPtPart | `${ChoiceFieldPtPart}:${GroupWidePtState}` | `${GroupRowPtPart}:${GroupPtState}`]?: PtValue;
+} & {
+    [K in GroupRowPtPart]?: PtValue | PtItemFn<Item, GroupPtState>;
+};
 /**
  * The states of an option group (owner ruling 2026-09-15). Group-wide, on
  * every part: `hasValue` (something is chosen), `readonly`, `loading` (the

package/dist/types/passthrough.js

@@ -63,7 +63,7 @@ var e = [
 	"checked",
 	"focused",
 	"focusVisible"
-], l = [
+], l = [...o, "indicator"], u = [
 	"hasValue",
 	"checked",
 	"readonly",
@@ -75,4 +75,4 @@ var e = [
 	"loading"
 ];
 //#endregion
-export { a as CHECKABLE_PT_STATES, n as COUNTER_PT_STATES, e as FORM_CONTROL_PT_STATES, o as GROUP_PT_PARTS, l as GROUP_PT_STATES, s as GROUP_ROW_PT_PARTS, c as GROUP_ROW_PT_STATES, t as TEXT_CONTROL_PT_PARTS, r as TOGGLE_PT_PARTS, i as TOGGLE_PT_STATES };
+export { a as CHECKABLE_PT_STATES, l as CHOICE_PT_PARTS, n as COUNTER_PT_STATES, e as FORM_CONTROL_PT_STATES, o as GROUP_PT_PARTS, u as GROUP_PT_STATES, s as GROUP_ROW_PT_PARTS, c as GROUP_ROW_PT_STATES, t as TEXT_CONTROL_PT_PARTS, r as TOGGLE_PT_PARTS, i as TOGGLE_PT_STATES };