@yahoo/uds-v5-wip 1.40.0 → 1.41.0

package/dist/config/dist/Props.d.ts

@@ -3,6 +3,7 @@ import { ComponentConfigValue, HtmlTag, LayerInput, PropBinding } from "./compon
 import { ComponentPropsWithoutRef, HTMLAttributes, JSX } from "react";
 
 //#region ../config/dist/Props.d.ts
+//#region src/Props.d.ts
 /**
  * Resolve the native HTML-attribute surface for the config's root tag.
  *
@@ -65,5 +66,9 @@ interface DataAttrs {
 type Props<TConfig extends ComponentConfigValue<Record<string, LayerInput>, Record<string, PropBinding>, HtmlTag | undefined>> = TConfig extends ComponentConfigValue<Record<string, LayerInput>, infer TProps extends Record<string, PropBinding>, infer TTag extends HtmlTag | undefined> ? Prettify<PropsFromConfig<TProps> & Omit<ElementProps<TTag>, keyof TProps> & DataAttrs & {
   as?: string;
 }> : never;
+/**
+ * `Props<typeof boxConfig>` for the common 'use the config's inferred
+ * type' invocation. Keeps `box.tsx` from having to repeat the generic.
+ */
 //#endregion
 export { Props };

package/dist/config/dist/component-config.d.ts

@@ -2,6 +2,7 @@ import { ComponentRef, CompositeRef, RegisteredComponents, StylePropRef } from "
 import { ReactNode } from "react";
 
 //#region ../config/dist/component-config.d.ts
+//#region src/component-config.d.ts
 /**
  * HTML tag literal. The TypeScript type is `string` (any tag name);
  * runtime renders it via `React.createElement(tag, ...)`.
@@ -158,6 +159,14 @@ type PrimitivePropBinding = StylePropShorthand | VerbosePropBinding;
  * tighter `VerbosePropBinding`.
  */
 type PropBinding = PrimitivePropBinding;
+/**
+ * Marker for a boolean JSX prop. Use inside the `props` block:
+ *
+ *     props: {
+ *       loading: bool(),
+ *       disabled: bool(),
+ *     }
+ */
 /**
  * Branded shape returned by `defineComponent({...})`. Carries `layers`,
  * `props`, AND a phantom `__tag` slot as const-narrowed types so
@@ -183,5 +192,10 @@ interface ComponentConfigValue<TLayers extends Record<string, LayerInput>, TProp
   readonly props?: TProps;
   readonly defaultProps?: Record<string, unknown>;
 }
+/**
+ * The bundle passed to the render function for each layer — a ready-to-
+ * spread object with `className` and any forwarded attrs. The render
+ * function destructures `props.<layerName>` into the JSX position.
+ */
 //#endregion
 export { BoolMarker, ComponentConfigValue, ComposedLayer, CompositeBinding, EnumMarker, HtmlTag, LayerInput, PrimitiveLayer, PrimitivePropBinding, PropBinding, RootTag, SingleLayerCompositeBinding, StylePropBinding, StylePropShorthand, SurfaceForward, VerbosePropBinding };

package/dist/config/dist/component-refs.d.ts

@@ -1,4 +1,5 @@
 //#region ../config/dist/component-refs.d.ts
+//#region src/component-refs.d.ts
 /**
  * Augmentable registries + template-literal ref types for the
  * component-API surface.
@@ -63,6 +64,14 @@ interface RegisteredStyleProps {}
  * call.
  */
 interface RegisteredComposites {}
+/**
+ * Registered motion-preset names. Each key is the preset identifier
+ * (`'{fadeIn}'`); value is `void`.
+ *
+ * Populated by codegen from `uds.config.ts`'s `.defineMotion({...})`
+ * (motion has no separate `.registerMotion` step today; the entries
+ * come directly from `defineMotion` keys).
+ */
 /**
  * Brace-wrapped reference to a registered React component. Falls open
  * to `'{${string}}'` when the registry is unaugmented (e.g. inside
@@ -81,5 +90,9 @@ type StylePropRef = [keyof RegisteredStyleProps] extends [never] ? `{${string}}`
  * when unaugmented.
  */
 type CompositeRef = [keyof RegisteredComposites] extends [never] ? `{${string}}` : `{${Extract<keyof RegisteredComposites, string>}}`;
+/**
+ * Brace-wrapped reference to a registered motion preset. Falls open
+ * when unaugmented.
+ */
 //#endregion
 export { ComponentRef, CompositeRef, RegisteredComponents, RegisteredComposites, RegisteredStyleProps, StylePropRef };

