@yahoo/uds-create-config 2.45.0 → 3.0.1

package/dist/types.d.ts

@@ -1,1138 +0,0 @@
-import { AssetRef, ComponentName, ComponentRef as ComponentRef$1, CompositeRef, ModeRef, TagRef, TokenGroupRef, TokenRef } from "./refs.js";
-import { ColorExpression } from "./colorExpressions.js";
-import { MOTION_CSS_DIRECTIONS, MOTION_CSS_FILL_MODES, MOTION_CSS_PLAY_STATES, MOTION_JS_DRAG_AXES, MOTION_JS_LAYOUT_MODES, MOTION_JS_REPEAT_TYPES, MOTION_JS_TRANSITION_TYPES } from "./motion-constants.js";
-import { CssPropertyName, CssPropertyValues } from "./types/css-properties.js";
-import { IconAssetMetadata } from "./defineAssetGroup.js";
-import { ComponentRef, ComponentType, JSX } from "react";
-import { EntityKind } from "@yahoo/uds-create-types/entity";
-
-//#region src/types.d.ts
-/**
- * CSS value-type names used to tag a token. The scaffold leaves the
- * union open so token-type tightening (a closed CSS-value-type union)
- * lands as a follow-up — needs to ship with type-narrowing on
- * `defineStyleProp({ values: ... })` to be useful.
- */
-type TokenType = string;
-/**
- * What a token's `value` can hold:
- *
- * - A literal — `string` (`'#1167f4'`, `'1rem'`), `number`, `boolean`.
- * - A `token('ns/name')` marker pointing at another token.
- * - A structured `ColorExpression` — `mix(...)`, `alpha(...)`,
- *   `linearGradient(...)`, `radialGradient(...)`. Codegen resolves the
- *   expression to a CSS function call (`color-mix(...)`,
- *   `linear-gradient(...)`) via `resolveColorExpression`.
- */
-type TokenValue = string | number | boolean | TokenRef | AssetRef | ColorExpression;
-type TokenModifierKey = `_${string}`;
-/**
- * Platform-neutral authored token definition. Web and native configs share
- * the definition envelope (value, type, link provenance, and nested modifier
- * overrides) while supplying their own supported value union.
- */
-type TokenDefinitionFor<TValue> = {
-  value: TValue;
-  type?: TokenType; /** Set when this token is linked from another system — see {@link SystemLink}. */
-  link?: SystemLink;
-} & { [K in `_${string}`]?: TValue | TokenDefinitionFor<TValue> };
-type TokenModifierValue = TokenValue | TokenDefinition;
-/**
- * Provenance marker on an entity linked from another system: it records where
- * the definition came from, not what it is (the definition itself is inlined
- * alongside). Present only on linked entities — `undefined` means local.
- *
- * Deliberately an enumerable field rather than a non-enumerable slot like
- * `__sourcePath`: the marker has to survive `JSON.stringify` so a config that
- * round-trips through storage still knows which entities are linked, and unlike
- * a source path it can't be recomputed on load.
- *
- * The local key is the entity's key in its own map, so it isn't repeated here;
- * `sourceKey` is the key in the source system, and the two differ on rename.
- *
- * `kind` is the kind of the entity this marker sits on, which is not always the
- * kind of the patch that created it. The link contract is entity-to-entity, so a
- * group-level link is a bulk instruction: a `link-create` with
- * `kind: 'token-group'` spreads to a marker on every token in that group, each
- * carrying `kind: 'token'`. A token group therefore never holds a marker itself.
- */
-interface SystemLink {
-  kind: EntityKind;
-  /** Source system's database UUID — the pin's identity. */
-  systemId: string;
-  /** Exact published version of the source system (`'1.3.1'`). */
-  systemVersion: string;
-  /** The entity's key in the source system. */
-  sourceKey: string;
-}
-/**
- * Sparse override applied to a linked component via `.extend(patch)` — a
- * recursive merge-patch (RFC 7396 semantics) over the definition's
- * non-structural fields. Objects merge key-by-key, scalars and arrays
- * replace, `null` deletes the key. `layers`, `ref`, `link`, and `extension`
- * are never extendable.
- */
-type ComponentExtension = Record<string, unknown>;
-/**
- * Provenance for an applied extension, stored enumerably on the definition
- * beside `link` so it survives serialization. `payload` is the authored
- * patch (intent — replayable against an updated source); `inverse` is the
- * merge-engine-computed patch that restores the pre-extension definition,
- * which is what makes post-merge update/delete possible.
- */
-interface ComponentExtensionRecord {
-  payload: ComponentExtension;
-  inverse: ComponentExtension;
-}
-/**
- * Authored shape for one token. Modifier values live as flat `_${key}`
- * properties on the same object — matches the doc's example
- * `{ value: '#1167f4', _dark: '#88bcfb' }` and the wire format.
- *
- * `Token` normalizes flat keys into a `modifiers` map at construction
- * time so consumers reading the class instance work with the
- * doc-described class shape.
- */
-type TokenDefinition = TokenDefinitionFor<TokenValue>;
-/**
- * Authored shape — the bare tokens record. Mirrors the old `@yahoo/uds-create-config`
- * `defineTokenGroup(tokens)` signature: input is the tokens map; group
- * metadata (label / description) is attached separately via the
- * registration call, not nested under a wrapper.
- */
-/**
- * A token group: a tokens record + optional Studio-facing metadata.
- * Mirrors main's `TokenGroupDef`. The parent record key in
- * `registerTokenGroups({...})` carries the namespace, so it doesn't
- * appear here. Tokens nest under `tokens` so a token named `'label'`
- * (or any meta key) can never collide with group metadata.
- */
-interface TokenGroupDefinitionFor<TDefinition> {
-  tokens: Record<string, TDefinition>;
-  label?: string;
-  description?: string;
-}
-type TokenGroupDefinition = TokenGroupDefinitionFor<TokenDefinition>;
-/**
- * Alias for the on-disk wire shape — structurally identical to
- * `TokenGroupDefinition`. Used as the return type of
- * `TokenGroup.toJSON()` so the serialization intent reads at call
- * sites; consumers reading `config.json` see `SerializedTokenGroup`,
- * authors writing `registerTokenGroups` see `TokenGroupDefinition`.
- */
-type SerializedTokenGroup = TokenGroupDefinition;
-interface ModifierDefinition {
-  selector?: string | CompositeRef | ModeRef;
-  media?: string;
-  description?: string;
-}
-interface ModeOptionDefinition {
-  /**
-   * Modifier the option contributes. Defaults to `_${optionName}` —
-   * `colorMode: { options: { light: {...}, dark: {...} } }` produces
-   * modifiers `_light` and `_dark` without restating them. Override
-   * when the option name and the desired modifier should differ.
-   */
-  modifier?: TokenModifierKey;
-  label?: string;
-  description?: string;
-  /**
-   * CSS selector text the option produces — for `colorMode/dark`,
-   * `'.dark'` so consumers can write `<html class="dark">` and have
-   * the dark-mode tokens apply. Mirrors the old
-   * `@yahoo/uds-create-config` `ModeOptionInput.css` field name.
-   */
-  css?: string;
-  media?: string;
-}
-type ModeDefinition = Record<string, ModeOptionDefinition>;
-type CompositeStyleObject = Record<string, unknown>;
-interface CompositeStyleDefinition {
-  label: string;
-  description?: string;
-  /**
-   * Named style variants keyed by variant name. Mirrors the old
-   * `@yahoo/uds-create-config` `defineCompositeStyle({ styles })` field name —
-   * authors write `styles: { sm: {...}, md: {...} }`.
-   */
-  styles: Record<string, CompositeStyleObject>;
-  /**
-   * Provenance when this composite is linked from another system; `undefined`
-   * for local ones. Sits at the composite level, not per variant: a variant
-   * isn't a registerable entity (no `EntityKind`, no key in
-   * `Config.compositeStyles`, no dimension in `dependentsOf`), and components
-   * bind the whole group through one `composite()` prop — so a per-variant
-   * marker would have no referrer or CSS expression. Contrast a token group,
-   * which holds no marker precisely because its members ARE the entities.
-   */
-  link?: SystemLink;
-}
-/**
- * Any CSS property name `defineStyleProp` can target. Standard
- * property names come from the `CssPropertyValues` registry; custom
- * CSS properties (`--*`) are open template strings.
- */
-type StylePropProperty = CssPropertyName | `--${string}`;
-/**
- * Literal-keyword subset accepted by a CSS property. For standard
- * properties, falls out of `CssPropertyValues[P]`. For custom CSS
- * properties (`--*`), open string — narrowing happens via the
- * `cssType` field on the style-prop spec.
- */
-type LiteralFor<P extends StylePropProperty> = [P] extends [CssPropertyName] ? Extract<CssPropertyValues[P], string> : string;
-/**
- * Author-friendly alias for a CSS keyword. `alias` is what the JSX
- * value site uses (`flexDirection="col"`); `value` is the underlying
- * CSS the prop resolves to.
- *
- *  - `string` — a single CSS keyword (`'column'`).
- *  - `Record<string, string>` — a multi-property emission, used to
- *    write vendor-prefixed pairs (`{ '-webkit-user-select': 'none',
- *    'user-select': 'none' }`) so a single utility class sets both at
- *    once and matches Tailwind's built-in body byte-for-byte (avoids
- *    cascade overrides).
- *
- * `value` is kept un-narrowed here — per-property narrowing via
- * `LiteralFor<P>` would explode the union across every CSS property
- * and hit TS's "too complex" limit.
- */
-interface ValueAlias {
-  alias: string | boolean | number;
-  value: string | Record<string, string>;
-}
-/**
- * A single entry in a style-prop's `values` array. Narrowed against
- * the chosen `cssProperty` so authoring sites like
- * `values: ['banana']` on a `border-color` prop error at compile time.
- *
- *  - `TokenGroupRef` — pulls every token in the named namespace
- *    into the prop's accepted value set.
- *  - `LiteralFor<P>` — a CSS keyword the property accepts per spec
- *    (e.g. `'transparent'` for `border-color`).
- *  - `number` — bare numeric values where CSS itself accepts numbers
- *    (e.g. `line-clamp: 3`).
- *  - `boolean` — a toggle value. `true` emits the bare class prefix as a
- *    hook (the runtime `boolAlias` path), `false` emits nothing (off);
- *    combine with string entries for a `boolean | 'first' | 'last'`-style
- *    surface (e.g. `nestedBorderRadius`). The accompanying `cssProperty`
- *    is typically a custom property used only as the class carrier.
- *  - `ValueAlias<P>` — `{ alias, value }` pair for Tailwind-style
- *    shorthands; the alias appears at the JSX value site and resolves
- *    to the underlying CSS keyword at emit time.
- */
-type ValuesEntry<P extends StylePropProperty = StylePropProperty> = TokenGroupRef | LiteralFor<P> | number | boolean | ValueAlias;
-interface ArbitrarySpec {
-  type?: TokenType;
-}
-/**
- * One entry in a multi-shape `arbitrary` array. `toCss` lets the prop
- * coerce a runtime value into the actual CSS string (e.g. wrapping a
- * raw `'1px'` in `var(--...)` or stitching multi-property output). The
- * `regex` variant accepts any string matching a pattern instead of
- * binding to a named value type.
- */
-type ArbitraryEntry = {
-  type: TokenType;
-  toCss?: (value: unknown) => string;
-} | {
-  type: 'regex';
-  pattern: RegExp;
-  toCss?: (value: string) => string;
-};
-/**
- * Author-time shape for `arbitrary`. Four forms:
- *  - `true` — accept any bracketed value, passed through verbatim into the
- *    prop's `cssProperty` (`arbitrary: true` → `blur="[blur(6px)]"` →
- *    `filter: blur(6px)`). Use when the bracket already carries the full CSS
- *    value and needs no data-type validation or transform.
- *  - bare `TokenType` string (`arbitrary: 'length-percentage'`) —
- *    shorthand for `{ type: ... }`.
- *  - `ArbitrarySpec` object (`arbitrary: { type: 'color' }`).
- *  - `ArbitraryEntry[]` for multi-shape props that accept several
- *    value-type variants (e.g. `grid-template-rows` taking integers,
- *    length-percentages, and full track lists).
- * Normalized at `StyleProp` construction time (`true` → `{}`).
- */
-type ArbitraryInput = boolean | TokenType | ArbitrarySpec | readonly ArbitraryEntry[];
-/**
- * Authored shape attached by `defineStyleProp(spec).withOpacity({...})`.
- * Declares a paired opacity sibling style-prop: the parent emits
- * `${classPrefix}-${tokenName}` for the bare value AND
- * `${classPrefix}-${tokenName}${separator}${opacityValue}` when the
- * sibling prop is set. The sibling itself is registered alongside the
- * parent at `registerStyleProps` time.
- *
- * `ref` (deprecated alias for `as`) is kept for back-compat with sites
- * that read the opacity pair as `{ ref }` — codegen's `extractClasses.ts`
- * checks `opacityPair.ref` directly.
- */
-interface OpacityPairSpec {
-  /** JSX-prop name for the opacity sibling (e.g. `'bgOpacity'`). */
-  as: string;
-  /** Token group the opacity sibling pulls values from. */
-  values: TokenGroupRef;
-  /**
-   * Class-name separator between the parent's token suffix and the
-   * opacity value. Defaults to `'_'`. Pass `'/'` for Tailwind-flavored
-   * output (`bg-primary/75`).
-   */
-  separator?: string;
-  /** Back-compat alias of `as`. New code should use `as`. */
-  ref?: string;
-}
-/**
- * Authoring metadata attached via `defineStyleProp(spec).metadata({...})`.
- * Consumed by codegen prompt artifacts and Studio's UI. Kept open
- * (`Readonly<Record<string, unknown>>`) — `label` / `description` are
- * the conventional fields but the slot doesn't enforce.
- */
-type StylePropMetadata = Readonly<Record<string, unknown>>;
-/**
- * Authoring metadata attached via
- * `defineComponent(...).config(...).metadata({...})`. `description`
- * shows up in codegen's AI prompt artifact next to the component name;
- * `events` lists React/HTML event handler names the component supports
- * (`'focus'`, `'press'`, etc.) — when unset, the synthesizer falls
- * back to the standard React event roster. `deprecated` keeps a component
- * out of the AI prompt artifact while leaving it registered and renderable.
- */
-interface ComponentMetadata {
-  /**
-   * Human-facing display name for Studio's palette. Defaults to the
-   * component's registered name when absent. Lets two components present
-   * the same label (e.g. both "Badge") while keeping distinct, stable
-   * identities (`uds:Badge` vs `uds:StudioBadge`) — identity stays the
-   * registered name, never this label.
-   */
-  readonly label?: string;
-  readonly description?: string;
-  readonly events?: readonly string[];
-  /**
-   * Marks the component as deprecated. Deprecated components are omitted
-   * from codegen's AI prompt artifact so the model won't reach for them in
-   * new work — they remain fully registered and renderable everywhere else.
-   */
-  readonly deprecated?: boolean;
-}
-/**
- * Authored shape for `defineStyleProp`. `P` is the CSS property name
- * (or names, when `cssProperty` is an array of side-shorthand props)
- * — `values` narrows against `LiteralFor<P>` so unsupported keywords
- * surface at the authoring site.
- *
- * No default for `P`: the wide case would force TypeScript to
- * materialize `Extract<CssPropertyValues[CssPropertyName], string>`
- * (a giant union) at every reference site. Wide-typed consumers
- * (`Config.styleProps`, the wire format) use `AnyStylePropDefinition`
- * instead.
- */
-interface StylePropDefinition<P extends StylePropProperty> {
-  cssProperty: P | readonly P[];
-  classPrefix: string;
-  /**
-   * Token-group refs + literal keywords + bare numbers the prop accepts.
-   * Optional — `values: []` (or omitting it) is meaningful for props
-   * that only take arbitrary `[...]` escape values (e.g. `motion`).
-   */
-  values?: readonly ValuesEntry<P>[];
-  arbitrary?: ArbitraryInput;
-  /**
-   * Marks the prop as emitting a *negative* value: the resolved token or
-   * arbitrary value is wrapped in `calc(<value> * -1)` at emit time, so
-   * `offsetTop="3"` (a `negative` prop) paints
-   * `margin-top: calc(var(--uds-spacing-3) * -1)`. This flag is the single
-   * source of negativity — both the build-time emitter (`prepareCss`) and
-   * the runtime injector (`renderGetStyles`) read it, replacing the old
-   * `classPrefix.startsWith('-')` heuristic. It's also the structured signal
-   * the MCP / AI guidance / spec lint use to identify overlap-prone props.
-   *
-   * Negative props conventionally still use a `-`-led `classPrefix` (`-mt`)
-   * so the utility reads as a Tailwind negative class (`.-mt-3`) and stays
-   * distinct from a positive sibling (`marginTop` → `.mt-3`) — but the prefix
-   * only *names* the class; this flag *drives* the negation.
-   */
-  negative?: boolean;
-  cssType?: TokenType;
-  metadata?: StylePropMetadata;
-  opacityPair?: OpacityPairSpec;
-  /**
-   * Optional value coercion the renderer applies after token resolution.
-   * Takes the resolved value (number for bare-numeric tokens, string
-   * otherwise) and returns the final CSS string. Lets props like
-   * `gridTemplateColumns` accept `12` and emit
-   * `repeat(12, minmax(0, 1fr))`.
-   */
-  transform?: (value: string | number) => string;
-}
-/**
- * Wide structural shape used by `Config.registerStyleProps` and the
- * `StyleProp` class storage. Any concretely-narrowed
- * `StylePropDefinition<P>` is assignable to this. `values` is the
- * un-narrowed marker/literal/number union — runtime treats every
- * entry uniformly, so the narrowing in `StylePropDefinition<P>` is
- * purely an authoring-time check.
- */
-interface AnyStylePropDefinition {
-  cssProperty: StylePropProperty | readonly StylePropProperty[];
-  classPrefix: string;
-  values?: readonly (TokenGroupRef | string | number | boolean | ValueAlias)[];
-  arbitrary?: ArbitraryInput;
-  /** See {@link StylePropDefinition.negative} — emit `calc(<value> * -1)`. */
-  negative?: boolean;
-  cssType?: TokenType;
-  metadata?: StylePropMetadata;
-  opacityPair?: OpacityPairSpec;
-  transform?: (value: string | number) => string;
-}
-type MotionKeyframes = Record<string, Record<string, unknown>>;
-/**
- * Author-side metadata for a registered motion preset, supplied via
- * `defineMotion({...}).metadata({...})`. `label` names the preset in Studio's
- * motion picker; `description` rides into codegen's AI prompt artifact so the
- * model can pick the right preset. Mirrors {@link TokenGroupMetadata}: the
- * `.metadata({...})` chain lands `label` / `description` as top-level fields on
- * the definition, which round-trip through `MotionDef.toJSON` / `fromJSON`.
- */
-interface MotionMetadata {
-  readonly label?: string;
-  readonly description?: string;
-}
-interface MotionTransition {
-  /** How the value moves — {@link MOTION_JS_TRANSITION_TYPES}. */
-  type?: (typeof MOTION_JS_TRANSITION_TYPES)[number];
-  duration?: number | string;
-  delay?: number | string;
-  ease?: string | readonly number[];
-  /** Repeat count (framer `repeat`). */
-  repeat?: number;
-  /** How each repeat plays — {@link MOTION_JS_REPEAT_TYPES}. */
-  repeatType?: (typeof MOTION_JS_REPEAT_TYPES)[number];
-  repeatDelay?: number;
-  stiffness?: number;
-  damping?: number;
-  mass?: number;
-  bounce?: number;
-  velocity?: number;
-  [key: string]: unknown;
-}
-interface MotionStateKeyframe {
-  [key: string]: unknown;
-}
-/**
- * A time-ish CSS motion value: a raw string (`'300ms'`), a number (seconds), or
- * a `token('...')` ref resolved to a `var(...)` at build time — so durations and
- * easings stay token-aware like every other config value, not raw literals.
- */
-type MotionCssValue = string | number | TokenRef;
-/** Per-side box a framer drag prop accepts (`dragConstraints`/`dragElastic`). */
-type MotionDragBox = Partial<Record<'top' | 'right' | 'bottom' | 'left', number>>;
-/**
- * Named animation targets a JS motion can animate between, keyed by variant
- * name (framer's `Variants`). `initial`/`animate`/`while*` may reference a
- * variant by name (a `string`) instead of an inline keyframe.
- */
-type MotionVariants = Record<string, MotionStateKeyframe>;
-/** A JS-motion state: inline keyframes or the name of a declared variant. */
-type MotionState = MotionStateKeyframe | string;
-/** `whileInView` viewport options (framer's `ViewportOptions`). */
-interface MotionViewportOptions {
-  once?: boolean;
-  margin?: string;
-  amount?: number | 'some' | 'all';
-}
-/**
- * The CSS timing/playback surface shared by a registered CSS motion
- * ({@link CssMotionDefinition}) and an inline CSS slot motion
- * ({@link CssSlotMotion}). No `keyframes` here — a definition requires them
- * while a slot motion doesn't, so each declares its own.
- */
-interface CssMotionFields {
-  transition?: MotionTransition;
-  /**
-   * Timing / playback knobs folded into the emitted `animation: …` declaration
-   * alongside the keyframes. No `animation` prefix — it's redundant inside a
-   * motion def, and these are motion-def config, not registered style props.
-   * Explicitly typed (not an open index signature) so they autocomplete, reject
-   * typos, and accept `token(...)` refs where a value can be tokenized
-   * (duration / timing-function / delay).
-   */
-  duration?: MotionCssValue;
-  timingFunction?: string | TokenRef;
-  delay?: MotionCssValue;
-  iterationCount?: number | 'infinite';
-  direction?: (typeof MOTION_CSS_DIRECTIONS)[number];
-  fillMode?: (typeof MOTION_CSS_FILL_MODES)[number];
-  playState?: (typeof MOTION_CSS_PLAY_STATES)[number];
-  /** `'none'` disables the animation under `prefers-reduced-motion: reduce`. */
-  reducedMotion?: 'none';
-}
-interface CssMotionDefinition extends CssMotionFields {
-  runtime: 'css';
-  keyframes: MotionKeyframes;
-  /** Author-side label — see {@link MotionMetadata}. */
-  label?: string;
-  /** Author-side description — see {@link MotionMetadata}. */
-  description?: string;
-}
-/**
- * The framer-motion `motion`-prop surface shared by a registered JS motion
- * ({@link JsMotionDefinition}) and an inline JS slot motion
- * ({@link JsSlotMotion}) — a preset and an inline motion accept the same
- * fields; they differ only in whether `runtime` is required. Typed to the
- * config-serializable subset of framer's API: no element `ref` constraints or
- * event callbacks, which can't round-trip through JSON.
- */
-interface JsMotionFields {
-  /** Named targets `initial`/`animate`/`while*` may reference by name. */
-  variants?: MotionVariants;
-  initial?: MotionState | boolean;
-  animate?: MotionState;
-  /**
-   * Exit keyframes — applied when the host element unmounts. Requires
-   * the consumer to render the slot conditionally so the JS runtime
-   * (`motion/react`'s `<AnimatePresence>`) can play the exit before the
-   * node detaches.
-   */
-  exit?: MotionState;
-  transition?: MotionTransition;
-  /** Keyframes applied while the element is hovered. */
-  whileHover?: MotionState;
-  /** Keyframes applied while the element is actively pressed. */
-  whileTap?: MotionState;
-  /** Keyframes applied while the element holds keyboard focus. */
-  whileFocus?: MotionState;
-  /** Keyframes applied while the element is being dragged. */
-  whileDrag?: MotionState;
-  /** Keyframes applied while the element is in the viewport. */
-  whileInView?: MotionState;
-  viewport?: MotionViewportOptions;
-  drag?: boolean | (typeof MOTION_JS_DRAG_AXES)[number];
-  dragConstraints?: boolean | MotionDragBox;
-  dragElastic?: boolean | number | MotionDragBox;
-  dragMomentum?: boolean;
-  dragSnapToOrigin?: boolean;
-  dragPropagation?: boolean;
-  dragDirectionLock?: boolean;
-  dragTransition?: MotionTransition;
-  layout?: boolean | (typeof MOTION_JS_LAYOUT_MODES)[number];
-  layoutId?: string;
-  layoutDependency?: string | number;
-}
-interface JsMotionDefinition extends JsMotionFields {
-  runtime: 'js';
-  /** Author-side label — see {@link MotionMetadata}. */
-  label?: string;
-  /** Author-side description — see {@link MotionMetadata}. */
-  description?: string;
-}
-type MotionDefinitionInput = CssMotionDefinition | JsMotionDefinition;
-/**
- * Layer-with-overrides shape — the old `@yahoo/uds-create-config` authoring form
- * where a layer carries its tag and its per-layer overrides
- * (`defaultProps`, `base`, etc.) inline. Codegen reads `tag` to set
- * the layer's element and the remaining fields contribute to the
- * layer's emitted styles. Used in tests + legacy configs; the
- * structured marker forms (`tag('div')` etc.) are preferred for new
- * code because they round-trip cleanly through JSON.
- */
-interface LayerWithOverrides {
-  tag: string | TagRef | ComponentRef$1;
-  defaultProps?: Record<string, unknown>;
-  base?: Record<string, unknown>;
-  [key: string]: unknown;
-}
-/**
- * What can appear as a layer's value in `defineComponent`'s `layers`
- * map. Five authoring forms:
- *
- *  - bare tag name string — `'div'`, `'span'`. The old `@yahoo/uds-create-config`
- *    layer syntax; `Component` normalizes to a `TagRef` at construction.
- *  - `TagRef` — `tag('div')` marker form (equivalent to the bare
- *    string; both produce the same on-disk shape).
- *  - `ComponentRef` — string-keyed reference to a registered
- *    component (`component('Box')`).
- *  - `ComponentDefinition` value — the registered component itself
- *    (`{ root: Box, trigger: Pressable }`). Identity-keyed; codegen
- *    resolves it back to a component name via its
- *    `configToName` reverse map at type-narrowing + class-extraction
- *    time. Permits ergonomic `.layers({ root: Box })` authoring.
- *  - `LayerWithOverrides` — `{ tag, defaultProps?, base?, ... }`. The
- *    old layer-with-overrides shape; `Component` lifts `tag` onto
- *    `Layer.tag` and leaves the remaining fields on the layer entry
- *    for codegen to read.
- */
-type LayerInput = string | TagRef | ComponentRef$1 | ComponentDefinition | LayerWithOverrides;
-type BaseStyles = Record<string, Record<string, unknown>>;
-interface CompoundPropsEntry {
-  when: Record<string, unknown>;
-  layers: Record<string, unknown>;
-}
-/**
- * JS-runtime inline slot motion — a `motion/react` config the component
- * carries inline and codegen spreads onto the hoisted `motion.create`
- * wrapper. Shares {@link JsMotionFields} with a `registerMotion({ runtime:
- * 'js' })` preset (identical field set); the only difference is that
- * `runtime` is optional here (absent ⇒ JS).
- */
-interface JsSlotMotion extends JsMotionFields {
-  readonly runtime?: 'js';
-}
-/**
- * CSS-runtime inline slot motion — mirrors the timing/playback knobs of a
- * `registerMotion({ runtime: 'css' })` definition via the shared
- * {@link CssMotionFields}, so an inline CSS motion emits an `animation: …`
- * declaration from its own keyframes instead of pulling in `motion/react`.
- */
-interface CssSlotMotion extends CssMotionFields {
-  readonly runtime: 'css';
-  readonly keyframes?: MotionKeyframes;
-}
-/**
- * Per-layer motion spec a component carries inline, discriminated on
- * `runtime`. Absent/`'js'` → {@link JsSlotMotion} (framer-motion config);
- * `'css'` → {@link CssSlotMotion} (emitted `animation` declaration). Codegen
- * branches on `runtime` and passes the value through to the runtime renderer.
- */
-type SlotMotion = JsSlotMotion | CssSlotMotion;
-/**
- * Component-level motion field. Three shapes:
- *  - `string` — alias of a `registerMotion({...})` preset.
- *  - `{ runtime, ... }` — inline `SlotMotion` applied to the root.
- *  - `Record<string, SlotMotion>` — per-layer record keyed by layer
- *    name (`{ icon: {...}, menu: {...} }`); each layer animates
- *    independently with its own framer config.
- */
-type ComponentMotionValue = string | SlotMotion | Record<string, SlotMotion>;
-type PropBinding = unknown;
-/**
- * Extract the literal HTML tag from a `layers` map when it can be read
- * statically. Returns the bare-tag literal (`'a' | 'div' | ...`) when:
- *
- *  - `layers.root` is a bare tag string (`'a'`),
- *  - `layers.root` is a `TagRef<'a'>` marker,
- *  - `layers.root` is a `LayerWithOverrides` (`{ tag: 'a', ... }`) where
- *    `tag` is a bare string or `TagRef`, or
- *  - `layers.root` is a value-extend wrapper carrying its own captured
- *    root tag (recurses one level so `defineComponent(Box)` inherits
- *    Box's `'div'` root tag).
- *
- * Returns `undefined` when `layers.root` is a value-extend wrapper
- * without a captured tag, or when the field is absent. `Props<T>`
- * reads this and substitutes `ComponentPropsWithRef<TTag>` for the
- * generic `HTMLAttributes<HTMLElement>` when narrowable.
- */
-type RootTag<TLayers> = TLayers extends {
-  root: infer R;
-} ? R extends string ? R : R extends {
-  __kind: 'tag';
-  ref: infer T extends string;
-} ? T : R extends {
-  tag: infer T extends string;
-} ? T : R extends {
-  tag: {
-    __kind: 'tag';
-    ref: infer T extends string;
-  };
-} ? T : R extends {
-  defaultProps: {
-    as: infer A extends string;
-  };
-} ? A : R extends ComponentDefinition<Record<string, LayerInput>, Record<string, PropBinding>, infer TInnerTag> ? TInnerTag : undefined : undefined;
-/**
- * Structural shape of a `defineComponent` config. Parameterized over its
- * `layers`, `props`, and the resolved root tag so a wrapping `Props<T>`
- * walker can read each piece independently without unfolding the wide
- * structural surface at every recursion.
- *
- * Defaults match the historic open shape so existing 70+ use sites that
- * write `ComponentDefinition` un-parameterized continue to typecheck —
- * the narrow forms only kick in when authoring chains thread literal
- * generics through (`defineComponent('div')` → `TTag = 'div'`).
- */
-/**
- * HTML or SVG tag name used to declare a component's forwarded-ref target
- * element via `.config({ ref: 'button' })`. Opt-in by design: a component that
- * omits `ref` exposes no `ref` prop at all, rather than a guessed default.
- *
- * Sourced from React's `JSX.IntrinsicElements` (not the DOM lib's
- * `HTMLElementTagNameMap`) so it resolves under the Bun tsconfig, whose `lib`
- * omits the DOM tag-name maps.
- */
-type RefTag = keyof JSX.IntrinsicElements;
-/**
- * Map a {@link RefTag} to its DOM element interface via React's `ComponentRef`
- * — `'div'` → `HTMLDivElement`, `'svg'` → `SVGSVGElement`. Falls back to
- * `HTMLElement` for anything that isn't a known intrinsic tag.
- */
-type RefElement<Tag> = Tag extends keyof JSX.IntrinsicElements ? ComponentRef<Tag> : HTMLElement;
-interface ComponentDefinition<TLayers extends Record<string, LayerInput> = Record<string, LayerInput>, TProps extends Record<string, PropBinding> = Record<string, PropBinding>, TTag extends string | undefined = string | undefined> {
-  layers: TLayers;
-  props?: TProps;
-  base?: BaseStyles;
-  defaultProps?: Record<string, unknown>;
-  compoundProps?: readonly CompoundPropsEntry[];
-  motion?: ComponentMotionValue;
-  /**
-   * Opt-in forwarded-ref target — an HTML/SVG tag name declaring which DOM
-   * element a consumer `ref` lands on. Drives the typed `ref?: Ref<...>` on the
-   * component's JSX surface and the `ref` arg handed to its render fn. Omit it
-   * and the component exposes no `ref` prop (no guessed default element).
-   */
-  ref?: RefTag;
-  /**
-   * Set when this component is linked from another system — see
-   * {@link SystemLink}. Distinct from `ref` above, which is a DOM tag name for
-   * ref forwarding and unrelated to linking.
-   */
-  link?: SystemLink;
-  /**
-   * Set when a linked component carries an applied `.extend(patch)` override
-   * — see {@link ComponentExtensionRecord}. Only valid beside `link`.
-   */
-  extension?: ComponentExtensionRecord;
-  /**
-   * Phantom slot — populated only as a type marker (never read at
-   * runtime) so `RootTag<TLayers>` callers can fall back to this when
-   * the layer's root is a value-extend wrapper. The value-extend chain
-   * threads its captured `TTag` through here.
-   */
-  readonly __tag?: TTag;
-}
-/**
- * Authored shape for a component's preview block — attached via
- * `defineComponent({...}).preview({...})`. Carries the data Studio +
- * codegen need to render a component tile: `defaultProps` is the
- * baseline JSX prop bag; `matrix` declares the axes for the canvas
- * grid view. Stored verbatim on `Component.preview` and round-trips
- * through JSON unchanged.
- *
- * Named `PreviewDefinition` to match the package's `*Definition`
- * convention and avoid confusion with json-render's `spec` (the
- * canvas-renderable tree that lives at `ManifestPreviewEntry.spec`).
- *
- * `matrix.columns` / `matrix.rows` are typed as `unknown[]` — concrete
- * axis-entry shapes (prop-axis, modifier-axis) belong to the renderer
- * surface, not the authoring contract.
- */
-interface PreviewDefinition<TProps extends Record<string, unknown> = Record<string, unknown>> {
-  /**
-   * Authored — passed to `.preview({ defaultProps })`. Narrowed against
-   * the component's resolved JSX prop shape so callback params
-   * (`onSubmit: (event) => ...`) infer from the component's declared
-   * `TExtra` rather than collapsing to `any`. Falls back to the wide
-   * `Record<string, unknown>` when the call site doesn't supply a
-   * `TProps` generic (Studio + codegen consume the loose shape).
-   */
-  readonly defaultProps?: Partial<TProps>;
-  /** Authored — passed to `.preview({ matrix })`. Drives the canvas grid view.
-   *  `pinnedModifiers` is the pinned state-modifier set kept independent of
-   *  the displayed axes (a regroup that hides the state dimension drops its
-   *  markers from `rows`/`columns`; the pinned set survives here). It is NOT
-   *  the same as a `states([...])` axis entry: that one is positional — a
-   *  displayed row-chain level with `'rest'` included — while this registry
-   *  is arrangement-independent and never contains `'rest'`. */
-  readonly matrix?: {
-    readonly columns?: readonly unknown[];
-    readonly rows?: readonly unknown[];
-    readonly pinnedModifiers?: readonly string[];
-  };
-  /**
-   * Codegen-extracted — parsed json-render spec from
-   * `defaultProps.children` JSX. Studio's canvas + docs read this to
-   * render the preview tile. Plain JSON (no functions / React elements).
-   */
-  readonly spec?: Readonly<Record<string, unknown>>;
-}
-/**
- * Wire shape for a component — what lands in `config.json`. The
- * authored `ComponentDefinition` plus the two enrichments that aren't
- * authored at the call site: `preview` (added by the `.preview()`
- * chain) and `sourceFilePath` (stack-walked by `captureCallerPath` at
- * `defineComponent` time). Kept separate from `ComponentDefinition`
- * so IDE completions inside `defineComponent({...})` don't suggest
- * fields the author can't write directly.
- */
-interface SerializedComponent extends ComponentDefinition {
-  preview?: PreviewDefinition;
-  /**
-   * Path of the file that defined the component. Relative to
-   * `meta.projectRoot` when `Config.toJSON({ projectRoot })` is used
-   * (CLI's path) — keeps `config.json` portable across machines.
-   * Absolute when serialized without a `projectRoot`.
-   */
-  sourceFilePath?: string;
-  /**
-   * `true` when the authored component chained `.render(fn)`. The fn itself
-   * can't serialize; this flag preserves the codegen classification (transform
-   * path vs inline primitive emitter) across a `toJSON`/`fromJSON` round-trip
-   * so a hydrated single-layer `.render(fn)` component isn't downleveled as a
-   * bare-tag primitive. Mirrors `Component.hasRenderFn`.
-   */
-  hasRenderFn?: boolean;
-  /** `.renderCanvas(fn)` sibling of {@link hasRenderFn} — mirrors
-   *  `Component.hasCanvasRenderFn`. */
-  hasCanvasRenderFn?: boolean;
-  /**
-   * Set on a sub-part — name of the parent that owns it. Mirrors
-   * `Component.derived.subcomponentOf`. The authored relationship is
-   * declared on the parent via `.subcomponents({...})`; this field is
-   * the wire-format echo so `Config.fromJSON` can rebuild the linkage
-   * without re-running the original `.subcomponents` chain.
-   */
-  subcomponentOf?: string;
-  /**
-   * Name of the component this one value-extends via `defineComponent(Source)`.
-   * Mirrors `Component.extendsFrom`; lets consumers diff a child's props
-   * against the parent's instead of re-listing the inherited surface.
-   */
-  extendsFrom?: string;
-  /**
-   * Set on a parent — child names declared via `.subcomponents({...})`.
-   * Mirrors `Component.derived.subcomponents`.
-   */
-  subcomponents?: readonly string[];
-}
-/**
- * Authored shape for a component group — a labeled bundle of
- * registered components surfaced together in the Studio palette,
- * codegen catalog, and AI prompt.
- *
- * `components` is keyed by the registration name (same surface as
- * `registerComponents`); each value is a plain `ComponentDefinition`.
- * Registration flattens these into `Config.components` and stamps
- * `componentGroup` on each member's `Component.derived`.
- *
- * The serialized form (`SerializedComponentGroup`) replaces
- * `components: Record<string, ComponentDefinition>` with
- * `components: readonly string[]` — names only — because the
- * definitions themselves live under `config.components` on disk.
- */
-interface ComponentGroupDefinition {
-  label: string;
-  description?: string;
-  /**
-   * Slug of the parent component group this one nests under. Omitted
-   * means the group sits at the top level of the palette tree.
-   */
-  parent?: string;
-  components: Record<string, ComponentDefinition>;
-}
-interface SerializedComponentGroup {
-  label: string;
-  description?: string;
-  /**
-   * Slug of the parent component group this one nests under. Omitted
-   * means the group sits at the top level of the palette tree.
-   */
-  parent?: string;
-  components: readonly string[];
-}
-/**
- * One font-class asset member — a pure-JSON data record (no FC to
- * render), mirroring `@yahoo/uds-fonts`' `FontDeclarationConfig`. The
- * structural contract the font-class member guard enforces is
- * `fontFamily` + `declarations[]`; everything else (`fallback`,
- * weights/axes, `isVariableFont`, …) rides along through the open
- * index so the registered record stays faithful to the source map
- * without `@yahoo/uds-create-config` depending on the font package's types.
- */
-interface FontAssetMember {
-  /** CSS-facing family name (`'YA Sans VF'`). */
-  readonly fontFamily: string;
-  /**
-   * `@font-face` source declarations (CDN URLs, weights/axes) — pure
-   * JSON the browser loader derives `@font-face` rules from.
-   */
-  readonly declarations: readonly Record<string, unknown>[];
-  /**
-   * Governance flag stamped at registration from the group's `deprecated`
-   * FontID list. Deprecated fonts stay fully selectable (no hard block) —
-   * this only lets the picker surface a badge. Rides the open index, so it
-   * round-trips through serialization with the rest of the record.
-   */
-  readonly deprecated?: boolean;
-  readonly [key: string]: unknown;
-}
-/**
- * Wire shape for one asset group, discriminated by `assetKind` from
- * day one so future asset classes extend the union without a wire
- * migration. The member shape is per-class:
- *
- *  - `'icon'` — `members` is a member-*name* list. The React
- *    components ship in the consumer bundle, so the serialized form
- *    only needs names (mirrors `SerializedComponentGroup.components`).
- *  - `'font'` — `members` is the full member-*record* map. Font
- *    members are already plain JSON and the browser `@font-face`
- *    loader needs the records themselves.
- */
-interface SerializedIconAssetGroup {
-  assetKind: 'icon';
-  label: string;
-  description?: string;
-  /** Source-library version shown in the Assets UI (e.g. `2.1.1`). */
-  version?: string;
-  /** Named size → px. The picker's size options are these keys. */
-  sizes: Readonly<Record<string, number>>;
-  /** Group-level variant superset (declared or harvested union). */
-  variants: readonly string[];
-  /**
-   * Authoring component for code export (`'Icon'`) — lets code views
-   * serialize a placed asset node as `<Icon name="Trophy" … />` and
-   * round-trip it. Also the component a placed member renders through on
-   * the canvas. Omitted for a component-less group (members render bare).
-   */
-  component?: string;
-  members: readonly string[];
-  /**
-   * Per-member harvested metadata (each icon's own variants, category,
-   * tags), keyed by asset name. Carried on the wire so the browser picker
-   * can narrow ragged variants and search tags/category from the resolved
-   * config alone — without introspecting live member components. Omitted
-   * when no member carried metadata (e.g. a metadata-less library).
-   */
-  memberMetadata?: Readonly<Record<string, IconAssetMetadata>>;
-}
-interface SerializedFontAssetGroup {
-  assetKind: 'font';
-  label: string;
-  description?: string;
-  /** Source-library version shown in the Assets UI (e.g. `2.1.1`). */
-  version?: string;
-  members: Readonly<Record<string, FontAssetMember>>;
-}
-type SerializedAssetGroup = SerializedIconAssetGroup | SerializedFontAssetGroup;
-/**
- * The Studio canvas insert tools a component can back. `frame` drives
- * the frame/draw tool (Box / VStack / HStack-style containers); `text`
- * drives the text tool. Registered via
- * `config.registerCanvasRoles({...})` so the canvas resolves its
- * toolbar through the config instead of hardcoded component names.
- */
-type CanvasRole = 'frame' | 'text';
-/** One component entry backing a canvas role's tool (normalized/wire shape). */
-interface CanvasRoleEntry {
-  /**
-   * Registered component name (`'Box'`). Narrows to the registered
-   * component names once the `RegisteredComponents` augmentation is
-   * emitted; falls open to `string` before the first build. Existence
-   * is enforced at registration time either way.
-   */
-  readonly component: ComponentName;
-  /**
-   * Marks the tool's preselected entry. At most one per role; when no
-   * entry is marked, the first entry is the default.
-   */
-  readonly default?: boolean;
-  /**
-   * Initial props for the element the tool inserts, in spec prop syntax
-   * (`width: '[200px]'`, `bg: 'primary'`). JSON-safe values only — the
-   * record rides the wire format. Insert tools may override entries the
-   * gesture itself determines (a drawn frame's `width`/`height`).
-   */
-  readonly defaultProps?: Readonly<Record<string, unknown>>;
-}
-/**
- * Wire shape for canvas roles — entries normalized to component *names*.
- * Round-trips through `Config.toJSON()` / `fromJSON()` unchanged.
- */
-type CanvasRolesDefinition = Partial<Record<CanvasRole, readonly CanvasRoleEntry[]>>;
-/**
- * Authoring-time entry for `registerCanvasRoles`. `component` may be the
- * registered name (`'Box'`) or the authored `defineComponent(...)` value
- * itself (`Box`). Passing the value types `defaultProps` against that
- * component's real prop surface via {@link CanvasRolesInputConstraint} —
- * `defaultProps: { width: 200 }` fails to compile when `width` only
- * accepts tokens / `[<css>]` literals.
- */
-interface CanvasRoleEntryInput {
-  readonly component: ComponentName | ComponentDefinition;
-  readonly default?: boolean;
-  readonly defaultProps?: Readonly<Record<string, unknown>>;
-}
-type CanvasRolesDefinitionInput = Partial<Record<CanvasRole, readonly CanvasRoleEntryInput[]>>;
-/**
- * Per-entry `defaultProps` narrowing: when `component` is an authored
- * component value, its `FC<Props<T>>` call signature carries the JSX
- * prop surface — `defaultProps` must be a `Partial` of it. A string
- * component name (no call signature to infer from) leaves the entry
- * unconstrained beyond {@link CanvasRoleEntryInput}.
- */
-type CanvasRoleEntryConstraint<E> = E extends {
-  readonly component: infer C;
-} ? C extends ((props: infer P) => unknown) ? {
-  readonly defaultProps?: Partial<P>;
-} : unknown : unknown;
-/**
- * Validator generic for `registerCanvasRoles` — intersected with the
- * inferred input so each entry's `defaultProps` typechecks against its
- * own `component` value.
- */
-type CanvasRolesInputConstraint<R> = { readonly [K in keyof R]: R[K] extends readonly unknown[] ? { readonly [I in keyof R[K]]: CanvasRoleEntryConstraint<R[K][I]> } : unknown };
-type GlobalStylesDef = Record<string, Record<string, unknown>>;
-/**
- * Build-time knobs settable via `config.configure({ buildOptions })`. Read
- * by the codegen pipeline (`@yahoo/uds-create-codegen`) and the CLI to gate
- * artifact emission. Authored on the config instance, propagated as-is.
- */
-interface BuildOptions {
-  skipCssVariables?: boolean;
-  preflight?: boolean;
-  /**
-   * Trusted source root (relative to the project root) the push pipeline
-   * is allowed to traverse when publishing component files and their local
-   * dependencies. Bounds the dependency walk to this subtree so a component
-   * can't drag in arbitrary app code, `node_modules`, or files outside the
-   * design system. Authored via `configure({ buildOptions: { componentsDir } })`
-   * (e.g. `'src/uds/components'`); read by the CLI at push time.
-   */
-  componentsDir?: string;
-  /**
-   * Source globs (relative to the config file's directory) scanned by
-   * `uds build` to safelist the utility classes a consumer app's own JSX
-   * produces (`<Box gap="6">` → `.gap-6` lands in the purged `styles.css`).
-   * REPLACES the default scan of `src/​**​/*.{ts,tsx}` when set — an app that
-   * also keeps JSX under `src/` must include a glob covering it. Prefer
-   * directory-scoped globs (`app/​**​/*.{ts,tsx}`) over `./​**` so unrelated
-   * `*.config.ts` files don't enter the component-authoring scans.
-   */
-  content?: string[];
-  /**
-   * Where `uds pull` materializes linked-system dependencies, relative to
-   * the project root. Optional — defaults to `<componentsDir>/registry`
-   * (or `.uds-registry` when no `componentsDir` is declared). Registry
-   * files are consumed as sealed foreign sources: the push pipeline never
-   * seals them as the consumer's own components, and the loader never
-   * rewrites their imports.
-   */
-  registryDir?: string;
-  /**
-   * Scope every emitted CSS selector under this class name. The
-   * emitter's `:root` block becomes `.<cssScope>`; mode/theme blocks
-   * (e.g. `.dark` or `[data-theme="slate"]`) append `.<cssScope>` so
-   * they still apply when the attribute is on `<html>`. Utility
-   * classes nest under `.<cssScope>` so two UDS-powered packages on
-   * the same page don't collide.
-   */
-  cssScope?: string;
-}
-/** A json-render spec authored for a custom playground page — a plain
- *  `{ root, elements }` object rendered through `UdsRenderer`. */
-type PlaygroundSpec = Readonly<Record<string, unknown>>;
-/**
- * A playground page — the default export of a file in
- * `PlaygroundOptions.pagesDir`. Dispatched by shape at render time:
- *  - a React component (a function) rendered on the playground React engine;
- *    optional `Component.title` / `Component.description` statics set its nav
- *    label and subtitle (both fall back to the filename otherwise);
- *  - a json-render spec (`{ root, elements }`) rendered via `UdsRenderer`;
- *  - a descriptor `{ title?, description?, component }` or
- *    `{ title?, description?, spec }` — the same renderables with an explicit
- *    display title and description. Specs use this form since a plain spec
- *    object has nowhere to carry a title.
- */
-type PlaygroundPage = ComponentType | PlaygroundSpec | {
-  title?: string;
-  description?: string;
-  component: ComponentType;
-} | {
-  title?: string;
-  description?: string;
-  spec: PlaygroundSpec;
-};
-/** Authored via `configure({ playgroundOptions })` — the playground pages
- *  directory plus `uds dev --playground` settings. */
-interface PlaygroundOptions {
-  /** Directory (relative to the config file) whose files each default-export a
-   *  {@link PlaygroundPage}. Codegen globs it at build time — every file with a
-   *  default export becomes a page, keyed (and titled, by default) by filename.
-   *  Files without a default export are ignored, so colocated helpers are safe. */
-  pagesDir?: string;
-  /** Port the playground dev server binds (default 4321). */
-  port?: number;
-}
-/** Serializable subset of {@link PlaygroundOptions} that lands in `config.json`.
- *  Only the port rides the wire — `pagesDir` is a build-time input codegen reads
- *  from the config source, and the pages themselves (React functions + spec
- *  data) are bundled as code (`playground/pages.tsx`), so the playground reads
- *  them from the bundle, not `config.json`. */
-interface SerializedPlaygroundOptions {
-  port?: number;
-}
-/**
- * One pinned source system in `registerLinkedSystems` — the version anchor
- * every linked value from that system validates against. The record key (the
- * source system's database UUID) is the identity; `name` is the system's
- * display-name snapshot at link time, used for review surfaces and to derive
- * the registry folder slug — the source system renaming itself does not
- * orphan the pin.
- */
-interface LinkedSystemPin {
-  /** Display-name snapshot of the linked system at link time. Never identity. */
-  name: string;
-  /** Exact published version of the linked system (`'1.3.1'`) — no ranges. */
-  version: string;
-}
-/** Input to `registerLinkedSystems`, keyed by the linked system's UUID. */
-type LinkedSystemsInput = Record<string, LinkedSystemPin>;
-/**
- * `Config.toJSON()` produces this shape. Mirrors authored fields exactly
- * — derived data is never serialized. The `{ __kind, ref }` marker shape
- * appears wherever a position can hold either a literal or a cross-ref.
- */
-interface SerializedConfig {
-  schemaVersion: number;
-  builtAt?: string;
-  prefix: string;
-  /** Registry namespace that prefixes component `registryKey`s
-   *  (`<namespace>:<Component>`). Absent for un-namespaced configs.
-   *  Declared via `configure({ namespace })`. */
-  namespace?: string;
-  preflight: boolean;
-  designPrinciples?: readonly string[];
-  globalStyles?: GlobalStylesDef;
-  /** Raw CSS strings included verbatim via `config.includeCss()` (e.g.
-   *  `@font-face` blocks). Emitted after compilation, ahead of generated CSS. */
-  rawCss?: readonly string[];
-  /** Build-time knobs authored via `configure({ buildOptions })`. Serialized
-   *  so the CLI/codegen can read them from `config.json` (e.g. the trusted
-   *  `componentsDir` traversal root). Absent when no options are set. */
-  buildOptions?: BuildOptions;
-  modes?: Record<string, ModeDefinition>;
-  modifiers?: Record<string, ModifierDefinition>;
-  tokenGroups?: Record<string, SerializedTokenGroup>;
-  styleProps?: Record<string, AnyStylePropDefinition>;
-  compositeStyles?: Record<string, CompositeStyleDefinition>;
-  motion?: Record<string, MotionDefinitionInput>;
-  components?: Record<string, SerializedComponent>;
-  componentGroups?: Record<string, SerializedComponentGroup>;
-  /**
-   * Registered asset groups, keyed by slug. Optional — old
-   * `config.json` files without it hydrate to an empty map; no
-   * `schemaVersion` bump.
-   */
-  assetGroups?: Record<string, SerializedAssetGroup>;
-  providers?: Record<string, Record<string, never>>;
-  /**
-   * Canvas tool → component mappings from `registerCanvasRoles`.
-   * Optional — old `config.json` files without it hydrate to an empty
-   * map; no `schemaVersion` bump.
-   */
-  canvasRoles?: CanvasRolesDefinition;
-  /**
-   * Root-config playground settings from `configure({ playgroundOptions })`.
-   * Optional — old `config.json` files without it hydrate to empty; no
-   * `schemaVersion` bump. Only the serializable subset (spec pages, port) is
-   * here; React-component pages are emitted as bundled code by codegen.
-   */
-  playgroundOptions?: SerializedPlaygroundOptions;
-  /**
-   * Source systems pinned via `registerLinkedSystems`, keyed by the source
-   * system's database UUID. Every linked value in the config validates
-   * against its pin (systemId present, version matching). Optional — old
-   * `config.json` files without it hydrate to an empty map; no
-   * `schemaVersion` bump.
-   */
-  linkedSystems?: Record<string, LinkedSystemPin>;
-}
-//#endregion
-export { AnyStylePropDefinition, ArbitraryEntry, ArbitrarySpec, BaseStyles, BuildOptions, CanvasRole, CanvasRoleEntry, CanvasRoleEntryInput, CanvasRolesDefinition, CanvasRolesDefinitionInput, CanvasRolesInputConstraint, ComponentDefinition, ComponentExtension, ComponentExtensionRecord, ComponentGroupDefinition, ComponentMetadata, ComponentMotionValue, CompositeStyleDefinition, CompositeStyleObject, CompoundPropsEntry, CssMotionDefinition, CssMotionFields, CssSlotMotion, FontAssetMember, GlobalStylesDef, JsMotionDefinition, JsMotionFields, JsSlotMotion, LayerInput, LinkedSystemPin, LinkedSystemsInput, LiteralFor, ModeDefinition, ModeOptionDefinition, ModifierDefinition, MotionDefinitionInput, MotionDragBox, MotionKeyframes, MotionMetadata, MotionState, MotionStateKeyframe, MotionTransition, MotionVariants, MotionViewportOptions, OpacityPairSpec, PlaygroundOptions, PlaygroundPage, PlaygroundSpec, PreviewDefinition, PropBinding, RefElement, RefTag, RootTag, SerializedAssetGroup, SerializedComponent, SerializedComponentGroup, SerializedConfig, SerializedFontAssetGroup, SerializedIconAssetGroup, SerializedPlaygroundOptions, SerializedTokenGroup, SlotMotion, StylePropDefinition, StylePropMetadata, StylePropProperty, SystemLink, TokenDefinition, TokenDefinitionFor, TokenGroupDefinition, TokenGroupDefinitionFor, TokenModifierKey, TokenModifierValue, TokenType, TokenValue, ValuesEntry };