@yahoo/uds-v5-wip 1.38.0 → 1.40.0

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

@@ -2,7 +2,6 @@ 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, ...)`.
@@ -59,6 +58,23 @@ interface StylePropBinding {
   layer: string;
   styleProp: StylePropRef;
 }
+/**
+ * Extract the root tag literal from a `layers` map when it can be read
+ * statically. Returns the string literal `'a' | 'div' | …` when:
+ *
+ *  - `layers.root` is a bare tag string (`'a'`), or
+ *  - `layers.root` is `{ tag: 'a', attrs?: … }`.
+ *
+ * Returns `undefined` when `layers.root` is a brace-ref (`'{Box}'`), a
+ * `{ component: '{Box}' }` form, or not present. `Props<TConfig>` reads
+ * this and substitutes `React.ComponentPropsWithoutRef<TTag>` for the
+ * generic `HTMLAttributes<HTMLElement>` when narrowable.
+ */
+type RootTag<TLayers> = TLayers extends {
+  root: infer R;
+} ? R extends HtmlTag ? R extends `{${string}}` ? undefined : R : R extends {
+  tag: infer T extends HtmlTag;
+} ? T : undefined : undefined;
 /**
  * Bind a registered composite to a single layer. Multi-layer composites
  * use the `CompositeBinding` shape instead (see below).
@@ -111,49 +127,61 @@ interface EnumMarker<TValues extends Record<string, unknown>> {
 /**
  * Shorthand binding form — a brace-ref string standing in for the
  * verbose object. `'{bg}'` means "bind the registered style prop `bg`
- * to the default layer (`root` when present, else the first layer
- * declared)". Use the long-form `{ layer, styleProp }` shape when the
- * target layer isn't the default, or when the JSX-prop key differs
- * from the style-prop name.
+ * to the *root* layer".
  *
- *     props: {
- *       bg: '{bg}',                                              // shorthand
- *       padding: '{spacing}',                                     // shorthand: rename
- *       borderRadius: { layer: 'root', styleProp: '{borderRadius}' }, // long-form
- *     }
+ * Only legal in the primitive form `defineComponent('div', { props: { bg: '{bg}' } })`,
+ * where the root layer is unambiguous. In the verbose form
+ * `defineComponent({ layers: {...}, props: {...} })` authors must use
+ * the explicit long-form `{ layer, styleProp: '{bg}' }` binding so
+ * the target layer is named at the call site.
  */
 type StylePropShorthand = StylePropRef;
 /**
- * All allowed shapes for a single entry in the `props` block.
+ * All allowed shapes for a single entry in the verbose form's `props`
+ * block. Verbose form (with explicit `layers`) requires the long-form
+ * `{ layer, styleProp }` binding — no shorthand. The shorthand
+ * `'{bg}'` is allowed only in the primitive form's props (see
+ * `PrimitivePropBinding`).
  */
-type PropBinding = StylePropShorthand | StylePropBinding | SingleLayerCompositeBinding | CompositeBinding | SurfaceForward | BoolMarker | EnumMarker<any>;
+type VerbosePropBinding = StylePropBinding | SingleLayerCompositeBinding | CompositeBinding | SurfaceForward | BoolMarker | EnumMarker<any>;
 /**
- * Marker for a boolean JSX prop. Use inside the `props` block:
- *
- *     props: {
- *       loading: bool(),
- *       disabled: bool(),
- *     }
+ * All allowed shapes for a single entry in the primitive form's `props`
+ * block. Primitive form adds the `StylePropShorthand` brace-ref
+ * (`'{bg}'`) on top of every verbose form — the root layer is
+ * unambiguous so the shorthand resolves trivially.
  */
+type PrimitivePropBinding = StylePropShorthand | VerbosePropBinding;
 /**
- * Branded shape returned by `defineComponent({...})`. Carries `layers`
- * AND `props` as const-narrowed types so downstream type-only imports
- * (`import type { AlertConfig } from './alert.config'`) thread the
- * full shape through to `Props<typeof config>` — and per-prop literal
- * binding values (e.g. `'{bg}'`) survive for `Props<TConfig>` to
- * resolve against `RegisteredStyleProps`. The component name is
- * supplied at registration time, not here.
+ * Union of every legal prop-binding shape across both forms. Read-side
+ * helpers (`Props<TConfig>`, runtime resolution) accept this widest
+ * union; authoring-side input types (`ComponentConfigInput`) take the
+ * tighter `VerbosePropBinding`.
  */
-interface ComponentConfigValue<TLayers extends Record<string, LayerInput>, TProps extends Record<string, PropBinding> = Record<string, PropBinding>> {
+type PropBinding = PrimitivePropBinding;
+/**
+ * Branded shape returned by `defineComponent({...})`. Carries `layers`,
+ * `props`, AND a phantom `__tag` slot as const-narrowed types so
+ * downstream type-only imports (`import type { AlertConfig } from
+ * './alert.config'`) thread the full shape through to
+ * `Props<typeof config>` — per-prop literal binding values (e.g.
+ * `'{bg}'`) survive for `Props<TConfig>` to resolve against
+ * `RegisteredStyleProps`, and the root tag survives for HTML-attribute
+ * narrowing via `React.ComponentPropsWithoutRef<TTag>`.
+ *
+ * `__tag` is a *phantom* type slot — there is no runtime field. It's
+ * derived from either the primitive-form first arg (`defineComponent('a',
+ * …)`) or from `layers.root` via `RootTag<TLayers>` for the verbose form.
+ * When the root isn't a literal tag (brace-ref / composed layer), it's
+ * `undefined` and `Props<TConfig>` falls back to `HTMLAttributes<HTMLElement>`.
+ *
+ * The component's name is supplied at registration time, not here.
+ */
+interface ComponentConfigValue<TLayers extends Record<string, LayerInput>, TProps extends Record<string, PropBinding> = Record<string, PropBinding>, TTag extends HtmlTag | undefined = RootTag<TLayers>> {
   readonly __kind: 'componentConfig';
+  readonly __tag?: TTag;
   readonly layers: TLayers;
   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, PropBinding, SingleLayerCompositeBinding, StylePropBinding, SurfaceForward };
+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,5 +1,4 @@
 //#region ../config/dist/component-refs.d.ts
-//#region src/component-refs.d.ts
 /**
  * Augmentable registries + template-literal ref types for the
  * component-API surface.
@@ -64,14 +63,6 @@ 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
@@ -90,9 +81,5 @@ 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 @@
-export { };
+import { ComponentsConfig } from "@uds/types";

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

@@ -1,5 +1,4 @@
 //#region ../config/dist/consts/defaultColors.d.ts
-//#region src/consts/defaultColors.d.ts
 declare const defaultColors: {
   inherit: string;
   current: string;
@@ -248,6 +247,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,11 @@
 import { ComponentConfigValue } from "./component-config.js";
+import { BoundComponent } from "./defineComponent.js";
 import { AnyStyleProp } from "./defineStyleProp.js";
-import { TokenType, VarsConfig } from "./types.js";
 import { ResolvedStyleProp } from "./resolveStyleProp.js";
+import { TokenType, VarsConfig } from "./types.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,12 +78,6 @@ 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;
@@ -163,7 +157,6 @@ 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 */
@@ -236,7 +229,7 @@ interface UdsConfigData {
    * `ComponentConfigValue` branded record carrying `layers`, `props`,
    * `defaultProps`.
    */
-  componentConfigs?: Record<string, ComponentConfigValue<any, any>>;
+  componentConfigs?: Record<string, ComponentConfigValue<any, any, any>>;
 }
 interface ComponentConfig<TComponents extends ComponentsConfig<string> = ComponentsConfig<string>, TMotion extends MotionPresetsDef | undefined = MotionPresetsDef | undefined> {
   name?: string;
@@ -304,24 +297,28 @@ interface UdsConfig<TModifier extends ModifierNameShape = ModifierProp, TTokens
    */
   registerStyleProps<const Props extends Record<string, AnyStyleProp>>(props: Props): ConfigResult<TModifier, TTokens, TMotion, TExt, TCompositeStyles, TModeModifiers, TVars>;
   /**
-   * Register `defineComponent('Name', config)`-authored components,
-   * keyed by component name. Calls accumulate — later
-   * `.registerComponents({...})` calls merge into the existing map
-   * (later keys overwrite earlier ones with the same name).
+   * Register components authored with `defineComponent(...)`. Calls
+   * accumulate — later `.registerComponents({...})` calls merge into
+   * the existing map (later keys overwrite earlier ones with the same
+   * name).
+   *
+   * Accepts either form returned by `defineComponent`:
+   *  - The pure-data config value from the bare verbose form
+   *    (`defineComponent({ layers, props })`).
+   *  - A bound component from the primitive form
+   *    (`defineComponent('div', { props })`) or the chained
+   *    `.render(fn)` builder — the framework extracts the underlying
+   *    config from the non-enumerable `__config` slot.
    *
    * @example
    * ```ts
