@animus-ui/system 0.1.20 → 0.1.22

package/dist/index-C1AAiaiJ.d.ts

@@ -0,0 +1,663 @@
+import { i as ClassResolverConfig, t as ClassResolver } from "./createClassResolver-Do1nmvkf.js";
+import { $ as SerializedTheme, A as SystemProps, At as ReservedByConditionRegistry, Ct as ConditionAliasMap, Dt as NarrowedAliases, F as VariantConfig, G as CSSColorValue, H as AbstractTheme, J as ContextualVarRegistration, K as ColorModeOptions, M as ThemedCSSProps, R as AbstractProps, Z as ModeAliasDefinition, _ as CSSProps, _t as KeyframeFrameMap, a as BuilderClassProps, at as TokenDefinition, bt as AtRuleValue, d as StylingNames, f as SystemPicks, g as CSSPropMap, h as BuiltInSelectorAlias, ht as SelectorAliasMap, it as ThemeStructuralKey, j as ThemedCSSPropMap, jt as ReservedBySelectorRegistry, k as SystemProp, kt as RegistryBrand, l as AnimusExtended, lt as LiteralPaths, m as BuiltInConditionAlias, n as AnimusComponent, nt as ThemeCssFragment, p as AbstractParser, r as AnimusWrappedComponent, rt as ThemeManifest, st as CSSObject, v as CompoundEntry, x as DeclarationProp, y as CustomPropConfig, yt as Keyframes } from "./component-stJhG_A-.js";
+import "./compose-BQi7TDtL.js";
+import "./createComposedFamily-BkrvSsfl.js";
+import { ComponentType, JSX } from "react";
+//#region src/Animus.d.ts
+declare class AnimusWithAll<PropRegistry extends Record<string, SystemProp>, GroupRegistry extends Record<string, (keyof PropRegistry)[]>, BaseStyles extends CSSProps<AbstractProps, SystemProps<AbstractParser>>, Variants extends Record<string, VariantConfig>, States extends CSSPropMap<AbstractProps, SystemProps<AbstractParser>>, ActiveGroups extends Record<string, true>, CustomProps extends Record<string, SystemProp>> {
+  propRegistry: PropRegistry;
+  groupRegistry: GroupRegistry;
+  baseStyles: BaseStyles;
+  statesConfig: States;
+  variants: Variants;
+  activeGroups: ActiveGroups;
+  custom: CustomProps;
+  compounds: CompoundEntry[];
+  constructor(props: PropRegistry, groups: GroupRegistry, base: BaseStyles, variants: Variants, states: States, activeGroups: ActiveGroups, custom: CustomProps, compounds?: CompoundEntry[]);
+  protected extend(): AnimusExtended<PropRegistry, GroupRegistry, BaseStyles, Variants, States, ActiveGroups, CustomProps>;
+  asElement<El extends keyof JSX.IntrinsicElements>(component: El): AnimusComponent<El, PropRegistry, GroupRegistry, BaseStyles, Variants, States, ActiveGroups, CustomProps>;
+  asComponent<C extends ComponentType<any>>(AsComponent: C): AnimusWrappedComponent<C, PropRegistry, GroupRegistry, BaseStyles, Variants, States, ActiveGroups, CustomProps>;
+  asClass<This extends {
+    _buildComponentConfig(): ClassResolverConfig;
+  }>(this: This): ClassResolver<BuilderClassProps<This>>;
+  _buildComponentConfig(): ClassResolverConfig;
+}
+declare class AnimusWithSystem<PropRegistry extends Record<string, SystemProp>, GroupRegistry extends Record<string, (keyof PropRegistry)[]>, BaseStyles extends CSSProps<AbstractProps, SystemProps<AbstractParser>>, Variants extends Record<string, VariantConfig>, States extends CSSPropMap<AbstractProps, SystemProps<AbstractParser>>, ActiveGroups extends Record<string, true>> extends AnimusWithAll<PropRegistry, GroupRegistry, BaseStyles, Variants, States, ActiveGroups, {}> {
+  constructor(props: PropRegistry, groups: GroupRegistry, base: BaseStyles, variants: Variants, states: States, activeGroups: ActiveGroups, compounds?: CompoundEntry[]);
+  props<NewCustomProps extends Record<string, CustomPropConfig | DeclarationProp>>(config: NewCustomProps): AnimusWithAll<PropRegistry, GroupRegistry, BaseStyles, Variants, States, ActiveGroups, NewCustomProps>;
+}
+declare class AnimusWithStates<PropRegistry extends Record<string, SystemProp>, GroupRegistry extends Record<string, (keyof PropRegistry)[]>, BaseStyles extends CSSProps<AbstractProps, SystemProps<AbstractParser>>, Variants extends Record<string, VariantConfig>, States extends CSSPropMap<AbstractProps, SystemProps<AbstractParser>>> extends AnimusWithSystem<PropRegistry, GroupRegistry, BaseStyles, Variants, States, {}> {
+  constructor(props: PropRegistry, groups: GroupRegistry, base: BaseStyles, variants: Variants, states: States, compounds?: CompoundEntry[]);
+  system<PickedKeys extends keyof GroupRegistry | Extract<keyof PropRegistry, string>>(config: SystemPicks<GroupRegistry, PickedKeys, StylingNames<Variants, States>>): AnimusWithSystem<PropRegistry, GroupRegistry, BaseStyles, Variants, States, Record<PickedKeys, true>>;
+}
+declare class AnimusWithCompounds<PropRegistry extends Record<string, SystemProp>, GroupRegistry extends Record<string, (keyof PropRegistry)[]>, BaseStyles extends CSSProps<AbstractProps, SystemProps<AbstractParser>>, Variants extends Record<string, VariantConfig>> extends AnimusWithStates<PropRegistry, GroupRegistry, BaseStyles, Variants, {}> {
+  constructor(props: PropRegistry, groups: GroupRegistry, base: BaseStyles, variants: Variants, compounds?: CompoundEntry[]);
+  compound<Props extends AbstractProps>(condition: { [K in keyof Variants]?: keyof Variants[K]['variants'] | ReadonlyArray<keyof Variants[K]['variants']>; }, styles: ThemedCSSProps<Props, PropRegistry>): AnimusWithCompounds<PropRegistry, GroupRegistry, BaseStyles, Variants>;
+  states<Props extends AbstractProps>(config: ThemedCSSPropMap<Props, PropRegistry>): AnimusWithStates<PropRegistry, GroupRegistry, BaseStyles, Variants, ThemedCSSPropMap<Props, PropRegistry>>;
+}
+declare class AnimusWithVariants<PropRegistry extends Record<string, SystemProp>, GroupRegistry extends Record<string, (keyof PropRegistry)[]>, BaseStyles extends CSSProps<AbstractProps, SystemProps<AbstractParser>>, Variants extends Record<string, VariantConfig>> extends AnimusWithCompounds<PropRegistry, GroupRegistry, BaseStyles, Variants> {
+  constructor(props: PropRegistry, groups: GroupRegistry, base: BaseStyles, variants: Variants, compounds?: CompoundEntry[]);
+  compound<Props extends AbstractProps>(condition: { [K in keyof Variants]?: keyof Variants[K]['variants'] | ReadonlyArray<keyof Variants[K]['variants']>; }, styles: ThemedCSSProps<Props, PropRegistry>): AnimusWithCompounds<PropRegistry, GroupRegistry, BaseStyles, Variants>;
+  variant<Keys extends keyof Props, Base extends AbstractProps, Props extends Record<Keys, AbstractProps>, PropKey extends Readonly<string> = 'variant'>(options: {
+    prop?: PropKey;
+    defaultVariant?: Extract<keyof Props, string>;
+    base?: ThemedCSSProps<Base, PropRegistry>;
+    variants: ThemedCSSPropMap<Props, PropRegistry>;
+  }): AnimusWithVariants<PropRegistry, GroupRegistry, BaseStyles, Variants & Record<PropKey, {
+    prop?: PropKey;
+    defaultVariant?: Extract<keyof Props, string>;
+    base?: ThemedCSSProps<Base, PropRegistry>;
+    variants: ThemedCSSPropMap<Props, PropRegistry>;
+  }>>;
+}
+declare class AnimusWithBase<PropRegistry extends Record<string, SystemProp>, GroupRegistry extends Record<string, (keyof PropRegistry)[]>, BaseStyles extends CSSProps<AbstractProps, SystemProps<AbstractParser>>> extends AnimusWithVariants<PropRegistry, GroupRegistry, BaseStyles, {}> {
+  constructor(props: PropRegistry, groups: GroupRegistry, base: BaseStyles);
+  variant<Keys extends keyof Props, Base extends AbstractProps, Props extends Record<Keys, AbstractProps>, PropKey extends Readonly<string> = 'variant'>(options: {
+    prop?: PropKey;
+    defaultVariant?: Extract<keyof Props, string>;
+    base?: ThemedCSSProps<Base, PropRegistry>;
+    variants: ThemedCSSPropMap<Props, PropRegistry>;
+  }): AnimusWithVariants<PropRegistry, GroupRegistry, BaseStyles, Record<PropKey, {
+    prop?: PropKey;
+    defaultVariant?: Extract<keyof Props, string>;
+    base?: ThemedCSSProps<Base, PropRegistry>;
+    variants: ThemedCSSPropMap<Props, PropRegistry>;
+  }>>;
+}
+declare class Animus<PropRegistry extends Record<string, SystemProp>, GroupRegistry extends Record<string, (keyof PropRegistry)[]>> extends AnimusWithBase<PropRegistry, GroupRegistry, {}> {
+  constructor(props: PropRegistry, groups: GroupRegistry);
+  styles<Props extends AbstractProps>(config: ThemedCSSProps<Props, PropRegistry>): AnimusWithBase<PropRegistry, GroupRegistry, ThemedCSSProps<Props, PropRegistry>>;
+}
+//#endregion
+//#region src/asset.d.ts
+declare const ASSET_REF_BRAND: unique symbol;
+/**
+ * A plain string so it crosses the sandbox's JSON boundary untouched; the host
+ * plugin substitutes the placeholder with the bundler-resolved URL.
+ */
+type AssetRef = string & {
+  readonly [ASSET_REF_BRAND]: true;
+};
+declare const ASSET_PLACEHOLDER_PREFIX = "animus-asset:";
+/**
+ * Brands the specifier only — aliases, exports maps and hashing belong to the
+ * host bundler. A literal URL string stays a valid alternative.
+ */
+declare function asset(specifier: string): AssetRef;
+//#endregion
+//#region src/transforms/createTransform.d.ts
+/** A transform returns a string or a finite number. */
+type TransformFn = (value: string | number, property?: string, props?: AbstractProps) => string | number;
+type NamedTransform = TransformFn & {
+  transformName: string;
+  /**
+   * A wrapper's own `toString()` is identical for every transform, so
+   * equality compares this captured source instead.
+   */
+  transformSource?: string;
+};
+declare function createTransform(name: string, fn: TransformFn): NamedTransform;
+/**
+ * Two transforms with byte-identical source compare equal even when they
+ * close over different values.
+ */
+declare function areTransformsEqual(a: TransformFn | undefined, b: TransformFn | undefined): boolean;
+//#endregion
+//#region src/SystemBuilder.d.ts
+type GlobalStyleMap = Record<string, Record<string, any>>;
+interface FontFaceSrc {
+  /**
+   * A literal string is emitted byte-exact; an `AssetRef` emits its
+   * placeholder string, which the host plugin substitutes after extraction.
+   */
+  url: string | AssetRef;
+  /** Format hint (`woff2`, `woff`, …), rendered as `format('…')`. */
+  format?: string;
+}
+/**
+ * `family` may use a font-scale token reference (`{fonts.body}`); the other
+ * descriptors take CSS literals only.
+ */
+interface FontFace {
+  family: string;
+  src: FontFaceSrc[];
+  weight?: string;
+  style?: string;
+  display?: string;
+  unicodeRange?: string;
+  stretch?: string;
+}
+interface GlobalStyleBlock {
+  __brand: 'GlobalStyleBlock';
+  styles: GlobalStyleMap;
+  /** Rendered ahead of the block's selector rules. */
+  fontFaces?: FontFace[];
+  /**
+   * Emitted outside every cascade layer, after `@layer anm-global`, so its
+   * rules can win over unlayered vendor CSS; otherwise in `anm-global`.
+   */
+  unlayered?: true;
+}
+type GlobalStylesFactory<PropReg extends Record<string, SystemProp> = Record<string, SystemProp>> = <Map extends Record<string, AbstractProps>>(styles: { readonly [K in keyof Map]: ThemedCSSProps<Map[K], PropReg>; }, options?: {
+  fontFaces?: readonly FontFace[];
+  unlayered?: boolean;
+}) => GlobalStyleBlock;
+type CreateKeyframesFactory<PropReg extends Record<string, SystemProp> = Record<string, SystemProp>> = <Frames extends Record<string, Record<string, AbstractProps>>>(frames: { readonly [N in keyof Frames]: { readonly [S in keyof Frames[N]]: ThemedCSSProps<Frames[N][S], PropReg>; }; }) => Keyframes<{ readonly [N in keyof Frames]: KeyframeFrameMap; }>;
+type IncludableSystem = {
+  toConfig(): SerializedConfig;
+  /**
+   * Optional only so systems built by an older @animus-ui/system stay
+   * structurally acceptable; `extend()` throws when it is absent.
+   */
+  getRegistrySnapshot?(): RegistrySnapshot;
+};
+/**
+ * Frozen at `build()`: `toConfig()` serializes and `extend()` merges from
+ * it, so post-build mutation of the public registries reaches neither.
+ */
+interface RegistrySnapshot {
+  props: Record<string, SystemProp>;
+  groups: Record<string, readonly string[]>;
+  selectors: SelectorAliasMap;
+  conditions: ConditionAliasMap;
+}
+/**
+ * The shape `registerKeyframes` accepts. The brand is structural: a
+ * hand-rolled object carrying it is admitted; provenance is not checked.
+ */
+interface RegisterableKeyframes {
+  readonly __brand: 'Keyframes';
+  readonly __frames: object;
+}
+interface RegisterableGlobalStyles {
+  readonly __brand: 'GlobalStyleBlock';
+  readonly styles: object;
+}
+type KeyframesFrameData = Record<string, {
+  readonly name: string;
+  readonly frames: KeyframeFrameMap;
+}>;
+interface VocabularyKeyframesEntry {
+  readonly name: string;
+  readonly frames: KeyframesFrameData;
+}
+interface VocabularyGlobalStyleEntry {
+  readonly name: string;
+  readonly styles: GlobalStyleMap;
+  readonly fontFaces?: readonly FontFace[];
+  readonly unlayered?: true;
+}
+interface VocabularyCollisionEntry {
+  /** Stable machine code — the record, not the console, is the witness
+   * channel (the loader's evaluation host shims `console` to a no-op). */
+  readonly code: 'animus.vocabulary.collision';
+  readonly name: string;
+  readonly winner: string;
+  readonly loser: string;
+}
+/**
+ * Names a sealed source's registered vocabulary that `from()` / `includes:`
+ * did not deliver — those verbs merge no registries; `.extend()` does.
+ */
+interface VocabularyLegacyVerbEntry {
+  readonly code: 'animus.vocabulary.legacy-verb';
+  readonly verb: 'from' | 'includes';
+  /** Positional label (`includes source #1`) — a source has no knowable
+   *  export name at this seam. */
+  readonly source: string;
+  readonly names: readonly string[];
+}
+/**
+ * The registration record a sealed system carries, in declaration order.
+ * The loader reads registered collections exclusively from here.
+ */
+interface VocabularyRecord {
+  readonly version: 1;
+  readonly keyframes: readonly VocabularyKeyframesEntry[];
+  readonly globalStyles: readonly VocabularyGlobalStyleEntry[];
+  readonly collisions: readonly VocabularyCollisionEntry[];
+  readonly legacyVerbs: readonly VocabularyLegacyVerbEntry[];
+}
+/** ONE name-space across both kinds: a global-style block and a keyframes
+ *  collection cannot share a registered name. */
+type VocabularyEntryState = {
+  kind: 'keyframes';
+  name: string;
+  frames: KeyframesFrameData;
+  origin: string;
+} | {
+  kind: 'globalStyles';
+  name: string;
+  styles: GlobalStyleMap;
+  fontFaces?: readonly FontFace[];
+  unlayered?: true;
+  origin: string;
+};
+declare const VOCABULARY_COLLISION_BRAND: unique symbol;
+/**
+ * Impossible-to-satisfy marker so a colliding registration site reports the
+ * offending vocabulary name instead of a bare structural mismatch.
+ */
+interface VocabularyNameCollision<Name extends string> {
+  readonly [VOCABULARY_COLLISION_BRAND]: `Vocabulary name "${Name}" is already registered on this system`;
+}
+declare const VOCABULARY_INDEX_SIGNATURE: unique symbol;
+/**
+ * Rejects index-signature maps: they bypass the collision mapping
+ * (`Extract<string, Vocab>` is `never`) and widen the axis to `string`.
+ */
+interface VocabularyIndexSignatureRejected {
+  readonly [VOCABULARY_INDEX_SIGNATURE]: 'vocabulary registration requires literal keys — an index-signature map cannot prove its names';
+}
+type LiteralKeyMap<M> = string extends keyof M ? VocabularyIndexSignatureRejected : unknown;
+declare const VOCABULARY_BRAND: unique symbol;
+/**
+ * What `seal()` returns. The registered names ride as phantom type state so
+ * `.extend()` can make a collision a compile error in a consumer's chain.
+ * They ride in a one-element tuple: inferring from a bare optional `never`
+ * yields `string`, which made an empty system's vocabulary every name.
+ */
+type SealedSystemInstance<PropReg extends Record<string, SystemProp>, GroupReg extends Record<string, (keyof PropReg)[]>, Conds extends string = never, Sels extends string = never, Vocab extends string = never> = SystemInstance<PropReg, GroupReg, Conds, Sels, Vocab> & {
+  getVocabularyRecord(): VocabularyRecord;
+  readonly [VOCABULARY_BRAND]?: [Vocab];
+};
+type VocabularyOf<S> = S extends {
+  readonly [VOCABULARY_BRAND]?: [infer V];
+} ? Extract<V, string> : never;
+/**
+ * The `build()` return. Registration is linear — chain the returned bundle;
+ * one `seal()` per bundle, and later registering or re-sealing throws.
+ */
+interface SystemBundle<PropReg extends Record<string, SystemProp>, GroupReg extends Record<string, (keyof PropReg)[]>, Conds extends string = never, Sels extends string = never, Vocab extends string = never> {
+  system: SystemInstance<PropReg, GroupReg, Conds, Sels, never>;
+  createGlobalStyles: GlobalStylesFactory<PropReg>;
+  createKeyframes: CreateKeyframesFactory<PropReg>;
+  /**
+   * The registration key must equal the collection's module-scope export
+   * name — references resolve by export name. Registration is linear.
+   */
+  registerKeyframes<M extends Record<string, RegisterableKeyframes>>(map: M & LiteralKeyMap<M> & { [K in Extract<keyof M, Vocab>]: VocabularyNameCollision<K & string>; }): SystemBundle<PropReg, GroupReg, Conds, Sels, Vocab | (keyof M & string)>;
+  /**
+   * Keys equal the block's module-scope export name. Blocks and keyframes
+   * collections share ONE vocabulary name-space. Blocks marked `unlayered`
+   * emit after `@layer anm-global`, outside every layer, in registration
+   * order.
+   */
+  registerGlobalStyles<M extends Record<string, RegisterableGlobalStyles>>(map: M & LiteralKeyMap<M> & { [K in Extract<keyof M, Vocab>]: VocabularyNameCollision<K & string>; }): SystemBundle<PropReg, GroupReg, Conds, Sels, Vocab | (keyof M & string)>;
+  seal(): SealedSystemInstance<PropReg, GroupReg, Conds, Sels, Vocab>;
+}
+/**
+ * One export for both builders: `createSystem().extend()` takes the system
+ * half, `createTheme().extend()` the theme half (`tokens` is accepted too).
+ */
+interface LibraryBundle<Vocab extends string = never> {
+  system: IncludableSystem;
+  theme?: unknown;
+  tokens?: unknown;
+  /** Phantom vocabulary axis — never present at runtime. */
+  readonly __vocabulary?: Vocab;
+}
+declare const EXTEND_SOURCE_BRAND: unique symbol;
+/**
+ * Present only on systems Animus built. A private member is dropped from an
+ * object spread's type, so a hand-assembled object cannot carry it.
+ */
+declare class SourceOrigin {
+  private readonly __animusSourceOrigin;
+}
+/**
+ * What typed `extend()` reads from its source: the registry axes as one
+ * record, plus the methods the runtime merge calls. Comparing a whole
+ * `SystemInstance` instead expands every component type it can author, so
+ * extending a kit cost millions of instantiations; this record keeps the cost
+ * near the kit's own. The private origin keeps a forged record, whose
+ * snapshot carries none of the registries it claims, out.
+ */
+interface ExtendSource<PropReg extends Record<string, SystemProp>, GroupReg extends Record<string, (keyof PropReg)[]>, Conds extends string = never, Sels extends string = never, Vocab extends string = never> extends SourceOrigin, RegistryBrand<Conds, Sels> {
+  readonly [EXTEND_SOURCE_BRAND]: {
+    readonly props: PropReg;
+    readonly groups: GroupReg;
+    readonly conditions: Conds;
+    readonly selectors: Sels;
+    readonly vocabulary: Vocab;
+  };
+  toConfig(): SerializedConfig;
+  getRegistrySnapshot?(): RegistrySnapshot;
+  getVocabularyRecord?(): VocabularyRecord;
+  readonly [VOCABULARY_BRAND]?: [Vocab];
+}
+interface CreateSystemConfig {
+  /**
+   * @deprecated Use `createSystem().extend(source)`, which merges the
+   * source's registries. `includes` adds discovery membership only.
+   */
+  includes?: readonly IncludableSystem[];
+}
+declare const STAGE_BRAND: unique symbol;
+/**
+ * Phantom type-state: `extend()` / `from()` are callable only in
+ * `'inherit'`, and every `add*` call advances the builder to `'extend'`.
+ */
+type SystemBuilderStage = 'inherit' | 'extend';
+declare class SystemBuilder<PropReg extends Record<string, SystemProp> = {}, GroupReg extends Record<string, (keyof PropReg)[]> = {}, Conds extends string = never, Sels extends string = never, Stage extends SystemBuilderStage = 'inherit', Vocab extends string = never> {
+  #private;
+  readonly [STAGE_BRAND]?: Stage;
+  constructor(propRegistry?: PropReg, groupRegistry?: GroupReg, selectorRegistry?: SelectorAliasMap, includesRegistry?: readonly IncludableSystem[], conditionRegistry?: ConditionAliasMap, extendProvenance?: ReadonlyMap<string, number>, extendCount?: number, vocabularyRegistry?: readonly VocabularyEntryState[], vocabularyCollisions?: readonly VocabularyCollisionEntry[], legacyVerbWitnesses?: readonly VocabularyLegacyVerbEntry[]);
+  /**
+   * @deprecated Use `extend(source)`, which merges the source's registries.
+   * `from()` admits types and discovery membership only — no merge.
+   */
+  from<SrcProps extends Record<string, SystemProp>, SrcGroups extends Record<string, (keyof SrcProps)[]>, SrcConds extends string = never, SrcSels extends string = never>(this: SystemBuilder<PropReg, GroupReg, Conds, Sels, 'inherit', Vocab>, source: SystemInstance<SrcProps, SrcGroups, SrcConds, SrcSels, string> | {
+    system: SystemInstance<SrcProps, SrcGroups, SrcConds, SrcSels, string>;
+    theme?: unknown;
+    tokens?: unknown;
+  }): SystemBuilder<PropReg & SrcProps, GroupReg & SrcGroups, Conds | SrcConds, Sels | SrcSels, 'inherit', Vocab>;
+  /**
+   * @deprecated Use `extend(source)`. A `LibraryBundle` annotation has
+   * already erased the system half's generics — no type surface to admit.
+   */
+  from(this: SystemBuilder<PropReg, GroupReg, Conds, Sels, 'inherit', Vocab>, source: LibraryBundle<string>): SystemBuilder<PropReg, GroupReg, Conds, Sels, 'inherit', Vocab>;
+  /**
+   * Merges the source's prop, group, selector, and condition registries;
+   * identical entries coalesce, divergent ones throw naming both origins.
+   */
+  extend<SrcProps extends Record<string, SystemProp>, SrcGroups extends Record<string, (keyof SrcProps)[]>, SrcConds extends string = never, SrcSels extends string = never, SrcVocab extends string = never>(this: SystemBuilder<PropReg, GroupReg, Conds, Sels, 'inherit', Vocab>, source: ExtendSource<SrcProps, SrcGroups, SrcConds, SrcSels, SrcVocab> | {
+    system: ExtendSource<SrcProps, SrcGroups, SrcConds, SrcSels, SrcVocab>;
+    theme?: unknown;
+    tokens?: unknown;
+  }): SystemBuilder<PropReg & SrcProps, GroupReg & SrcGroups, Conds | SrcConds, Sels | SrcSels, 'inherit', Vocab | (string extends SrcVocab ? never : SrcVocab)>;
+  /**
+   * A `LibraryBundle` annotation has erased the system half's generics: the
+   * runtime merge is identical, but no source types are admitted.
+   */
+  extend<SrcVocab extends string = never>(this: SystemBuilder<PropReg, GroupReg, Conds, Sels, 'inherit', Vocab>, source: LibraryBundle<SrcVocab>): SystemBuilder<PropReg, GroupReg, Conds, Sels, 'inherit', Vocab | SrcVocab>;
+  /**
+   * Registers `_` aliases → `&`-relative selectors. The cross-registry clash
+   * is checked in VALUE position: `Exclude` on a `_${string}` key is a no-op.
+   */
+  addSelectors<S extends Record<`_${string}`, string>>(selectors: S & { [K in keyof S]: K extends BuiltInConditionAlias | NarrowedAliases<Conds> ? ReservedByConditionRegistry<K & string> : S[K]; }): SystemBuilder<PropReg, GroupReg, Conds, Sels | NarrowedAliases<Extract<keyof S, string>>, 'extend', Vocab>;
+  /**
+   * Registers `_` aliases → at-rule strings; user aliases override built-ins
+   * of the same name. A selector-owned key maps to the branded rejection.
+   */
+  addConditions<C extends Record<`_${string}`, AtRuleValue>>(conditions: C & { [K in keyof C]: K extends BuiltInSelectorAlias | NarrowedAliases<Sels> ? ReservedBySelectorRegistry<K & string> : C[K]; }): SystemBuilder<PropReg, GroupReg, Conds | NarrowedAliases<Extract<keyof C, string>>, Sels, 'extend', Vocab>;
+  addGroup<Name extends string, Conf extends Record<string, SystemProp>>(name: Name extends keyof PropReg ? never : Name, authored: Conf): SystemBuilder<PropReg & Conf, GroupReg & Record<Name, (keyof Conf)[]>, Conds, Sels, 'extend', Vocab>;
+  addProps<Conf extends Record<string, SystemProp> & Partial<Record<Extract<keyof GroupReg, string>, never>>>(authored: Conf): SystemBuilder<PropReg & Conf, GroupReg, Conds, Sels, 'extend', Vocab>;
+  build(): SystemBundle<PropReg, GroupReg, Conds, Sels, Vocab>;
+}
+type SystemInstance<PropReg extends Record<string, SystemProp>, GroupReg extends Record<string, (keyof PropReg)[]>, Conds extends string = never, Sels extends string = never, Vocab extends string = string> = Animus<PropReg, GroupReg> & {
+  toConfig(): SerializedConfig;
+  /**
+   * Frozen registry state captured at `build()` — what `extend()` merges
+   * from. Optional only for systems built by an older @animus-ui/system.
+   */
+  getRegistrySnapshot?(): RegistrySnapshot;
+} & RegistryBrand<Conds, Sels> & ExtendSource<PropReg, GroupReg, Conds, Sels, Vocab>;
+interface SerializedConfig {
+  propConfig: string;
+  groupRegistry: string;
+  /** Bound callables by definition id. */
+  transforms: Record<string, NamedTransform>;
+  /**
+   * `{ definitionId: sourceText }` — the only channel by which transforms
+   * shipped inside a package reach the build-time evaluator.
+   */
+  transformSources: string;
+  selectorAliases: string;
+  /** Condition alias map JSON: `alias → { value, order, kind }`. */
+  conditionAliases: string;
+}
+declare function createSystem(config?: CreateSystemConfig): SystemBuilder;
+//#endregion
+//#region src/scales/createScale.d.ts
+declare const createScale: <T extends string | number>() => readonly T[] & {
+  length: 0;
+};
+declare const numericScale: (number & {})[];
+declare const stringScale: (string & {})[];
+declare const numericOrStringScale: ((string & {}) | (number & {}))[];
+//#endregion
+//#region src/declarations.d.ts
+/** One key's declarations: canonical member name → CSS value. */
+interface DeclarationRecord {
+  [member: string]: string | number;
+}
+/** Scale key → that key's complete record. */
+interface DeclarationScaleValues {
+  [key: string]: DeclarationRecord;
+}
+//#endregion
+//#region src/theme/property-records.d.ts
+/** Where a record was first declared. Kept for diagnostics; not serialized,
+ *  so an unchanged extension serializes exactly like its source. */
+type PropertySource = {
+  method: 'declareContextualVars';
+} | {
+  method: 'extend';
+  call: number;
+} | {
+  method: 'from';
+};
+/** One declared custom property: the record every declaration API writes. */
+interface PropertyRecord {
+  /** The authored name, without `--`. */
+  name: string;
+  /** Normalized: the home's default applies when nothing says otherwise. */
+  inherits: boolean;
+  syntax?: string;
+  initialValue?: string;
+  home: 'theme';
+  source: PropertySource;
+  /** Present on records the contextual-variable method made. */
+  legacy?: {
+    /** The authored registration, projected verbatim into the manifest. */
+    registration?: ContextualVarRegistration;
+  };
+}
+interface PropertyStore {
+  /**
+   * By authored name. A record moves to the end when it first gains a
+   * registration, so registered records keep registration order, which is
+   * the order their `@property` rules are emitted in.
+   */
+  records: Map<string, PropertyRecord>;
+  /**
+   * Names declared on each scale, in declaration order with repeats: the
+   * names-by-scale input extraction already reads. Each record's scales are
+   * read from here.
+   */
+  scaleNames: Map<string, string[]>;
+}
+//#endregion
+//#region src/theme/createTheme.d.ts
+/** Identity mapping that caches the type, preventing TS2589 depth growth. */
+type Flatten<T> = { [K in keyof T]: T[K]; };
+type MergeRecord<Base, Incoming> = Omit<Base, keyof Incoming> & Incoming;
+/**
+ * Var NAMES across all scales. Derives from the already-inferred `Vars`, so it
+ * never feeds back into inference or perturbs literal-key narrowing.
+ */
+type ContextualVarNames<Vars> = { [K in keyof Vars]: Vars[K] extends readonly (infer N extends string)[] ? N : never; }[keyof Vars];
+type ThemeScaleKeys<T> = Exclude<keyof T & string, ThemeStructuralKey>;
+/** Theme data plus boundary members, non-enumerable at runtime. */
+type BuiltTheme<T, Emitted extends string> = { [K in keyof T]: T[K]; } & {
+  /** Tuple wrapper prevents never-distribution. Non-enumerable at runtime. */
+  readonly __emitted: [Emitted];
+  manifest: ThemeManifest;
+  serialize(): SerializedTheme;
+  /** Dot-path token → `var()` ref, or the raw value if not emitted. */
+  varRef(tokenPath: string): string | undefined;
+};
+/**
+ * Manifest fields carried through the explicit manifest read — the manifest is
+ * non-enumerable. Read-only: `build()` regenerates every fragment.
+ */
+interface CarriedManifestV2 {
+  tokenDefinitions?: Record<string, TokenDefinition>;
+  emittedScales?: string[];
+  modeAliasDefinitions?: ModeAliasDefinition;
+  registrations?: Record<string, ContextualVarRegistration>;
+  emitterVersion?: number;
+  contractHash?: string;
+  cssFragments?: ThemeCssFragment[];
+}
+interface BuilderState {
+  theme: Record<string, unknown>;
+  emittedScales: Set<string>;
+  /** One record per declared custom property, contextual variables included. */
+  properties: PropertyStore;
+  carriedManifestV2?: CarriedManifestV2;
+  /**
+   * A source manifest without the v2 discriminant: the authored graph is
+   * unknowable, so `build()` suppresses all v2 fields instead of fabricating.
+   */
+  hasLegacyManifestSource: boolean;
+  /**
+   * Flattened leaf path → 1-based index of the `extend()` call that first
+   * defined it; sibling conflicts name both sources by that index.
+   */
+  extendProvenance: Map<string, number>;
+  extendCount: number;
+  /**
+   * Mode names carried in by `extend()`. Exempt from the coverage gate — a
+   * kit's own alias asymmetry must round-trip unchanged.
+   */
+  inheritedModes: Set<string>;
+  /**
+   * Alias dot-paths from extended sources: a consumer-declared mode must cover
+   * them or name a base.
+   */
+  inheritedModeAliases: Set<string>;
+  /**
+   * Token path dropped by `addScale({ replace: true })` → the replaced scale.
+   * A reference to one that is never re-added fails `build()`.
+   */
+  droppedTokenPaths: Map<string, string>;
+  /**
+   * Declaration scales by name, kept out of `theme` so the scalar flatten
+   * never sees their records. Records are replaced whole, never merged.
+   */
+  declarationScales: Record<string, DeclarationScaleValues>;
+  /** `scale.key` → the 1-based `extend()` call that first defined it. */
+  declarationProvenance: Map<string, number>;
+}
+type DeclarationScalesOfTheme<T> = T extends {
+  __declarationScales: infer Scales;
+} ? Scales : {};
+/** Per-scale key union; `Over` records win, as runtime composition does. */
+type MergeDeclarationScales<Base, Over> = Flatten<{ [Scale in keyof Base | keyof Over]: Scale extends keyof Over ? Scale extends keyof Base ? Flatten<MergeRecord<Base[Scale], Over[Scale]>> : Over[Scale] : Scale extends keyof Base ? Base[Scale] : never; }>;
+/** A theme without declaration scales keeps its type unchanged. */
+type WithDeclarationScales<Merged, Scales> = [keyof Scales] extends [never] ? Merged : Flatten<Omit<Merged, '__declarationScales'> & Record<'__declarationScales', Scales>>;
+type ThemeSourceOf<Source> = Source extends {
+  system: {
+    toConfig(...args: never[]): unknown;
+  };
+  theme?: infer ThemeHalf;
+  tokens?: infer TokensHalf;
+} ? ThemeHalf extends Record<string, unknown> ? ThemeHalf : TokensHalf extends Record<string, unknown> ? TokensHalf : Record<never, never> : Source;
+type ThemeBoundaryKey = '__emitted' | 'manifest' | 'serialize' | 'varRef';
+type ThemeDataOf<Source> = { [Key in keyof Source as Key extends ThemeBoundaryKey ? never : Extract<Source[Key], (...args: never[]) => unknown> extends never ? Key : never]: Source[Key]; };
+type MergeThemeData<Base, Source> = Flatten<MergeRecord<Base, ThemeDataOf<Source>>>;
+type EmittedThemeScalesOf<Source> = Source extends {
+  readonly __emitted: [infer Emitted extends string];
+} ? Emitted : never;
+type ExtendedThemeSourceOf<Source> = Source extends {
+  system: {
+    toConfig(...args: never[]): unknown;
+  };
+  theme?: infer ThemeHalf;
+  tokens?: infer TokensHalf;
+} ? ThemeHalf extends Record<string, unknown> ? ThemeHalf : TokensHalf extends Record<string, unknown> ? TokensHalf : Record<never, never> : Source;
+declare const THEME_STAGE_BRAND: unique symbol;
+/**
+ * Phantom builder stage: `extend()` is callable only while `'inherit'`, and
+ * every augmentation method advances to `'extend'`. `from()` is not gated.
+ */
+type ThemeBuilderStage = 'inherit' | 'extend';
+declare class ThemeBuilder<T extends Record<string, unknown> = Record<string, unknown>, Emitted extends string = never, Stage extends ThemeBuilderStage = 'inherit'> {
+  readonly [THEME_STAGE_BRAND]?: Stage;
+  /** @internal */ _state: BuilderState;
+  constructor(state: BuilderState);
+  addBreakpoints<BP extends Record<string, number>>(breakpoints: BP): ThemeBuilder<{ [K in keyof (Omit<T, "breakpoints"> & Record<"breakpoints", { [K in keyof BP]: BP[K]; }>)]: (Omit<T, "breakpoints"> & Record<"breakpoints", { [K in keyof BP]: BP[K]; }>)[K]; }, Emitted, "extend">;
+  /**
+   * Source-WINS precedence over prior builder state, callable at any stage.
+   * @deprecated Use `extend(source)` — the source seeds the base, local wins.
+   */
+  from<Source extends object>(builtTheme: Source): ThemeBuilder<WithDeclarationScales<Flatten<MergeRecord<T, ThemeDataOf<ThemeSourceOf<Source>>>>, Flatten<{ [Scale in keyof DeclarationScalesOfTheme<T> | keyof DeclarationScalesOfTheme<ThemeSourceOf<Source>>]: Scale extends keyof DeclarationScalesOfTheme<ThemeSourceOf<Source>> ? Scale extends keyof DeclarationScalesOfTheme<T> ? Flatten<MergeRecord<DeclarationScalesOfTheme<T>[Scale], DeclarationScalesOfTheme<ThemeSourceOf<Source>>[Scale]>> : DeclarationScalesOfTheme<ThemeSourceOf<Source>>[Scale] : Scale extends keyof DeclarationScalesOfTheme<T> ? DeclarationScalesOfTheme<T>[Scale] : never; }>>, Emitted | EmittedThemeScalesOf<ThemeSourceOf<Source>>, Stage>;
+  /**
+   * Inherits a built theme or library bundle as the BASE; local calls after
+   * `extend()` win, and leaves that two sources define divergently throw.
+   */
+  extend<Source extends object>(this: ThemeBuilder<T, Emitted, 'inherit'>, source: Source): ThemeBuilder<WithDeclarationScales<MergeThemeData<T, ExtendedThemeSourceOf<Source>>, MergeDeclarationScales<DeclarationScalesOfTheme<ExtendedThemeSourceOf<Source>>, DeclarationScalesOfTheme<T>>>, Emitted | EmittedThemeScalesOf<ExtendedThemeSourceOf<Source>>, 'inherit'>;
+  addColors<Colors extends Record<string, CSSColorValue | Record<string, CSSColorValue>>, NextColors extends LiteralPaths<Colors, '.'> = LiteralPaths<Colors, '.'>>(colors: Colors): ThemeBuilder<Flatten<Omit<T, "colors"> & Record<"colors", Flatten<MergeRecord<T extends {
+    colors: infer Existing;
+  } ? Existing : {}, NextColors>>>>, "colors" | Emitted, "extend">;
+  addColorModes<Config extends Record<string, Record<string, unknown>>, AliasKeys extends LiteralPaths<Config[keyof Config], '.', '_'> = LiteralPaths<Config[keyof Config], '.', '_'>>(initialMode: string, modeConfig: Config, options?: ColorModeOptions<Config>): ThemeBuilder<{ [K in keyof (Omit<T, "colors"> & Record<"colors", (T extends {
+    colors: infer C;
+  } ? C : unknown) & AliasKeys>)]: (Omit<T, "colors"> & Record<"colors", (T extends {
+    colors: infer C;
+  } ? C : unknown) & AliasKeys>)[K]; }, Emitted, "extend">;
+  addScale<Key extends string, Values extends Record<string | number, string | number | Record<string, string | number>>, Emit extends boolean = false, Replace extends boolean = false, NewScale extends LiteralPaths<Values, '.'> = LiteralPaths<Values, '.'>>(config: {
+    name: Key & (Key extends ThemeStructuralKey ? never : unknown);
+    values: Values;
+    emit?: Emit;
+    replace?: Replace;
+  }): ThemeBuilder<Flatten<Omit<T, Key> & Record<Key, Replace extends true ? NewScale : Flatten<MergeRecord<Key extends keyof T ? T[Key] : {}, NewScale>>>>, Emit extends true ? Emitted | Key : Emitted, "extend">;
+  /**
+   * Registers a finite declaration scale: each key maps to a flat record of
+   * CSS declarations, and every record sets the same members. Bind it with a
+   * `{ kind: 'declarations', scale, members }` system or component prop. Keys merge by
+   * record; `replace` makes the scale exactly these keys.
+   */
+  addDeclarationScale<Key extends string, Values extends Record<string | number, Record<string, string | number>>, Replace extends boolean = false>(config: {
+    name: Key & (Key extends ThemeStructuralKey ? never : unknown);
+    values: Values;
+    replace?: Replace;
+  }): ThemeBuilder<Flatten<Omit<T, "__declarationScales"> & Record<"__declarationScales", Flatten<Omit<DeclarationScalesOfTheme<T>, Key> & Record<Key, Replace extends true ? { [K in keyof Values]: Values[K]; } : Flatten<MergeRecord<Key extends keyof DeclarationScalesOfTheme<T> ? DeclarationScalesOfTheme<T>[Key] : {}, Values>>>>>>, Emitted, "extend">;
+  declareContextualVars<const Vars extends Partial<{ [K in ThemeScaleKeys<T>]: readonly string[]; }>>(vars: Vars & Record<Exclude<keyof Vars, ThemeScaleKeys<T>>, never>, registrations?: Partial<Record<ContextualVarNames<Vars>, ContextualVarRegistration>>): ThemeBuilder<{ [K in keyof T]: K extends keyof Vars ? Vars[K] extends readonly string[] ? T[K] & Record<Vars[K][number], `var(--${string})`> : T[K] : T[K]; }, Emitted, "extend">;
+  extendScale<Key extends Exclude<keyof T, ThemeStructuralKey>, Fn extends (tokens: T[Key]) => Record<string | number, unknown>>(key: Key, updateFn: Fn): ThemeBuilder<Flatten<Omit<T, Key> & Record<Key, Flatten<MergeRecord<T[Key], ReturnType<Fn>>>>>, Emitted, "extend">;
+  build(): BuiltTheme<T, Emitted>;
+}
+type EmptyTheme = {
+  breakpoints: Record<string, number>;
+};
+declare function createTheme(): ThemeBuilder<EmptyTheme, never, "inherit">;
+//#endregion
+//#region src/theme/serializeTokens.d.ts
+type KeyAsVariable<T extends Record<string, any>, Prefix extends string> = { [V in keyof T]: `var(--${Prefix}-${SanitizeKey<Extract<V, string>>})`; };
+type SanitizeKey<T extends string> = T extends `${'$'}${infer Y}` ? Y : T;
+//#endregion
+//#region src/theme/types.d.ts
+type MergeTheme<Base extends AbstractTheme, Next, Unmergable = Record<'breakpoints', Base['breakpoints']>> = Unmergable & Merge<Base, Next>;
+type Merge<A, B> = { [K in keyof (A & B)]: K extends keyof B ? K extends keyof A ? AssignValueIfUnmergable<A[K], B[K]> : B[K] : K extends keyof A ? A[K] : never; };
+type Mergable<T> = Exclude<T, ((...args: any) => any) | string | boolean | symbol | number | any[]>;
+type AssignValueIfUnmergable<A, B> = Mergable<A> extends never ? B : Mergable<B> extends never ? B : Assign<A, B>;
+type Assign<A, B> = { [K in keyof A | keyof B]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never; };
+type PrivateThemeKeys = {
+  _variables: Record<string, CSSObject>;
+  _tokens: Record<string | number, any>;
+};
+/**
+ * Nesting flattens to dash-joined keys: `{ button: { bg: { hover } } }`
+ * becomes `button-bg-hover`.
+ */
+type ColorModeConfig<Colors> = Record<string, Colors | Record<string, Colors> | Record<string, Colors | Record<string, Colors>>>;
+//#endregion
+//#region src/transforms/border.d.ts
+/** All logic stays inline: the extractor cannot follow external references. */
+declare const borderShorthand: NamedTransform;
+//#endregion
+//#region src/transforms/grid.d.ts
+/** All logic stays inline: the extractor cannot follow external references. */
+declare const gridItem: NamedTransform;
+/** Template logic is duplicated rather than shared: no external references. */
+declare const gridItemRatio: NamedTransform;
+//#endregion
+//#region src/transforms/size.d.ts
+/** The transform below cannot reference this: it inlines its own copy. */
+declare const percentageOrAbsolute: (coordinate: number) => string | 0;
+/** All logic stays inline: the extractor cannot follow external references. */
+declare const size: NamedTransform;
+//#endregion
+export { AssetRef as $, LibraryBundle as A, VocabularyCollisionEntry as B, CreateKeyframesFactory as C, GlobalStyleMap as D, GlobalStyleBlock as E, SerializedConfig as F, VocabularyOf as G, VocabularyKeyframesEntry as H, SystemBuilder as I, NamedTransform as J, VocabularyRecord as K, SystemBuilderStage as L, RegisterableKeyframes as M, RegistrySnapshot as N, GlobalStylesFactory as O, SealedSystemInstance as P, ASSET_PLACEHOLDER_PREFIX as Q, SystemBundle as R, stringScale as S, FontFaceSrc as T, VocabularyLegacyVerbEntry as U, VocabularyGlobalStyleEntry as V, VocabularyNameCollision as W, areTransformsEqual as X, TransformFn as Y, createTransform as Z, ThemeBuilderStage as _, borderShorthand as a, numericOrStringScale as b, ColorModeConfig as c, MergeTheme as d, asset as et, PrivateThemeKeys as f, ThemeBuilder as g, Flatten as h, gridItemRatio as i, RegisterableGlobalStyles as j, KeyframesFrameData as k, Mergable as l, SanitizeKey as m, size as n, AnimusWithAll as nt, Assign as o, KeyAsVariable as p, createSystem as q, gridItem as r, AssignValueIfUnmergable as s, percentageOrAbsolute as t, Animus as tt, Merge as u, createTheme as v, FontFace as w, numericScale as x, createScale as y, SystemInstance as z };
+//# sourceMappingURL=index-C1AAiaiJ.d.ts.map