package/dist/config/dist/component-resolution.d.ts

@@ -1 +1 @@
-import { ComponentsConfig } from "@uds/types";
+export { };

package/dist/config/dist/consts/defaultColors.d.ts

@@ -1,4 +1,5 @@
 //#region ../config/dist/consts/defaultColors.d.ts
+//#region src/consts/defaultColors.d.ts
 declare const defaultColors: {
   inherit: string;
   current: string;
@@ -247,6 +248,6 @@ declare const defaultColors: {
   'rose-800': string;
   'rose-900': string;
   'rose-950': string;
-};
+}; //#endregion
 //#endregion
 export { defaultColors };

package/dist/config/dist/createConfig.d.ts

@@ -1,11 +1,12 @@
 import { ComponentConfigValue } from "./component-config.js";
 import { BoundComponent } from "./defineComponent.js";
 import { AnyStyleProp } from "./defineStyleProp.js";
-import { ResolvedStyleProp } from "./resolveStyleProp.js";
 import { TokenType, VarsConfig } from "./types.js";
+import { ResolvedStyleProp } from "./resolveStyleProp.js";
 import { BaseModifierProp, ComponentsConfig, CompositeStylesConfig, ConfigurableProp, ModifierProp, MotionPreset, RemotionComponentDef, RemotionConfig, RemotionTransitionDef } from "@uds/types";
 
 //#region ../config/dist/createConfig.d.ts
+//#region src/createConfig.d.ts
 type MotionPresetsDef = Record<string, MotionPreset>;
 type MotionAliasValue<TMotion> = TMotion extends Record<string, infer V> ? Extract<V, string> : never;
 type EmptyMotion = {};
@@ -78,6 +79,12 @@ type GetModifierFromInput<I extends ModesInput> = { [SetKey in keyof I]: { [OptK
 } ? M extends ModifierNameShape ? M : never : OptKey extends string ? `_${OptKey}` : never }[keyof I[SetKey]['options']] }[keyof I];
 /** Reject any input whose derived/explicit modifiers collide with reserved names. */
 type CheckForReservedModifiersInput<I extends ModesInput> = true extends HasReservedModifier<GetModifierFromInput<I>> ? 'ERROR: Cannot use reserved modifier names from ModifierProp. Please use a different modifier name.' : I;