-   * import { Box, Alert } from './src/uds/components';
+   * import { Box } from './src/uds/components/box';      // primitive
+   * import { alertConfig } from './src/uds/components/alert.config'; // verbose pure-data
    *
-   * uds.registerComponents({ Box, Alert });
+   * uds.registerComponents({ Box, Alert: alertConfig });
    * ```
-   *
-   * The value side of each map entry is the `ComponentConfigValue`
-   * returned by `defineComponent`. (Apps pass the React component value
-   * — `Box` — and the framework reads its attached config via the
-   * registry populated as a side effect of importing the config file.)
    */
-  registerComponents<const TConfigs extends Record<string, ComponentConfigValue<any, any>>>(configs: TConfigs): ConfigResult<TModifier, TTokens, TMotion, TExt, TCompositeStyles, TModeModifiers, TVars>;
+  registerComponents<const TConfigs extends Record<string, ComponentConfigValue<any, any, any> | BoundComponent<ComponentConfigValue<any, any, any>, any>>>(configs: TConfigs): ConfigResult<TModifier, TTokens, TMotion, TExt, TCompositeStyles, TModeModifiers, TVars>;
   defineMotion<const M extends MotionPresetsDef>(presets: M | ((tokens: TTokens) => M)): ConfigResult<TModifier, TTokens, { [K in keyof M]: string }, TExt, TCompositeStyles, TModeModifiers, TVars>;
   defineComponents(params: ComponentsConfig<MotionAliasValue<TMotion> | string> | ((ctx: {
     tokens: TTokens;
@@ -352,10 +349,6 @@ 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 */
 /**
@@ -428,9 +428,12 @@ function createConfigBuilder(data, extensions) {
 			return next(updates);
 		},
 		registerComponents(configs) {
+			const normalized = {};
+			for (const [name, entry] of Object.entries(configs)) if (typeof entry === "function" && "__config" in entry) normalized[name] = entry.__config;
+			else normalized[name] = entry;
 			return next({ componentConfigs: {
 				...data.componentConfigs ?? {},
-				...configs
+				...normalized
 			} });
 		},
 		defineMotion(presets) {

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

@@ -1 +1,17 @@
-export { };
+import { ComponentConfigValue, HtmlTag, LayerInput } from "./component-config.js";
+import { Props } from "./Props.js";
+import { ReactNode } from "react";
+
+//#region ../config/dist/defineComponent.d.ts
+/**
+ * A React component bound to a `defineComponent` config, with the
+ * source config attached as a phantom type slot. Tools (codegen,
+ * devtools) recover the config at runtime via the non-enumerable
+ * `__config` property; the type slot lets consumers read it at the
+ * type level too — `Props<typeof Box['__config']>`.
+ */
+type BoundComponent<TConfig extends ComponentConfigValue<Record<string, LayerInput>, any, HtmlTag | undefined>, TExtra extends Record<string, unknown> = {}> = React.FC<Props<TConfig> & TExtra> & {
+  readonly __config: TConfig;
+};
+//#endregion
+export { BoundComponent };

package/dist/config/dist/defineComponent.js

@@ -0,0 +1,2 @@
+import "./createComponent.js";
+import "react";

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

@@ -1,4 +1,4 @@
-import { CssValueTypeName } from "./types/css-values.js";
+import { CssValue, CssValueTypeName } from "./types/css-values.js";
 
 //#region ../config/dist/defineStyleProp.d.ts
 /** Runtime input type for `toCss` based on the entry's `type`. */
@@ -22,20 +22,10 @@ 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
@@ -51,6 +41,5 @@ interface AnyStyleProp {
   readonly cssType?: CssValueTypeName;
   readonly metadata: StylePropMetadata;
 }
-/** Intermediate builder — the only callable method is `.metadata()`. */
 //#endregion
 export { AnyStyleProp, ArbitraryEntry, ArbitrarySpec, StylePropMetadata };

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

@@ -1,10 +1,12 @@
 import { ComponentRef, CompositeRef, RegisteredComponents, RegisteredComposites, RegisteredStyleProps, StylePropRef } from "./component-refs.js";
-import { BoolMarker, ComponentConfigValue, ComposedLayer, CompositeBinding, EnumMarker, HtmlTag, LayerInput, PrimitiveLayer, PropBinding, SingleLayerCompositeBinding, StylePropBinding, SurfaceForward } from "./component-config.js";
+import { BoolMarker, ComponentConfigValue, ComposedLayer, CompositeBinding, EnumMarker, HtmlTag, LayerInput, PrimitiveLayer, PrimitivePropBinding, PropBinding, RootTag, SingleLayerCompositeBinding, StylePropBinding, StylePropShorthand, SurfaceForward, VerbosePropBinding } from "./component-config.js";
+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

@@ -5,6 +5,7 @@ import "./propertyAcceptedTypes.js";
 import "./resolveTokenTypes.js";
 import "./resolveStyleProp.js";
 import "./createConfig.js";
+import "./defineComponent.js";
 import "./defineStyleProp.js";
 import "./propertyGroups.js";
 import "./refs.js";

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

@@ -1,7 +1,6 @@
 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;
@@ -59,11 +58,5 @@ 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/serialize.d.ts

@@ -3,7 +3,6 @@ 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;
@@ -68,6 +67,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; //#endregion
+declare function deserializeConfig(data: SerializedConfig): UdsConfig;
 //#endregion
 export { SerializedConfig, TokenRef, buildReverseMap, deserializeConfig, serializeConfig };

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

@@ -1,5 +1,4 @@
 //#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.
@@ -56,6 +55,6 @@ type CssValue = {
   ident: string;
   string: string;
 };
-type CssValueTypeName = keyof CssValue; //#endregion
+type CssValueTypeName = keyof CssValue;
 //#endregion
 export { ColorFn, ColorKeyword, CssAngle, CssColor, CssLength, CssPercentage, CssRatio, CssTime, CssValue, CssValueTypeName, HexColor, HslColor, RgbColor };

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

@@ -1,5 +1,4 @@
 //#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
@@ -60,6 +59,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>>; //#endregion
+type VarsConfig<M extends `_${string}` = `_${string}`> = Record<string, VarGroupDef<M>>;
 //#endregion
 export { TokenType, VarGroupDef, VarTokenDef, VarsConfig };