+/**
+ * Convert the authored object-keyed input into the internal `ModeGroup[]` shape.
+ * Derives `_${optionKey}` modifiers when no explicit `modifier` is provided.
+ * Never sets `default: true` — the new API has no concept of a default option;
+ * downstream consumers treat "no option active" as the implicit default.
+ */
 interface ModifierDef {
   modifier: ModifierNameShape;
   selector: string;
@@ -157,6 +164,7 @@ type VarsToTokens<TVars extends VarsConfig> = { [K in keyof TVars]: { [T in Excl
 type MergeTokens<A, B> = { [K in keyof A | keyof B]: K extends keyof B ? K extends keyof A ? A[K] & B[K] : B[K] : K extends keyof A ? A[K] : never };
 /** Build a structured token reference object from atomic tokens */
 declare function buildTokenReference(atomic: AtomicToken<ModifierNameShape>[], configPrefix: string): Record<string, Record<string, string>>;
+/** Build a structured composite-styles reference object for use in defineModifiers context */
 /** Global styles definition — CSS selector → style props */
 type GlobalStylesDef = Record<string, Record<string, any>>;
 /** CSS properties for the example wrapper element */
@@ -349,6 +357,10 @@ interface UdsConfig<TModifier extends ModifierNameShape = ModifierProp, TTokens
 type AnyUdsConfig = UdsConfig<ModifierNameShape, any, any, any, any, any, any>;
 /** Extract the raw config data from a builder instance */
 declare function resolveConfig(config: AnyUdsConfig): UdsConfigData;
+/**
+ * Resolve configuration with all token references replaced by their raw values.
+ * Useful for tools that need the actual values (e.g. anatomy generation).
+ */
 declare function createConfigBuilder<TModifier extends ModifierNameShape = ModifierProp, TTokens = EmptyTokens, TMotion = EmptyMotion, TExt extends Record<string, any> = {}, TCompositeStyles = EmptyCompositeStyles, TModeModifiers extends ModifierNameShape = never, TVars extends VarsConfig = EmptyVars>(data: UdsConfigData, extensions?: TExt): UdsConfig<TModifier, TTokens, TMotion, TExt, TCompositeStyles, TModeModifiers, TVars> & TExt;
 interface InterpolateMarker {
   __type: 'interpolate';

package/dist/config/dist/createConfig.js

@@ -4,9 +4,9 @@ import "../../utils/dist/index.js";
 import { getConfigurablePropMapping } from "../../core/dist/configurable-prop-helpers.js";
 import "../../core/dist/index.js";
 import { buildMotionReference, resolveComponentMotionAliases, validateComponentVariants } from "./component-resolution.js";
-import { applyPresetToData, deepMerge, mergeAtomic } from "./preset-merge.js";
 import { resolveTokenType, sniffTokenTypeFromValue } from "./resolveTokenTypes.js";
 import { resolveStyleProp } from "./resolveStyleProp.js";
+import { applyPresetToData, deepMerge, mergeAtomic } from "./preset-merge.js";
 //#region ../config/dist/createConfig.js
 /** biome-ignore-all lint/suspicious/noExplicitAny: necessary for dynamic builder to work correctly */
 /**

package/dist/config/dist/defineComponent.d.ts

@@ -3,6 +3,7 @@ import { Props } from "./Props.js";
 import { ReactNode } from "react";
 
 //#region ../config/dist/defineComponent.d.ts
+//#region src/defineComponent.d.ts
 /**
  * A React component bound to a `defineComponent` config, with the
  * source config attached as a phantom type slot. Tools (codegen,
@@ -13,5 +14,11 @@ import { ReactNode } from "react";
 type BoundComponent<TConfig extends ComponentConfigValue<Record<string, LayerInput>, any, HtmlTag | undefined>, TExtra extends Record<string, unknown> = {}> = React.FC<Props<TConfig> & TExtra> & {
   readonly __config: TConfig;
 };
+/**
+ * A `defineComponent({...})` config value with a `.render(fn)` builder
+ * method bolted on. The builder is non-enumerable so JSON serialization
+ * still produces pure data — codegen can read `__kind`, `layers`,
+ * `props`, and `defaultProps` without seeing the render hook.
+ */
 //#endregion
 export { BoundComponent };

package/dist/config/dist/defineStyleProp.d.ts

@@ -1,4 +1,4 @@
-import { CssValue, CssValueTypeName } from "./types/css-values.js";
+import { CssValueTypeName } from "./types/css-values.js";
 
 //#region ../config/dist/defineStyleProp.d.ts
 /** Runtime input type for `toCss` based on the entry's `type`. */
@@ -22,10 +22,20 @@ type ArbitraryEntry = { [T in CssValueTypeName]: {
  *  - An array of {@link ArbitraryEntry} for multi-shape acceptance.
  */
 type ArbitrarySpec = CssValueTypeName | readonly ArbitraryEntry[];
+/**
+ * The literal-keyword subset of values a property accepts, derived from
+ * {@link CssPropertyValues}[P]. For custom CSS properties (`--*`) the value
+ * type is governed by the required `cssType` field instead, so any string
+ * is accepted at the type level.
+ */
 type StylePropMetadata = {
   label?: string;
   description?: string;
 };
+/**
+ * A finalized style prop. Returned by `defineStyleProp(spec).metadata(meta)`.
+ * Consumers wrap these in `uds.registerStyleProps({ <propName>: ... })`.
+ */
 /**
  * Structurally-loose form of {@link StyleProp}. Any concrete `StyleProp<P>`
  * is assignable to this. Used at registration / resolution boundaries where
@@ -41,5 +51,14 @@ interface AnyStyleProp {
   readonly cssType?: CssValueTypeName;
   readonly metadata: StylePropMetadata;
 }
+/**
+ * Return shape of {@link defineStyleProp}. The `metadata` field doubles as
+ * a callable chain: read it to access `{ label?, description? }` (both
+ * optional, so an unset metadata reads `undefined` for either field) or
+ * call it as `.metadata({ label, description })` to attach metadata and
+ * get back a plain {@link StyleProp}. A function satisfies the
+ * {@link StylePropMetadata} structural shape because both fields are
+ * optional, so the dual nature is type-safe.
+ */
 //#endregion
 export { AnyStyleProp, ArbitraryEntry, ArbitrarySpec, StylePropMetadata };

package/dist/config/dist/defineStyleProp.js

@@ -1,25 +1,39 @@
 //#region ../config/dist/defineStyleProp.js
 const CUSTOM_PROPERTY_PREFIX = "--";
 /**
-* Author a style prop. Returns a builder whose `.metadata({...})` finalizes
-* the {@link StyleProp} record. Pure — no global registration.
+* Author a style prop. Returns a {@link StyleProp} directly so callers can
+* skip the `.metadata({...})` chain when there's nothing to attach:
+*
+* ```ts
+* defineStyleProp({ cssProperty: 'flex-direction', classPrefix: 'flex', values: ['row', 'col'] })
+* ```
+*
+* The returned object still supports `.metadata({...})` for the common
+* case where you want to attach a label/description — the chain returns a
+* plain {@link StyleProp} with the metadata baked in. Pure — no global
+* registration.
 */
 function defineStyleProp(spec) {
 	const { cssProperty, classPrefix, values, arbitrary, cssType } = spec;
 	const isCustomProperty = cssProperty.startsWith(CUSTOM_PROPERTY_PREFIX);
 	if (isCustomProperty && cssType === void 0) throw new Error(`defineStyleProp: cssType is required for custom CSS properties (got cssProperty=${JSON.stringify(cssProperty)}).`);
 	if (!isCustomProperty && cssType !== void 0) throw new Error(`defineStyleProp: cssType is only allowed for custom CSS properties (--*). Got cssProperty=${JSON.stringify(cssProperty)} with cssType=${JSON.stringify(cssType)}.`);
-	return { metadata(meta = {}) {
-		return {
-			kind: "styleProp",
-			cssProperty,
-			classPrefix,
-			values: values ?? [],
-			arbitrary,
-			cssType,
-			metadata: meta
-		};
-	} };
+	const baseFields = {
+		kind: "styleProp",
+		cssProperty,
+		classPrefix,
+		values: values ?? [],
+		arbitrary,
+		cssType
+	};
+	const metadata = (meta = {}) => ({
+		...baseFields,
+		metadata: meta
+	});
+	return {
+		...baseFields,
+		metadata
+	};
 }
 //#endregion
 export { defineStyleProp };

package/dist/config/dist/index.d.ts

@@ -4,9 +4,9 @@ import { Props } from "./Props.js";
 import { BoundComponent } from "./defineComponent.js";
 import { ColorFn, ColorKeyword, CssAngle, CssColor, CssLength, CssPercentage, CssRatio, CssTime, CssValue, CssValueTypeName, HexColor, HslColor, RgbColor } from "./types/css-values.js";
 import { AnyStyleProp, ArbitraryEntry, ArbitrarySpec, StylePropMetadata } from "./defineStyleProp.js";
-import { ResolvedStyleProp, ResolvedToken } from "./resolveStyleProp.js";
 import { TokenType, VarGroupDef, VarTokenDef, VarsConfig } from "./types.js";
 import { AtomicToken, BuildOptions, CheckForReservedModifiersInput, ComponentConfig, DefineComponentInput, DefineComponentMotionInput, ExampleDef, ExampleEntryDef, ExampleLayoutStyles, GetModifierFromInput, GlobalStylesDef, InterpolateMarker, ModeGroup, ModeOption, ModeOptionInput, ModeSetInput, ModesInput, ModifierDef, MotionPresetsDef, SingleComponentDef, UdsConfig, UdsConfigData, buildTokenReference, createConfigBuilder, darker, lighter, resolveConfig } from "./createConfig.js";
+import { ResolvedStyleProp, ResolvedToken } from "./resolveStyleProp.js";
 import { defaultColors } from "./consts/defaultColors.js";
 import { SerializedConfig, TokenRef, buildReverseMap, deserializeConfig, serializeConfig } from "./serialize.js";
 import { ComponentsConfig as ComponentsConfig$1 } from "@uds/types";

package/dist/config/dist/index.js

@@ -2,11 +2,11 @@ import "./component-resolution.js";
 import "./consts/defaultColors.js";
 import "./createComponent.js";
 import "./propertyAcceptedTypes.js";
+import "./refs.js";
 import "./resolveTokenTypes.js";
 import "./resolveStyleProp.js";
 import "./createConfig.js";
 import "./defineComponent.js";
 import "./defineStyleProp.js";
 import "./propertyGroups.js";
-import "./refs.js";
 import "./serialize.js";

package/dist/config/dist/refs.js

@@ -1 +1,66 @@
+import { kebabCase } from "../../utils/dist/string-utils/kebabCase.js";
+import { safeTokenName } from "../../utils/dist/string-utils/cssVar.js";
 import "../../utils/dist/index.js";
+//#region ../config/dist/refs.js
+/**
+* Token references — `'{namespace/key}'` braces in token values.
+*
+* Authors can point one token at another via a brace-wrapped path:
+*
+*   defineVars({
+*     spectrum: { 'blue/500': { value: '#1167f4' } },
+*     color:    { brand:      { value: '{spectrum/blue/500}' } },
+*   })
+*
+* At CSS-declaration time this expands to a CSS variable alias:
+*
+*   --uds-spectrum-blue-500: #1167f4;
+*   --uds-color-brand: var(--uds-spectrum-blue-500);
+*
+* Refs are a purely syntactic transform — no graph walk, no cycle
+* detection. CSS handles aliasing (and any cascade cycles) at runtime.
+* Refs that don't match a declared token resolve to a `var(...)` that
+* has no `:root` declaration; the browser falls back to the property's
+* initial value.
+*
+* Consumption is unchanged: `tokens.color.brand` in component configs
+* still resolves to `var(--uds-color-brand)`, regardless of whether the
+* brand value itself is a literal or a ref.
+*/
+const REF_PATTERN = /^\{([^/{}]+)\/([^{}]+)\}$/;
+/**
+* Parse a value as a token ref. Returns `null` when the value isn't a
+* brace-wrapped ref of the form `{namespace/name}`. The `name` portion
+* may contain additional slashes — only the first slash is treated as
+* the namespace separator.
+*/
+function parseTokenRef(value) {
+	const match = REF_PATTERN.exec(value);
+	if (!match) return null;
+	const namespace = match[1];
+	const name = match[2];
+	if (!namespace || !name) return null;
+	return {
+		namespace,
+		name
+	};
+}
+/**
+* Resolve a token value to its CSS form. If `value` is a token ref, returns
+* the corresponding `var(--<prefix>-<namespace>-<name>)` string. Otherwise
+* returns the value unchanged.
+*
+* The CSS variable name is built the same way `defineVars` builds its `:root`
+* declarations: `kebabCase` on the namespace, `safeTokenName` on the token
+* name. So `{spectrum/blue/500}` resolves to `var(--uds-spectrum-blue-500)`
+* (matching the namespace's own emitted variable name).
+*/
+function resolveTokenRef(value, configPrefix) {
+	const ref = parseTokenRef(value);
+	if (!ref) return value;
+	const cssPrefix = kebabCase(ref.namespace);
+	const cssName = safeTokenName(ref.name);
+	return `var(${configPrefix ? `--${configPrefix}-${cssPrefix}-${cssName}` : `--${cssPrefix}-${cssName}`})`;
+}
+//#endregion
+export { parseTokenRef, resolveTokenRef };

package/dist/config/dist/resolveStyleProp.d.ts

@@ -1,6 +1,7 @@
 import { CssValueTypeName } from "./types/css-values.js";
 import { ArbitrarySpec, StylePropMetadata } from "./defineStyleProp.js";
 //#region ../config/dist/resolveStyleProp.d.ts
+//#region src/resolveStyleProp.d.ts
 interface ResolvedToken {
   /** The token's raw key, e.g. `'brand'`. */
   readonly name: string;
@@ -58,5 +59,11 @@ interface ResolvedStyleProp {
   readonly arbitrary: ArbitrarySpec | undefined;
   readonly metadata: StylePropMetadata;
 }
+/**
+ * Structurally-loose input shape for the resolver. Any `StyleProp<P>` from
+ * `defineStyleProp` is assignable to this. Defined locally so the
+ * resolver's signature doesn't expand `ValuesEntry<P>` over the full CSS
+ * property union (TS2590).
+ */
 //#endregion
 export { ResolvedStyleProp, ResolvedToken };

package/dist/config/dist/resolveStyleProp.js

@@ -1,6 +1,7 @@
 import { safeTokenName } from "../../utils/dist/string-utils/cssVar.js";
 import "../../utils/dist/index.js";
 import { isTokenAcceptedByProperty } from "./propertyAcceptedTypes.js";
+import { resolveTokenRef } from "./refs.js";
 import { sniffTokenTypeFromValue } from "./resolveTokenTypes.js";
 //#region ../config/dist/resolveStyleProp.js
 /**
@@ -194,18 +195,8 @@ function resolveStyleProp(propName, styleProp, config) {
 			const aliasKey = aliasEntry.alias;
 			const aliasMapKey = typeof aliasKey === "string" ? aliasKey : String(aliasKey);
 			let resolvedValue;
-			if (typeof aliasEntry.value === "string") {
-				resolvedValue = aliasEntry.value;
-				const parsedRef = parseGroupRef(aliasEntry.value);
-				if (parsedRef?.key) {
-					const group = findGroup(config.atomic, parsedRef.group);
-					const token = group?.tokens.find((t) => t.name === parsedRef.key);
-					if (group && token) {
-						const safeName = safeTokenName(token.name);
-						resolvedValue = `var(${buildCssVar(configPrefix, group.cssPrefix ?? group.namespace ?? parsedRef.group, safeName)})`;
-					}
-				}
-			} else resolvedValue = aliasEntry.value;
+			if (typeof aliasEntry.value === "string") resolvedValue = resolveTokenRef(aliasEntry.value, configPrefix);
+			else resolvedValue = aliasEntry.value;
 			if (!literals.includes(aliasKey)) literals.push(aliasKey);
 			literalAliases[aliasMapKey] = resolvedValue;
 		}

package/dist/config/dist/serialize.d.ts

@@ -3,6 +3,7 @@ import { AtomicToken, ExampleDef, ModeGroup, ModifierDef, MotionPresetsDef, UdsC
 import { CompositeStylesConfig } from "@uds/types";
 
 //#region ../config/dist/serialize.d.ts
+//#region src/serialize.d.ts
 type ModifierNameShape = `_${string}`;
 type TokenRef = {
   $ref: string;
@@ -67,6 +68,6 @@ declare function serializeConfig(config: UdsConfig): SerializedConfig;
  * Resolves `$ref` markers back to `var()` strings using the atomic token
  * definitions, then reconstructs the builder chain.
  */
-declare function deserializeConfig(data: SerializedConfig): UdsConfig;
+declare function deserializeConfig(data: SerializedConfig): UdsConfig; //#endregion
 //#endregion
 export { SerializedConfig, TokenRef, buildReverseMap, deserializeConfig, serializeConfig };

package/dist/config/dist/types/css-values.d.ts

@@ -1,4 +1,5 @@
 //#region ../config/dist/types/css-values.d.ts
+//#region src/types/css-values.d.ts
 /**
  * CSS value-type primitives — building blocks used by {@link CssPropertyValues}
  * in `./css-properties` and by `defineStyleProp` to constrain authored values.
@@ -55,6 +56,6 @@ type CssValue = {
   ident: string;
   string: string;
 };
-type CssValueTypeName = keyof CssValue;
+type CssValueTypeName = keyof CssValue; //#endregion
 //#endregion
 export { ColorFn, ColorKeyword, CssAngle, CssColor, CssLength, CssPercentage, CssRatio, CssTime, CssValue, CssValueTypeName, HexColor, HslColor, RgbColor };

package/dist/config/dist/types.d.ts

@@ -1,4 +1,5 @@
 //#region ../config/dist/types.d.ts
+//#region src/types.d.ts
 /**
  * Scalar DTCG-aligned token types. Composite types (shadow, gradient,
  * typography, border, transition, cubicBezier) are intentionally deferred
@@ -59,6 +60,6 @@ type VarGroupDef<M extends `_${string}` = `_${string}`> = {
  *   spacing: { $type: 'dimension', 1: { value: '0.25rem' }, 2: { value: '0.5rem' } },
  * }
  */
-type VarsConfig<M extends `_${string}` = `_${string}`> = Record<string, VarGroupDef<M>>;
+type VarsConfig<M extends `_${string}` = `_${string}`> = Record<string, VarGroupDef<M>>; //#endregion
 //#endregion
 export { TokenType, VarGroupDef, VarTokenDef, VarsConfig };

package/dist/core/dist/color-opacity-map.d.ts

@@ -1,5 +1,4 @@
 //#region ../core/dist/color-opacity-map.d.ts
-//#region src/color-opacity-map.d.ts
 /**
  * Maps each color prop name to its corresponding opacity prop name.
  * Used by the runtime (`getStyles`) and loader (`style-transform`) to merge
@@ -8,6 +7,6 @@
  * @example
  * `bg="primary"` + `bgOpacity="75"` → class `bg-primary_75`
  */
-declare const colorPropToOpacityProp: Record<string, string>; //#endregion
+declare const colorPropToOpacityProp: Record<string, string>;
 //#endregion
 export { colorPropToOpacityProp };

package/dist/core/dist/compositeStyles.d.ts

@@ -1,7 +1,6 @@
 import { CompositeStylesConfig } from "@uds/types";
 
 //#region ../core/dist/compositeStyles.d.ts
-//#region src/compositeStyles.d.ts
 /** Set the composite-styles config (called by loader at build time) */
 declare function setCompositeStylesConfig(config: CompositeStylesConfig): void;
 /** Get the current composite-styles config */
@@ -17,6 +16,6 @@ declare function getCompositeStylesConfig(): CompositeStylesConfig;
 declare function expandCompositeStyles(props: Record<string, unknown>, config?: CompositeStylesConfig): {
   expanded: Record<string, unknown>;
   markerClasses: string[];
-}; //#endregion
+};
 //#endregion
 export { expandCompositeStyles, getCompositeStylesConfig, setCompositeStylesConfig };

package/dist/core/dist/configurable-prop-helpers.d.ts

@@ -2,7 +2,6 @@ import { PropMapping } from "./style-prop-data.js";
 import { ConfigurableProp } from "@uds/types";
 
 //#region ../core/dist/configurable-prop-helpers.d.ts
-//#region src/configurable-prop-helpers.d.ts
 /** Look up a {@link PropMapping} by ConfigurableProp name. */
 declare function getConfigurablePropMapping(prop: ConfigurableProp): PropMapping | undefined;
 interface ConfigurablePropertyEntry {
@@ -27,6 +26,6 @@ interface CssVariablePrefixEntry {
  * Only includes props that have both `cssProperty` and `defaultVarPrefix`.
  * Deduplicates by `defaultVarPrefix` so each namespace appears once.
  */
-declare function getCssVariablePrefixes(): CssVariablePrefixEntry[]; //#endregion
+declare function getCssVariablePrefixes(): CssVariablePrefixEntry[];
 //#endregion
 export { ConfigurablePropertyEntry, CssVariablePrefixEntry, getConfigurablePropMapping, getConfigurableProperties, getCssVariablePrefixes };

package/dist/core/dist/createComponent.d.ts

@@ -1,7 +1,6 @@
 import { CreateComponentConfig, CreateComponentProps, CreateComponentRenderFn, CreateComponentSlotTagConfig, CreateComponentTypeInput } from "@uds/types";
 
 //#region ../core/dist/createComponent.d.ts
-//#region src/createComponent.d.ts
 type PrimitiveTag = keyof React.JSX.IntrinsicElements;
 type SpecConfig<TSpec> = TSpec extends {
   config: infer TConfig extends CreateComponentTypeInput;
@@ -52,6 +51,6 @@ declare function createComponent<TSpecOrProps = {}>(tag: PrimitiveTag): React.FC
   props: infer TOwnProps;
 } ? CreateComponentProps<TConfig, TOwnProps, PrimitiveTag> : PrimitiveOwnProps<TSpecOrProps>>;
 declare function createComponent<TSpec>(renderFn: CreateComponentRenderFn<SpecConfig<TSpec>, SpecOwnProps<TSpec>, SpecSlotConfig<TSpec>>): React.FC<CreateComponentProps<SpecConfig<TSpec>, SpecOwnProps<TSpec>, SpecSlotConfig<TSpec>>>;
-declare function createComponent(config: CreateComponentConfig<string>, renderFn: CreateComponentRenderFn<any, any, any>): React.FC<any>; //#endregion
+declare function createComponent(config: CreateComponentConfig<string>, renderFn: CreateComponentRenderFn<any, any, any>): React.FC<any>;
 //#endregion
 export { createComponent };

package/dist/core/dist/createComponentExample.d.ts

@@ -1,7 +1,6 @@
 import { ComponentProps, ComponentType } from "react";
 
 //#region ../core/dist/createComponentExample.d.ts
-//#region src/createComponentExample.d.ts
 /**
  * Extracts variant fixtures from a Component's props type.
  * If Button has `variant?: 'brand' | 'outline'` and `size?: 'sm' | 'md'`,
@@ -37,6 +36,6 @@ type ExamplesResult<TComponent extends ComponentType<any>> = {
  * }));
  * ```
  */
-declare function createComponentExample<TComponent extends ComponentType<any>, T extends Record<string, ExampleFn<TComponent>>>(Component: TComponent, examplesFn: (fixtures: VariantFixtures<TComponent>) => ExamplesResult<TComponent>): ComponentExample<T>; //#endregion
+declare function createComponentExample<TComponent extends ComponentType<any>, T extends Record<string, ExampleFn<TComponent>>>(Component: TComponent, examplesFn: (fixtures: VariantFixtures<TComponent>) => ExamplesResult<TComponent>): ComponentExample<T>;
 //#endregion
 export { ComponentExample, createComponentExample };

package/dist/core/dist/createProvider.d.ts

@@ -1,5 +1,4 @@
 //#region ../core/dist/createProvider.d.ts
-//#region src/createProvider.d.ts
 type ProviderRenderFn<TContext, TProps = Record<never, never>> = (props: {
   children: React.ReactNode;
 } & TProps) => {
@@ -8,6 +7,6 @@ type ProviderRenderFn<TContext, TProps = Record<never, never>> = (props: {
 };
 declare function createProvider<TContext, TProps = Record<never, never>>(name: string, renderFn: ProviderRenderFn<TContext, TProps>): [React.FC<{
   children: React.ReactNode;
-} & TProps>, () => TContext]; //#endregion
+} & TProps>, () => TContext];
 //#endregion
 export { createProvider };

package/dist/core/dist/generated/stylePropsTwMap.d.ts

@@ -1,5 +1,4 @@
 //#region ../core/dist/generated/stylePropsTwMap.d.ts
-//#region src/generated/stylePropsTwMap.d.ts
 declare const stylePropsTwMap: {
   readonly "border-boolean": {
     readonly border: "boolean";
@@ -1696,6 +1695,6 @@ declare const stylePropsTwMap: {
   readonly "hyphens-manual": {
     readonly hyphens: "manual";
   };
-}; //#endregion
+};
 //#endregion
 export { stylePropsTwMap };

package/dist/core/dist/getComponentStyles.d.ts

@@ -1,7 +1,6 @@
 import { ComponentRegistry, ComponentSlotsOf, ComponentVariantsOf } from "@uds/types";
 
 //#region ../core/dist/getComponentStyles.d.ts
-//#region src/getComponentStyles.d.ts
 type ResolveSlots<Name extends string> = Name extends keyof ComponentRegistry ? ComponentSlotsOf<Name> : string;
 type ResolveVariants<Name extends string> = Name extends keyof ComponentRegistry ? ComponentVariantsOf<Name> : Record<string, string>;
 interface UdsRuntimeMeta {
@@ -45,6 +44,6 @@ interface ComponentStyler<Name extends string> {
  * @param slots - Array of slot names
  * @param element - Optional HTML element tag for element-specific prop forwarding
  */
-declare function createComponentStyler<Name extends string>(componentName: Name, slots: readonly string[], element?: string, variants?: readonly string[]): ComponentStyler<Name>; //#endregion
+declare function createComponentStyler<Name extends string>(componentName: Name, slots: readonly string[], element?: string, variants?: readonly string[]): ComponentStyler<Name>;
 //#endregion
 export { createComponentStyler };

package/dist/core/dist/getStyles.d.ts

@@ -2,7 +2,6 @@ import { ClassValue } from "clsx";
 import { ModifierProp, ModifierProps, StyleAndModifierProps, StyleProps } from "@uds/types";
 
 //#region ../core/dist/getStyles.d.ts
-//#region src/getStyles.d.ts
 /** Convert kebab-case CSS property to camelCase for React inline styles.
  *  CSS custom properties (--*) are kept as-is since React supports them verbatim. */
 declare function toCamelCase(str: string): string;
@@ -38,6 +37,6 @@ interface GetStylesParams extends StyleProps, ModifierProps {
  *  so they can be included in the CSS safelist.
  */
 declare function getStyles(props: GetStylesParams): string;
-declare function getVariantClassName(componentName: string, variant: string | undefined): string; //#endregion
+declare function getVariantClassName(componentName: string, variant: string | undefined): string;
 //#endregion
 export { createVariants, cx, getStyles, getVariantClassName, processStyleProps, toCamelCase };

package/dist/core/dist/modifier-mappings.d.ts

@@ -1,13 +1,12 @@
 import { ModifierProp } from "@uds/types";
 
 //#region ../core/dist/modifier-mappings.d.ts
-//#region src/modifier-mappings.d.ts
 declare const modifierMappings: Record<ModifierProp, string>;
 interface ModifierEntry {
   prop: string;
   cssSelector: string;
   category: string;
   description: string;
-} //#endregion
+}
 //#endregion
 export { ModifierEntry, modifierMappings };

package/dist/core/dist/resolveMotionState.d.ts

@@ -1,5 +1,4 @@
 //#region ../core/dist/resolveMotionState.d.ts
-//#region src/resolveMotionState.d.ts
-declare function resolveMotionState(stateKeyframe: Record<string, unknown>, index: number): Record<string, number>; //#endregion
+declare function resolveMotionState(stateKeyframe: Record<string, unknown>, index: number): Record<string, number>;
 //#endregion
 export { resolveMotionState };