@mildastudio/milda 0.1.0 → 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,1485 @@
+type Id = string;
+interface TypeRef {
+  kind: 'ref';
+  ref: Id;
+}
+type TypeExpr = {
+  kind: 'string';
+} | {
+  kind: 'number';
+  min?: number;
+  max?: number;
+} | {
+  kind: 'boolean';
+} | {
+  kind: 'enum';
+  values: string[];
+} | {
+  kind: 'context';
+  group: Id;
+} | {
+  kind: 'union';
+  members: TypeExpr[];
+} | TypeRef | {
+  kind: 'array';
+  item: TypeExpr;
+} | {
+  kind: 'object';
+  fields: ObjectField[];
+} | {
+  kind: 'component';
+  componentIds?: Id[];
+};
+interface ObjectField {
+  id: Id;
+  name: string;
+  type: TypeExpr;
+  required: boolean;
+  description?: string;
+}
+type PropValue = string | number | boolean | PropValue[] | {
+  [key: string]: PropValue;
+};
+type Metadata = Record<string, PropValue>;
+interface SharedType {
+  id: Id;
+  name: string;
+  description?: string;
+  definition: TypeExpr;
+}
+type ParamBinding = {
+  prop: Id;
+} | {
+  static: PropValue;
+};
+interface DocumentMeta {
+  id: Id;
+  name: string;
+  version: string;
+  description?: string;
+  createdAt?: string;
+  updatedAt?: string;
+}
+type DocumentKind = 'prelude' | 'design-system';
+interface MildaDocumentBase {
+  milda: string;
+  kind: DocumentKind;
+  prelude: string;
+  meta: DocumentMeta;
+}
+interface TokenRef {
+  ref: Id;
+}
+type PrimitiveTokenType = 'color' | 'spacing' | 'radius' | 'size' | 'shadow' | 'typography' | 'fontFamily' | 'fontWeight' | 'duration' | 'opacity' | 'blur' | 'tonal' | 'border' | 'lineHeight' | 'easing' | 'gradient' | 'fontSize' | 'letterSpacing';
+type FacetTokenType = 'elevation' | 'ring' | 'backdrop' | 'none';
+type TokenType = PrimitiveTokenType | FacetTokenType;
+type ColorSpace = 'srgb' | 'display-p3' | 'oklch' | 'hsl';
+interface ColorValue {
+  space: ColorSpace;
+  channels: number[];
+  alpha?: number;
+}
+/**
+ * The neutral length units (0038). `fixed` is a density-independent length (CSS px,
+ * Android dp, iOS pt, Figma px); `scaled` is a multiple of the user's text size (CSS
+ * rem, Android sp, iOS Dynamic Type). The surface spells them `12px` and `scaled(12)`;
+ * `dp`/`sp`/`rem` are read as synonyms but never emitted.
+ */
+type DimensionUnit = 'scaled' | 'fixed' | 'percent' | 'em';
+interface DimensionValue {
+  value: number;
+  unit: DimensionUnit;
+}
+/**
+ * A length that is an INTENT rather than a measurement (0038). `pill` is "fully
+ * rounded": on the web it lowers to a large px radius, on iOS to a capsule, on Android
+ * to a circle shape, in Figma to a clamped corner radius. Spelling it as a keyword is
+ * what lets each target lower it correctly instead of pattern-matching `9999px`.
+ */
+type LengthKeyword = 'pill';
+interface LengthKeywordValue {
+  keyword: LengthKeyword;
+}
+type LengthValue = DimensionValue | LengthKeywordValue;
+type ColorOrRef = ColorValue | TokenRef;
+type DimensionOrRef = DimensionValue | TokenRef;
+interface ShadowLayer {
+  offsetX: DimensionValue;
+  offsetY: DimensionValue;
+  blur: DimensionValue;
+  spread: DimensionValue;
+  color: ColorOrRef;
+  inset: boolean;
+}
+interface ShadowValue {
+  layers: ShadowLayer[];
+}
+type FontCategory = 'sans' | 'serif' | 'mono' | 'display';
+/**
+ * Where the face comes from (added 2026-08-06 with the fontFamily token surface).
+ *
+ * Without it a family read back from a file could only ever be "some family called Inter":
+ * whether it is a platform stack, a bundled Google Font (and under which licence), or a file
+ * the project uploaded is exactly what a generator has to know to EMIT it - a @font-face, a
+ * stylesheet link, or nothing at all. Optional, so every existing document stays valid and is
+ * read as a plain named family.
+ */
+type FontProvenance = {
+  kind: 'system';
+} | {
+  kind: 'google';
+  license?: string;
+} | {
+  kind: 'custom';
+};
+interface FontFamilyValue {
+  /** The family name, or - for a system face - the platform stack itself. */
+  family: string;
+  fallback: string[];
+  category: FontCategory;
+  assetId?: Id | null;
+  source?: FontProvenance;
+}
+interface FontWeightValue {
+  weight: number;
+}
+interface TypographyValue {
+  family: TokenRef | FontFamilyValue;
+  size: DimensionValue;
+  weight: number;
+  lineHeight: DimensionValue | {
+    ratio: number;
+  };
+  letterSpacing: DimensionValue;
+  italic?: boolean;
+  uppercase?: boolean;
+}
+interface DurationValue {
+  ms: number;
+}
+interface OpacityValue {
+  value: number;
+}
+interface BlurValue {
+  radius: DimensionValue;
+}
+interface TonalValue {
+  level: number;
+}
+type BorderWidth = 'hairline' | 'thin' | 'thick' | DimensionValue;
+type BorderStyle = 'solid' | 'dashed' | 'dotted' | 'none';
+interface BorderValue {
+  width: BorderWidth;
+  style: BorderStyle;
+  color: ColorOrRef;
+}
+interface NoneValue {
+  none: true;
+}
+interface RatioValue {
+  value: number;
+}
+interface EasingValue {
+  keyword?: string;
+  cubicBezier?: [number, number, number, number];
+  css?: string;
+}
+interface GradientValue {
+  css: string;
+}
+interface TokenValueSchemaByType {
+  color: ColorValue;
+  spacing: DimensionValue;
+  radius: LengthValue;
+  size: DimensionValue;
+  shadow: ShadowValue;
+  typography: TypographyValue;
+  fontFamily: FontFamilyValue;
+  fontWeight: FontWeightValue;
+  duration: DurationValue;
+  opacity: OpacityValue;
+  blur: BlurValue;
+  tonal: TonalValue;
+  border: BorderValue;
+  fontSize: DimensionValue;
+  letterSpacing: DimensionValue;
+  lineHeight: RatioValue;
+  easing: EasingValue;
+  gradient: GradientValue;
+  elevation: NoneValue;
+  ring: NoneValue;
+  backdrop: NoneValue;
+  none: NoneValue;
+}
+type AnyTokenValue = TokenValueSchemaByType[TokenType];
+interface RawTokenValue<T extends TokenType = TokenType> {
+  kind: 'raw';
+  value: TokenValueSchemaByType[T];
+}
+interface AliasTokenValue {
+  kind: 'alias';
+  by: Id;
+  refs: Record<string, Id>;
+}
+interface EscapeTokenValue {
+  kind: 'escape';
+  raw: string;
+  note?: string;
+}
+/**
+ * Which space a computed COLOUR does its maths in.
+ *
+ * Wider than `ColorSpace` on purpose: that type is about how a colour LITERAL is spelled, and
+ * the surface can only spell four. A perceptual space like Oklab is a legitimate place to do
+ * the arithmetic even though no literal is written in it, so narrowing this to ColorSpace
+ * would silently move a token's maths to a different space on the way through the file.
+ */
+type ComputeSpace = 'srgb' | 'display-p3' | 'oklch' | 'hsl' | 'oklab' | 'lab' | 'lch';
+/**
+ * One step of a computed value. Two vocabularies in one union, exactly as the IR has them:
+ * a colour is lightened and mixed, a measurement is scaled and rounded. Which one applies
+ * follows the TOKEN'S TYPE, not a discriminant here.
+ *
+ * Amounts are 0..1 fractions (the surface writes them as percentages), `degrees` is a hue
+ * rotation, and `delta` / `to` are density-independent pixels - the neutral unit, so a step
+ * means the same thing on every platform.
+ */
+type ComputeOp = {
+  op: 'lighten' | 'darken' | 'saturate' | 'desaturate' | 'alpha';
+  amount: number;
+} | {
+  op: 'rotate';
+  degrees: number;
+} | {
+  op: 'mix';
+  with: Id;
+  amount: number;
+} | {
+  op: 'scale';
+  factor: number;
+} | {
+  op: 'offset';
+  delta: number;
+} | {
+  op: 'round';
+  to: number;
+};
+/**
+ * A value DERIVED from another token: "the accent, 20% lighter", "the body size × 1.25".
+ *
+ * `base` and a `mix` operand are token IDS, like an alias's `refs` - and for the same reason:
+ * the canonical AST names tokens, it does not embed anonymous values. An inline literal
+ * written in either position is hoisted to a synthesized token by the parser (and printed
+ * back as the literal by the emitter), which is the mechanism alias slots already use.
+ */
+interface ComputeTokenValue {
+  kind: 'compute';
+  base: Id;
+  ops: ComputeOp[];
+  /** Colour only; absent means the IR's own default (OKLCH). */
+  space?: ComputeSpace;
+}
+type TokenValue<T extends TokenType = TokenType> = RawTokenValue<T> | AliasTokenValue | EscapeTokenValue | ComputeTokenValue;
+interface Token$1<T extends TokenType = TokenType> {
+  id: Id;
+  name: string;
+  type: T;
+  value: TokenValue<T>;
+  description?: string;
+}
+interface Layer {
+  id: Id;
+  name: string;
+  order: number;
+  tokens: Token$1[];
+}
+interface Context {
+  id: Id;
+  name: string;
+}
+interface ContextGroup {
+  id: Id;
+  name: string;
+  contexts: Context[];
+}
+declare const TOKEN_VALUE_KIND: Record<TokenType, 'color' | 'dimension' | 'shadow' | 'typography' | 'fontFamily' | 'fontWeight' | 'duration' | 'opacity' | 'blur' | 'tonal' | 'border' | 'ratio' | 'easing' | 'gradient' | 'facet'>;
+/** What a part IS. Neutral by design - the platform element is a target decision. */
+declare const NODE_KINDS: readonly string[];
+/** Where a part came from: the archetype, or the author. */
+declare const NODE_ORIGINS: readonly string[];
+/** The interactions an emission (or a demo action) can fire on. */
+declare const INTERACTION_KINDS: readonly string[];
+/** Control realization (0016) and group realization (0022). */
+declare const CONTROL_REALIZATIONS: readonly string[];
+declare const GROUP_REALIZATIONS: readonly string[];
+/** Presentation intent (0022 §8), surface-spelled. */
+declare const PRESENTATION_KINDS: readonly string[];
+/** A media part's type (0028). */
+declare const MEDIA_TYPES: readonly string[];
+/** A table cell's role. */
+declare const CELL_MODIFIERS: readonly string[];
+/** The modifiers a `slot` statement accepts after its arity and content spec. */
+declare const SLOT_MODIFIERS: readonly string[];
+/** The structural roles a slot can play in a disclosure. */
+declare const SLOT_ROLES: readonly string[];
+/** How a behaviour/config field's value is read. `node`/`nodes` name a part BY PATH. */
+type FieldType = 'string' | 'number' | 'boolean' | 'node' | 'nodes';
+declare const BEHAVIOR_FIELDS: Readonly<Record<string, Readonly<Record<string, FieldType>>>>;
+/** The behaviour kinds, in the surface's kebab spelling (`focus-trap`). */
+declare const BEHAVIOR_KINDS: readonly string[];
+type ConfigFieldSpec = {
+  kind: 'boolean';
+} | {
+  kind: 'number';
+} | {
+  kind: 'numbers';
+} | {
+  kind: 'enum';
+  values: readonly string[];
+} | {
+  kind: 'enums';
+  values: readonly string[];
+};
+interface ConfigSurface {
+  /** The node field this block configures. */
+  field: string;
+  fields: Readonly<Record<string, ConfigFieldSpec>>;
+  /** True for a single-valued surface written `severity danger` rather than as a block. */
+  single?: boolean;
+}
+declare const PART_CONFIGS: Readonly<Record<string, ConfigSurface>>;
+/** The block-shaped config surfaces - read as a config only when a `{` follows the word,
+ *  which is what keeps `overlay { … }` apart from the `overlay` paint facet. */
+declare const PART_CONFIG_NAMES: ReadonlySet<string>;
+/** The single-valued config surfaces (`severity danger`). */
+declare const PART_CONFIG_WORDS: readonly string[];
+/** The prose blocks, whose keyword IS their kind. */
+declare const DOC_PROSE_KINDS: readonly string[];
+/** The transclusion blocks - each names what it shows, by name. */
+declare const DOC_TRANSCLUSIONS: readonly string[];
+declare const DOC_BLOCK_KEYWORDS: readonly string[];
+/** Statement keywords inside `docs { … }` and inside a `page { … }`'s header. */
+declare const DOCS_KEYWORDS: readonly string[];
+declare const DOCS_SITE_KEYS: readonly string[];
+declare const DOCS_FOOTER_KEYWORDS: readonly string[];
+declare const ASSET_KINDS: readonly string[];
+/** The fields every asset carries, whatever its kind. `url`/`data` are the two shapes the
+ *  bytes can take: beside the file, or in it. */
+declare const ASSET_BASE_KEYS: readonly string[];
+/** Per-kind metadata, validated on lowering. */
+declare const ASSET_FIELDS: Readonly<Record<string, Readonly<Record<string, FieldType | 'strings'>>>>;
+/** The value each asset kind's fields take, in the surface's kebab spelling. */
+declare const ASSET_FIELD_KEYS: Readonly<Record<string, readonly string[]>>;
+interface LiteralChannel {
+  /** The channel's name, as the docs and the argument hint call it. */
+  name: string;
+  /** What it accepts, in one phrase. */
+  hint: string;
+  /** An in-range value, for a pre-filled call. */
+  sample: string;
+}
+interface LiteralFnSpec {
+  channels: readonly LiteralChannel[];
+  /** Whether a trailing alpha is accepted (`… / 50%`, or a bare fourth channel). */
+  alpha: boolean;
+  /** One line on what the function is. */
+  doc: string;
+}
+declare const VALUE_LITERAL_FNS: Readonly<Record<string, LiteralFnSpec>>;
+/** The colour-space literals, in the order a picker should offer them. */
+declare const COLOR_LITERAL_FNS: readonly string[];
+/**
+ * Spellings a reader accepts for a function it already has. In CSS Color 4 `rgba`/`hsla` ARE
+ * `rgb`/`hsl` - the alpha is a fourth channel either way - and someone coming from CSS writes
+ * the four-letter name without thinking about it. Read, never offered, never written: the
+ * canonical name is the target. (The same treatment `rem`/`dp`/`sp` get on the length side.)
+ */
+declare const COLOR_LITERAL_ALIASES: Readonly<Record<string, string>>;
+/** Every spelling of a colour function the reader accepts - the canonical ones and the aliases.
+ *  What a highlighter needs: `rgba(1 0 0 / 0.5)` is a colour literal, so its payload is a value
+ *  and not four identifiers. */
+declare const COLOR_LITERAL_SPELLINGS: readonly string[];
+/** Colour words that name a value rather than a token. `transparent` is the absence of a colour,
+ *  which every platform has a spelling for; the Studio seeds one (a tab's resting border). */
+declare const COLOR_KEYWORDS: readonly string[];
+/** The length-valued literals (0038). */
+declare const LENGTH_LITERAL_FNS: readonly string[];
+/** What a stack's children flow along. `layers` draws them on top of each other. */
+declare const LAYOUT_DIRECTIONS: readonly ['row', 'column', 'layers'];
+type LayoutDirection = (typeof LAYOUT_DIRECTIONS)[number];
+/** Cross-axis placement (vertical in a `layers` stack). */
+declare const LAYOUT_ALIGNS: readonly ['start', 'center', 'end', 'stretch', 'baseline'];
+type LayoutAlign = (typeof LAYOUT_ALIGNS)[number];
+/** Main-axis placement (horizontal in a `layers` stack). */
+declare const LAYOUT_DISTRIBUTES: readonly ['start', 'center', 'end', 'between', 'around', 'evenly'];
+type LayoutDistribute = (typeof LAYOUT_DISTRIBUTES)[number];
+declare const LAYOUT_WRAPS: readonly ['nowrap', 'wrap', 'wrap-reverse'];
+type LayoutWrap = (typeof LAYOUT_WRAPS)[number];
+/** How one axis of a part is sized (PRELUDE §4 "child sizing"). `weight`, `fixed` and `ratio`
+ *  take an argument: `weight(2)`, `fixed(size.md)`, `ratio(16:9)`. */
+declare const AXIS_INTENTS: readonly ['fit', 'fill', 'weight', 'fixed', 'ratio'];
+type AxisIntentKind = (typeof AXIS_INTENTS)[number];
+/** The clamps an axis intent may be followed by: `min(size.sm)`, `max(size.lg)`. */
+declare const AXIS_CLAMPS: readonly ['min', 'max'];
+/** Where a part sits relative to the flow. `pinned` and `bleed` take logical edges. */
+declare const POSITION_KINDS: readonly ['flow', 'overlay', 'pinned', 'bleed'];
+type PositionKind = (typeof POSITION_KINDS)[number];
+/** Logical edges, so a design system reads the same in a right-to-left locale. */
+declare const LOGICAL_EDGES: readonly ['block-start', 'block-end', 'inline-start', 'inline-end', 'block', 'inline', 'all'];
+type LogicalEdge = (typeof LOGICAL_EDGES)[number];
+/** The physical edge words the parser used to take, read as the logical edge each names in a
+ *  horizontal left-to-right system. Read, never offered, never written - the `rgba` treatment. */
+declare const PHYSICAL_EDGE_ALIASES: Readonly<Record<string, LogicalEdge>>;
+/** The keys of the editor's layout record (`node.layout`), whose values are the words above:
+ *  a direction, an alignment, a distribution, a wrap, an axis intent spelled as the surface
+ *  spells it (`fill`, `weight(2)`, `ratio(16:9)`, a size token or a length), a clamp as a size
+ *  token or a length, and a position as its surface words (`overlay`, `pinned block-start`). */
+declare const LAYOUT_RECORD_KEYS: readonly ['direction', 'align', 'distribute', 'wrap', 'width', 'height', 'widthMin', 'widthMax', 'heightMin', 'heightMax', 'position'];
+type LayoutRecordKey = (typeof LAYOUT_RECORD_KEYS)[number];
+declare const EXAMPLE_KEYWORDS: readonly string[];
+declare const DEMO_ACTION_OPS: readonly string[];
+declare function kebab(s: string): string;
+/** A surface kebab key → the IR's camelCase field (`week-starts-on` → `weekStartsOn`). */
+declare function camelField(s: string): string;
+declare const MILDA_SURFACE_VERSION = "0.8";
+declare const PRELUDE_VERSION = "0.0.2";
+type FacetName = 'fill' | 'ink' | 'border' | 'border.top' | 'border.right' | 'border.bottom' | 'border.left' | 'border.inline-start' | 'border.inline-end' | 'border.block-start' | 'border.block-end' | 'corner' | 'inset' | 'gap' | 'text' | 'textClamp' | 'textWrap' | 'weight' | 'font' | 'slant' | 'elevation' | 'overlay' | 'opacity' | 'ring' | 'backdrop';
+type InsetValue = {
+  block?: Id;
+  inline?: Id;
+} | {
+  top?: Id;
+  right?: Id;
+  bottom?: Id;
+  left?: Id;
+} | {
+  all: Id;
+};
+type BorderFacetStyle = 'solid' | 'dashed' | 'dotted';
+interface BorderFacetValue {
+  width?: Id;
+  color?: Id;
+  style?: BorderFacetStyle;
+}
+type FacetValue = {
+  token: Id;
+} | {
+  literal: string | number | boolean;
+} | {
+  inset: InsetValue;
+} | {
+  border: BorderFacetValue;
+} | {
+  raw: string;
+};
+type FacetMap = Partial<Record<FacetName, FacetValue>>;
+type StackAxis = LayoutDirection;
+type AxisIntent = 'fit' | 'fill' | {
+  weight: number;
+} | {
+  fixed: Id;
+} | {
+  ratio: {
+    w: number;
+    h: number;
+  };
+};
+interface AxisSize {
+  intent: AxisIntent;
+  min?: Id;
+  max?: Id;
+}
+type AxisSizeValue = AxisIntent | AxisSize;
+type Distribute = LayoutDistribute;
+type Align = LayoutAlign;
+/** `pinned` and `bleed` name LOGICAL edges (PRELUDE §4, proposal 0003 §2a). */
+type Position = 'flow' | 'overlay' | {
+  pinned: LogicalEdge[];
+} | {
+  bleed: LogicalEdge[];
+};
+interface LayoutSpec {
+  stack?: StackAxis;
+  /** Reserved: read and reported, with no target yet (0056 §3.3). */
+  grid?: {
+    cols: number;
+    rows?: number;
+  };
+  /** The `flow` key, an alias of `wrap wrap` (0003 §2b). Read, never written. */
+  flow?: boolean;
+  wrap?: LayoutWrap;
+  gap?: Id;
+  inset?: InsetValue;
+  distribute?: Distribute;
+  align?: Align;
+  size?: {
+    width?: AxisSizeValue;
+    height?: AxisSizeValue;
+  };
+  position?: Position;
+}
+type StateName = 'pressed' | 'hovered' | 'focused' | 'active' | 'selected' | 'checked' | 'expanded' | 'open' | 'disabled' | 'readonly' | 'loading' | 'error' | 'success' | 'invalid' | 'valid' | 'indeterminate' | 'dragging' | 'empty' | 'complete' | 'first' | 'last' | 'odd' | 'even';
+type Capability = 'input.keyboard' | 'input.pointer' | 'input.touch' | 'input.remote' | 'input.voice' | 'motion.haptic' | 'runtime.dynamic-color' | 'display.density' | 'a11y.screenreader' | 'platform.web' | 'platform.ios' | 'platform.android' | 'platform.tvos';
+interface AtomParam {
+  name: string;
+  bind?: boolean;
+}
+interface AtomContextVar {
+  name: string;
+  type?: string;
+  init?: string;
+}
+interface AtomStateNode {
+  id: string;
+  initial?: boolean;
+}
+interface AtomEvent {
+  name: string;
+  args?: string[];
+}
+interface Emit {
+  event: string;
+  arg?: string | boolean | number;
+}
+interface Assignment {
+  target: string;
+  expr: string;
+}
+type TransitionTarget = string | {
+  expr: string;
+};
+interface Transition {
+  from: string;
+  on?: string;
+  after?: string;
+  when?: string;
+  to?: TransitionTarget;
+  ctx?: Assignment[];
+  emit?: Emit;
+  do?: string;
+  note?: string;
+}
+interface Expose {
+  state: string;
+  when: string;
+  arg?: string;
+}
+interface RequiresClause {
+  anyOf: Capability[];
+  when?: string;
+}
+interface Atom {
+  kind: 'atom';
+  name: string;
+  doc?: string;
+  requires?: RequiresClause[];
+  params?: AtomParam[];
+  context?: AtomContextVar[];
+  states?: AtomStateNode[];
+  events?: AtomEvent[];
+  transitions: Transition[];
+  exposes?: Expose[];
+  emits?: {
+    name: string;
+  }[];
+  modes?: string[];
+  note?: string;
+}
+type CoordEntry = {
+  kind: 'wire';
+  from: string;
+  to: string;
+  arg?: string;
+  when?: string;
+} | {
+  kind: 'gate';
+  machine: string;
+  activeWhen: string;
+} | {
+  kind: 'broadcast';
+  set: string;
+  event: string;
+} | {
+  kind: 'aggregate';
+  op: 'all' | 'any' | 'count' | 'first';
+  set: string;
+  pred: string;
+  as?: string;
+  then?: string;
+} | {
+  kind: 'arena';
+  over: string[];
+  exclusive: boolean;
+} | {
+  kind: 'requiresFail';
+  gesture: string;
+  failsAfter: string;
+};
+interface UsesClause {
+  atom: string;
+  as: string;
+  params?: Record<string, string>;
+}
+interface CompositeBehavior {
+  kind: 'composite';
+  name: string;
+  builtFrom: string[];
+  uses?: UsesClause[];
+  composition?: CoordEntry[];
+  emits?: {
+    name: string;
+  }[];
+  note?: string;
+}
+type ArchetypeGroup = 'Actions' | 'Inputs' | 'Disclosure' | 'Navigation' | 'Collections' | 'Feedback' | 'Media';
+interface ContentCategory {
+  level: 'phrase' | 'region';
+  interactive: boolean;
+}
+interface ArchetypeRealize {
+  target: string;
+  when?: string;
+  surface?: string;
+  browse?: string;
+  commit?: 'explicit' | 'continuous';
+  drop?: string[];
+  wire?: {
+    from: string;
+    to: string;
+    arg?: string;
+  }[];
+  note?: string;
+}
+type PartRole = 'container' | 'item' | 'text' | 'control' | 'input' | 'icon' | 'content';
+interface AnatomyPart {
+  name: string;
+  role: PartRole;
+  optional?: boolean;
+  children?: AnatomyPart[];
+}
+interface ArchetypeDef {
+  kind: 'archetype';
+  name: string;
+  group: ArchetypeGroup;
+  contract: string;
+  produces: ContentCategory;
+  anatomy?: AnatomyPart[];
+  composes: string[];
+  uses?: UsesClause[];
+  composition?: CoordEntry[];
+  exposes?: Expose[];
+  emits?: {
+    name: string;
+    from?: string;
+  }[];
+  realize?: ArchetypeRealize[];
+  realizationNote?: string;
+}
+interface FacetDef {
+  name: FacetName;
+  covers: string;
+  divergence?: string;
+}
+interface StateDef {
+  name: StateName;
+  from: string;
+}
+interface CapabilityDef {
+  name: Capability;
+  note?: string;
+  status?: 'aspirational';
+}
+interface TaxonomyNote {
+  name: string;
+  note: string;
+}
+interface PreludeDocument extends MildaDocumentBase {
+  kind: 'prelude';
+  atoms: Atom[];
+  composites: CompositeBehavior[];
+  archetypes: ArchetypeDef[];
+  facets: FacetDef[];
+  states: StateDef[];
+  capabilities: CapabilityDef[];
+  decorations: TaxonomyNote[];
+  nonBehaviors: TaxonomyNote[];
+}
+interface PropDef {
+  id: Id;
+  name: string;
+  type: TypeExpr;
+  default?: PropValue;
+  required?: boolean;
+  requiredWhen?: Predicate;
+  description?: string;
+  global?: true;
+  binding?: string;
+  meta?: Metadata;
+}
+interface EventDef {
+  id?: Id;
+  name: string;
+  from?: string;
+  payload?: TypeExpr;
+  description?: string;
+}
+interface PropConstraint {
+  kind: 'one-of' | 'any-of' | 'exclusive';
+  props: string[];
+}
+interface Contract {
+  params: Record<string, ParamBinding>;
+  props: PropDef[];
+  events: EventDef[];
+  /** Absent when the props block states none. */
+  constraints?: PropConstraint[];
+}
+interface PartState {
+  layout?: LayoutSpec;
+  facets?: FacetMap;
+}
+type PredicateRef = {
+  kind: 'prop';
+  path: string;
+} | {
+  kind: 'state';
+  state: string;
+} | {
+  kind: 'context';
+  group: string;
+} | {
+  kind: 'ancestor';
+  nodeId: string;
+  state: string;
+};
+type CompareOp = 'eq' | 'ne' | 'lt' | 'lte' | 'gt' | 'gte' | 'contains' | 'set' | 'unset';
+type Predicate = {
+  kind: 'all';
+  items: Predicate[];
+} | {
+  kind: 'any';
+  items: Predicate[];
+} | {
+  kind: 'not';
+  item: Predicate;
+} | {
+  kind: 'cmp';
+  ref: PredicateRef;
+  op: CompareOp;
+  value?: PropValue;
+};
+interface PartVariant {
+  when?: RealizeCond;
+  whenPredicate?: Predicate;
+  states?: StateName[];
+  facets?: FacetMap;
+  layout?: LayoutSpec;
+}
+type PartSlotArity = 'single' | 'optional' | 'many';
+type PartSlotAccepts = {
+  kind: 'content';
+} | {
+  kind: 'type';
+  ref: string;
+} | {
+  kind: 'component';
+  ref: string;
+};
+/** A design-time-only fill for a slot (never generated): a literal string, a named
+ *  example, or a list of either (the multi-item preview of a `many` slot). */
+type PartSlotSample = {
+  kind: 'text';
+  text: string;
+} | {
+  kind: 'example';
+  example: string;
+} | {
+  kind: 'list';
+  items: PartSlotSample[];
+};
+interface PartSlot {
+  arity: PartSlotArity;
+  accepts: PartSlotAccepts;
+  /** The slot a consumer fills when they pass children positionally. */
+  default?: boolean;
+  /** The item field that keys a `many` slot's entries. */
+  keyedBy?: string;
+  /** The public name this slot is exposed under, when it differs from the part name. */
+  exposeAs?: string;
+  /** `trigger` / `panel` - the structural role a disclosure's slot plays. */
+  role?: string;
+  /** Authored doc prose for the slot (proposal 0018), transcluded by the docs page. */
+  description?: string;
+  sample?: PartSlotSample;
+}
+/** A value that is either a literal or BOUND to a prop. Mirrors core's `ContentValue`. */
+type PartValue = {
+  kind: 'value';
+  value: PropValue;
+} | {
+  kind: 'bind';
+  prop: string;
+};
+/** One conditional leg of a part's text (`when <predicate> -> <value>`). */
+interface PartContentRule {
+  when?: Predicate;
+  value: PartValue;
+}
+/** A part's text content: a fixed string, or a default plus predicate-gated legs. */
+type PartContent = {
+  kind: 'static';
+  text: string;
+} | {
+  kind: 'dynamic';
+  default: PartValue;
+  rules: PartContentRule[];
+};
+/** Accessible naming (proposal 0013). `labelledBy`/`describedBy` name a part by PATH. */
+interface PartA11y {
+  name?: PartValue;
+  labelledBy?: string;
+  describedBy?: string;
+}
+/** An event the part raises: `<event> on <interaction> [payload …]`. `event` is a
+ *  declared event NAME (the surface never prints an internal event id). */
+interface PartEmit {
+  event: string;
+  on: string;
+  payload?: PartValue;
+  signal?: string;
+  locked?: boolean;
+}
+/** A UI state driven by a prop (`bind state disabled disabled`). */
+interface PartStateBinding {
+  state: string;
+  prop: string;
+}
+type PartRepeatSource = {
+  kind: 'prop';
+  prop: string;
+} | {
+  kind: 'static';
+  items: PropValue[];
+};
+/** Repetition over a collection (`repeat items as item`). */
+interface PartRepeat {
+  source: PartRepeatSource;
+  itemAlias: string;
+}
+/** One transition (proposal 0017). `duration`/`easing`/`delay` name TOKENS. */
+interface PartMotionTransition {
+  facets?: string[];
+  duration: string;
+  easing?: string;
+  delay?: string;
+}
+/** A nested component (proposal 0012). `component` is the component NAME. */
+interface PartInstance {
+  component: string;
+  props: Array<{
+    name: string;
+    value: PartValue;
+  }>;
+}
+/** Non-portable, target-specific content (proposal 0041 §4). Quarantined by design: a
+ *  reader that does not know `target` must skip it rather than try to interpret it. */
+interface PartForeign {
+  code: string;
+  label?: string;
+  target?: string;
+}
+interface PartCell {
+  header?: boolean;
+  scope?: 'col' | 'row';
+}
+type PartMediaSample = {
+  kind: 'asset';
+  asset: string;
+} | {
+  kind: 'url';
+  url: string;
+};
+type PartMediaSource = {
+  kind: 'bind';
+  prop: string;
+  sample?: PartMediaSample;
+} | {
+  kind: 'static';
+  asset: string;
+};
+/** A free behaviour (proposal 0041 §4): a closed vocabulary of interaction behaviours
+ *  (`focus-trap`, `typeahead`, …), each a flat record of scalars and part paths. */
+interface PartBehavior {
+  kind: string;
+  config: Metadata;
+}
+/** The per-archetype configuration surfaces (proposal 0034/0029/0035): `calendar { … }`,
+ *  `tabs { … }`, `slider { … }`, … Each block is a flat record of scalars, keyed by the
+ *  surface block name; the AST→IR adapter VALIDATES each into its typed shape rather
+ *  than casting, because a `.milda` is untrusted input. */
+type PartConfigs = Record<string, Metadata>;
+interface Part {
+  layout?: LayoutSpec;
+  facets?: FacetMap;
+  kind?: string;
+  origin?: 'root' | 'archetype' | 'author';
+  locked?: boolean;
+  content?: PartContent;
+  a11y?: PartA11y;
+  emits?: PartEmit[];
+  stateBindings?: PartStateBinding[];
+  /** The prop this part's value is bound to (an input's `value`). */
+  valueBinding?: string;
+  /** The declared type of the value this part holds. */
+  value?: TypeExpr;
+  repeat?: PartRepeat;
+  cell?: PartCell;
+  /** Control realization (proposal 0016): `checkbox` | `switch`. */
+  control?: string;
+  /** Group realization (0022): `radio` | `segmented`. */
+  group?: string;
+  /** Presentation intent (0022 §8): `accessibleName` for an icon-only control. */
+  presentation?: string;
+  /** Media type of a content part: `img` | `video` | `audio` | `embed`. */
+  media?: string;
+  mediaSource?: PartMediaSource;
+  mediaAlt?: PartValue;
+  /** Navigation target of a link part - static or prop-bound. */
+  destination?: PartValue;
+  motion?: PartMotionTransition[];
+  instance?: PartInstance;
+  behaviors?: PartBehavior[];
+  foreign?: PartForeign;
+  configs?: PartConfigs;
+  /** Demo interactions (proposal 0021) - only meaningful inside an `example`. */
+  actions?: PartAction[];
+  slot?: PartSlot;
+  presence?: Predicate;
+  states?: Partial<Record<StateName, PartState>>;
+  variants?: PartVariant[];
+}
+type Anatomy = Record<string, Part>;
+interface RealizeCond {
+  prop: string;
+  eq: string | number | boolean;
+}
+interface Wire {
+  from: string;
+  to: string;
+  arg?: string;
+  when?: RealizeCond;
+}
+interface PresentationRealize {
+  surface?: string;
+  place?: string;
+  flip?: boolean;
+  matchWidth?: boolean;
+}
+interface BrowseRealize {
+  mode?: string;
+  orient?: 'horizontal' | 'vertical';
+  wrap?: boolean;
+}
+interface CommitRealize {
+  mode: 'explicit' | 'continuous';
+  on?: string[];
+  live?: string;
+  settled?: string;
+}
+interface Realization {
+  target: string;
+  when: RealizeCond | null;
+  presentation?: PresentationRealize;
+  browse?: BrowseRealize;
+  commit?: CommitRealize;
+  surface?: string;
+  drop?: string[];
+  wire?: Wire[];
+  note?: string;
+  dismiss?: string[];
+  backdrop?: string;
+}
+interface Composition {
+  uses: UsesClause[];
+  coordination: CoordEntry[];
+}
+interface Component {
+  id: Id;
+  name: string;
+  description?: string;
+  archetype: string;
+  contract: Contract;
+  anatomy: Anatomy;
+  realize: Realization[];
+  composition?: Composition;
+  meta?: Metadata;
+  group?: string;
+}
+interface ComponentGroupDecl {
+  path: string;
+  description?: string;
+}
+interface DemoVariable {
+  type: TypeExpr;
+  initial: PropValue;
+}
+interface Example {
+  name: string;
+  /** The component NAME this scene demonstrates; absent = a freestanding fixture. */
+  for?: string;
+  description?: string;
+  demo?: Record<string, DemoVariable>;
+  anatomy: Anatomy;
+}
+interface PartAction {
+  on: string;
+  op: 'set' | 'toggle';
+  variable: string;
+  value?: PropValue;
+}
+interface ProjectMetadataEntry {
+  id: Id;
+  key: string;
+  type: TypeExpr;
+  value?: PropValue;
+}
+/**
+ * A prop declared ONCE for the whole system, which any component may take by reference
+ * (proposal 0051 §5). Its default is the system-wide value; an instance overrides it by passing
+ * the prop, exactly as it would a local one.
+ *
+ * It lives in the foundations rather than on a component because that is what it IS: a
+ * system-wide decision, next to the context groups it usually names. A design system with a
+ * `variant` dimension says so once - the Radix mapping restated the same five props on 49
+ * components, and the restatement carried no information.
+ */
+interface GlobalProp {
+  id: Id;
+  name: string;
+  type: TypeExpr;
+  /** The system-wide value. Absent means "no default" - for a context type, inherit the theme. */
+  default?: PropValue;
+  description?: string;
+}
+/**
+ * How the system is meant to be put together (proposal 0052 §5): a top-level `rule`. Mirrors the
+ * editor IR's `UsageRule` (@mildastudio/core) for the reason `Predicate` does - this package is
+ * standalone - and is lowered to it by the AST adapter in `@mildastudio/generate`.
+ *
+ * Every reference is by NAME, so a rule naming a component another file declares survives a
+ * per-file round trip; a reference nothing resolves is a warning, never a drop.
+ */
+interface RuleSubject {
+  kind: 'component' | 'archetype';
+  name: string;
+  where?: Predicate;
+}
+type UsageRule = {
+  id: string;
+  severity: 'error' | 'warning';
+  rationale: string;
+} & ({
+  kind: 'count';
+  subject: RuleSubject;
+  within: RuleSubject;
+  min?: number;
+  max?: number;
+} | {
+  kind: 'never';
+  subject: RuleSubject;
+  within: RuleSubject;
+} | {
+  kind: 'only-within';
+  subject: RuleSubject;
+  within: RuleSubject[];
+} | {
+  kind: 'tokens-only';
+  types: TokenType[];
+} | {
+  kind: 'prefer';
+  component: string;
+  archetypes: string[];
+});
+interface Foundations {
+  contextGroups: ContextGroup[];
+  layers: Layer[];
+  sharedTypes: SharedType[];
+  metadata: ProjectMetadataEntry[];
+  /** Absent when the system declares none, so a file that has never used one is unchanged. */
+  globalProps?: GlobalProp[];
+  /** Usage rules (0052 §5). Absent when the file declares none. */
+  rules?: UsageRule[];
+}
+type DocBlockDecl = {
+  kind: 'prose';
+  prose: string;
+  text: string;
+  anchor?: string;
+} | {
+  kind: 'divider';
+} | {
+  kind: 'image';
+  asset?: string;
+} | {
+  kind: 'component';
+  component?: string;
+} | {
+  kind: 'componentProps';
+  component?: string;
+} | {
+  kind: 'componentEvents';
+  component?: string;
+} | {
+  kind: 'componentComposition';
+  component?: string;
+} | {
+  kind: 'componentProp';
+  component?: string;
+  prop?: string;
+} | {
+  kind: 'componentEvent';
+  component?: string;
+  event?: string;
+} | {
+  kind: 'example';
+  example?: string;
+} | {
+  kind: 'componentGroup';
+  group?: string;
+} | {
+  kind: 'tokens';
+  tokenType?: string;
+} | {
+  kind: 'swatch';
+  tokenType?: string;
+};
+interface DocPageDecl {
+  title: string;
+  /** The sidebar section this page sits in. */
+  group?: string;
+  /** The parent page's TITLE, for a nested page. */
+  parent?: string;
+  blocks: DocBlockDecl[];
+}
+interface DocsSiteDecl {
+  name?: string;
+  tagline?: string;
+  version?: string;
+  searchPlaceholder?: string;
+}
+interface DocsFooterLinkDecl {
+  label: string;
+  href: string;
+}
+interface DocsFooterDecl {
+  links: DocsFooterLinkDecl[];
+  copyright?: string;
+}
+interface DocsDecl {
+  pages: DocPageDecl[];
+  site?: DocsSiteDecl;
+  footer?: DocsFooterDecl;
+}
+interface AssetFolderDecl {
+  /** The folder's PATH (`Brand/Icons`), which is its nesting written down. */
+  path: string;
+}
+interface AssetDecl {
+  kind: string;
+  name: string;
+  /** The containing folder's path; absent = the library root. */
+  folder?: string;
+  mimeType?: string;
+  sizeBytes?: number;
+  uploadedAt?: string;
+  /** Where the bytes live. A `data:` URI here makes the file self-contained. */
+  url?: string;
+  tags?: string[];
+  /** Per-kind metadata (`width`, `viewBox`, `fontWeight`, …), validated on lowering. */
+  props: Record<string, PropValue>;
+}
+interface AssetsDecl {
+  folders: AssetFolderDecl[];
+  assets: AssetDecl[];
+}
+interface IconSetDecl {
+  /** The set's prefix in its provider's namespace (`lucide`, `ph`), which is what resolves. */
+  prefix: string;
+  name: string;
+  provider?: string;
+  license?: string;
+  /** Four representative glyph names a preview shows for the set. */
+  samples?: string[];
+}
+type IconDecl = {
+  kind: 'set';
+  prefix: string;
+  name: string;
+  label?: string;
+  /** The glyph's vendored SVG body, so a generated package needs no CDN (proposal 0019). */
+  svg?: string;
+} | {
+  kind: 'custom';
+  name: string;
+  /** The NAME of the asset in the file's `assets` block whose bytes draw this glyph. */
+  asset?: string;
+  label?: string;
+};
+interface IconsDecl {
+  sets: IconSetDecl[];
+  icons: IconDecl[];
+}
+type AssetKind = 'font' | 'image' | 'svg' | 'video' | 'animation';
+interface BaseAsset {
+  id: string;
+  name: string;
+  kind: AssetKind;
+  mimeType: string;
+  sizeBytes: number;
+  uploadedAt: string;
+  url: string;
+  tags: string[];
+  folderId: string | null;
+}
+interface FontAsset extends BaseAsset {
+  kind: 'font';
+  fontFamily: string;
+  fontStyle: 'normal' | 'italic';
+  fontWeight: number;
+  formats: Array<'woff2' | 'woff' | 'ttf' | 'otf'>;
+}
+interface ImageAsset extends BaseAsset {
+  kind: 'image';
+  width: number;
+  height: number;
+  alt: string;
+}
+interface SvgAsset extends BaseAsset {
+  kind: 'svg';
+  viewBox: string;
+  width: number;
+  height: number;
+}
+interface VideoAsset extends BaseAsset {
+  kind: 'video';
+  width: number;
+  height: number;
+  durationMs: number;
+  poster?: string;
+}
+type AnimationFormat = 'lottie' | 'rive' | 'css';
+interface AnimationAsset extends BaseAsset {
+  kind: 'animation';
+  format: AnimationFormat;
+  durationMs: number;
+  loop: boolean;
+}
+type Asset = FontAsset | ImageAsset | SvgAsset | VideoAsset | AnimationAsset;
+type AssetByKind = {
+  font: FontAsset;
+  image: ImageAsset;
+  svg: SvgAsset;
+  video: VideoAsset;
+  animation: AnimationAsset;
+};
+interface AssetFolder {
+  id: string;
+  name: string;
+  parentId: string | null;
+  createdAt: string;
+}
+interface AssetRegistry {
+  assets: Record<string, Asset>;
+  folders: Record<string, AssetFolder>;
+}
+interface Project extends MildaDocumentBase {
+  kind: 'design-system';
+  foundations: Foundations;
+  assets: AssetRegistry;
+  components: Component[];
+}
+declare const preludeV0: PreludeDocument;
+declare const atomsByName: Record<string, Atom>;
+declare const compositesByName: Record<string, CompositeBehavior>;
+declare const archetypesByName: Record<string, ArchetypeDef>;
+type ResolvedToken = {
+  kind: 'value';
+  type: TokenType;
+  value: AnyTokenValue;
+} | {
+  kind: 'escape';
+  raw: string;
+  note?: string;
+} |
+/**
+ * A computed value (proposal 0044), reported rather than evaluated: the maths - colour
+ * spaces, dp lowering - lives in the editor IR's resolver, not in this lightweight AST
+ * walk. It is its own answer because neither alternative is true: `null` would say the
+ * token does not resolve (it does, and a conformance check would report a hole that is not
+ * there), and returning the base's value would say the token IS its base, unmodified.
+ */
+{
+  kind: 'computed';
+  type: TokenType;
+  from: string;
+} | null;
+declare function resolveToken(tokenId: string, contextIds: string | readonly string[], layers: Layer[], _depth?: number): ResolvedToken;
+declare function findToken(tokenId: string, layers: Layer[]): {
+  token: Token$1;
+  layerId: string;
+} | null;
+declare function allTokensOfType(type: TokenType, layers: Layer[]): Array<{
+  token: Token$1;
+  layerId: string;
+  layerName: string;
+}>;
+interface ValidationIssue {
+  severity: 'error' | 'warning';
+  code: string;
+  message: string;
+  where?: string;
+  id?: string;
+}
+declare function validate(doc: Project, prelude: PreludeDocument): ValidationIssue[];
+interface Hole {
+  kind: 'facet' | 'layout' | 'behavior';
+  name: string;
+  where: string;
+  reason: string;
+}
+interface Substitution {
+  behavior: string;
+  via: string;
+}
+interface ConformanceReport {
+  target: string;
+  complete: boolean;
+  holes: Hole[];
+  substitutions: Substitution[];
+}
+interface ConformanceOptions {
+  target: string;
+  contextIds: string[];
+  layers: Layer[];
+}
+declare function conformance(comp: Component, opts: ConformanceOptions): ConformanceReport;
+interface DesignSystemDocument {
+  milda: string;
+  kind: 'design-system';
+  prelude: string;
+  meta: {
+    id: string;
+    name: string;
+    version: string;
+    description?: string;
+  };
+  foundations: Foundations;
+  components: Component[];
+  componentGroups?: ComponentGroupDecl[];
+  examples?: Example[];
+  docs?: DocsDecl;
+  assets?: AssetsDecl;
+  icons?: IconsDecl;
+}
+interface ParseIssue {
+  severity: 'error' | 'warning';
+  code: string;
+  message: string;
+  line: number;
+  col: number;
+}
+interface SourcePosition {
+  line: number;
+  col: number;
+}
+interface SourceRange {
+  start: SourcePosition;
+  end: SourcePosition;
+}
+type SpanKind = 'component' | 'token' | 'contextGroup' | 'context' | 'sharedType' | 'globalProp' | 'rule' | 'part' | 'prop' | 'event';
+interface NodeSpan {
+  id: string;
+  kind: SpanKind;
+  name: string;
+  nameRange: SourceRange;
+  fullRange: SourceRange;
+  parentId?: string;
+}
+interface ParseResult {
+  document: DesignSystemDocument;
+  issues: ParseIssue[];
+  spans: NodeSpan[];
+}
+interface ParseOptions {
+  name?: string;
+  milda?: string;
+  prelude?: string;
+}
+/** Facet names accepted by `parseFacetStmt` (those with an AST home). */
+declare const FACET_NAMES: readonly string[];
+/** Token-type names accepted by `parseTokenDecl` - kebab spelling only (the camelCase
+ *  aliases in TYPE_MAP stay accepted, they're just not advertised, and neither are the
+ *  legacy spellings above). */
+declare const TOKEN_TYPE_NAMES: readonly string[];
+/** The `token … = ‹kind›` value kinds. */
+declare const TOKEN_VALUE_KINDS: readonly string[];
+/** Keys accepted inside a `layout { … }` block - keep in step with `parseLayoutBody`. `flow` and
+ *  `ratio` are reading aliases (0056 §3.2); `grid` is reserved (0056 §3.3). */
+declare const LAYOUT_KEYS: readonly string[];
+/** What may follow each word inside a `layout { … }` block, keyed on the word BEFORE the
+ *  cursor so completion can read it directly: a key's values, the edges after `pinned` /
+ *  `bleed`, the intents after `size` / `width` / `height`. All from the vocabulary (0056 §3.1),
+ *  so the parser, the printer and the LSP cannot disagree about a word. */
+declare const LAYOUT_VALUES: Readonly<Record<string, readonly string[]>>;
+/** Slot arities accepted by `slot ‹arity›` (grammar `arity`). */
+declare const SLOT_ARITIES: readonly string[];
+/** Statement keywords accepted inside a `part { … }` block, for editor completion. */
+declare const PART_KEYWORDS: readonly string[];
+/** The surface token-type names whose value MUST carry a unit (a bare number is rejected
+ *  with `length-unit-required`). Exported so the printer's own "emit a canonical length
+ *  here" set can be asserted against this one: giving `border`/`font-size`/`letter-spacing`
+ *  their own words widened the reader's set and left the writer's behind, so the printer
+ *  emitted bare numbers its own reader then refused (0041 §1.1d). */
+declare const LENGTH_TOKEN_TYPE_NAMES: readonly string[];
+/**
+ * The KIND of value a token type carries. Types are grouped into families rather than compared
+ * exactly, because several of them share a value shape on purpose: a `ring` or a `backdrop` IS a
+ * colour, and every length type fills a length slot. Used by the alias cross-type check (below)
+ * and by editor tooling, which offers the tokens that would fit a slot - one answer to "can this
+ * value go there", not two that can disagree.
+ */
+declare function tokenTypeFamily(type: TokenType | string): string;
+/** Every accepted spelling of a token type → the AST type it means (`dimension` → `size`,
+ *  `font-family` → `fontFamily`). Exported so tooling can read a DECLARED type off the source
+ *  and compare it with the tokens it already parsed. */
+declare const TOKEN_TYPES_BY_NAME: Readonly<Record<string, TokenType>>;
+/** The surface token-type names whose value is a COLOUR - so an editor knows that this is
+ *  where `hex(…)` and `oklch(…)` belong, without a second list of type names to keep in
+ *  step with this file's (a `ring` and a `backdrop` are colours too, and both were missed
+ *  by every hand-written copy of "the colour types"). */
+declare const COLOR_TOKEN_TYPE_NAMES: readonly string[];
+declare function parseMildaDocument(src: string, opts?: ParseOptions): ParseResult;
+type TokenType$1 = 'word' | 'string' | 'lbrace' | 'rbrace' | 'lparen' | 'rparen' | 'lbracket' | 'rbracket' | 'lt' | 'gt' | 'lte' | 'gte' | 'ne' | 'colon' | 'equals' | 'comma' | 'semi' | 'question' | 'arrow' | 'at' | 'newline' | 'eof';
+interface Token {
+  type: TokenType$1;
+  value: string;
+  pos: number;
+  line: number;
+  col: number;
+}
+declare class LexError extends Error {
+  line: number;
+  col: number;
+  constructor(message: string, line: number, col: number);
+}
+/** A character the lexer had to skip: not a token, not whitespace, not a comment. Collected
+ *  rather than thrown, so a half-typed document still lexes - but REPORTED, because silently
+ *  dropping a character means a typo changes the value and the author never learns. `hex(őfff)`
+ *  used to lex as `hex(fff)`: white, no issue, no clue (proposal 0041). */
+interface SkippedChar {
+  char: string;
+  line: number;
+  col: number;
+}
+declare function lex(src: string, skipped?: SkippedChar[]): Token[];
+export { ASSET_BASE_KEYS, ASSET_FIELDS, ASSET_FIELD_KEYS, ASSET_KINDS, AXIS_CLAMPS, AXIS_INTENTS, type AliasTokenValue, type Align, type Anatomy, type AnatomyPart, type AnimationAsset, type AnimationFormat, type AnyTokenValue, type ArchetypeDef, type ArchetypeGroup, type ArchetypeRealize, type Asset, type AssetByKind, type AssetDecl, type AssetFolder, type AssetFolderDecl, type AssetKind, type AssetRegistry, type AssetsDecl, type Assignment, type Atom, type AtomContextVar, type AtomEvent, type AtomParam, type AtomStateNode, type AxisIntent, type AxisIntentKind, type AxisSize, type AxisSizeValue, BEHAVIOR_FIELDS, BEHAVIOR_KINDS, type BlurValue, type BorderFacetStyle, type BorderFacetValue, type BorderStyle, type BorderValue, type BorderWidth, type BrowseRealize, CELL_MODIFIERS, COLOR_KEYWORDS, COLOR_LITERAL_ALIASES, COLOR_LITERAL_FNS, COLOR_LITERAL_SPELLINGS, COLOR_TOKEN_TYPE_NAMES, CONTROL_REALIZATIONS, type Capability, type CapabilityDef, type ColorOrRef, type ColorSpace, type ColorValue, type CommitRealize, type CompareOp, type Component, type ComponentGroupDecl, type CompositeBehavior, type Composition, type ComputeOp, type ComputeSpace, type ComputeTokenValue, type ConfigFieldSpec, type ConfigSurface, type ConformanceOptions, type ConformanceReport, type ContentCategory, type Context, type ContextGroup, type Contract, type CoordEntry, DEMO_ACTION_OPS, DOCS_FOOTER_KEYWORDS, DOCS_KEYWORDS, DOCS_SITE_KEYS, DOC_BLOCK_KEYWORDS, DOC_PROSE_KINDS, DOC_TRANSCLUSIONS, type DemoVariable, type DesignSystemDocument, type DimensionOrRef, type DimensionUnit, type DimensionValue, type Distribute, type DocBlockDecl, type DocPageDecl, type DocsDecl, type DocsFooterDecl, type DocsFooterLinkDecl, type DocsSiteDecl, type DocumentKind, type DocumentMeta, type DocumentMeta as ProjectMeta, type Token as DslToken, type DurationValue, EXAMPLE_KEYWORDS, type Emit, type EscapeTokenValue, type EventDef, type Example, type Expose, FACET_NAMES, type FacetDef, type FacetMap, type FacetName, type FacetTokenType, type FacetValue, type FieldType, type FontAsset, type FontCategory, type FontFamilyValue, type FontProvenance, type FontWeightValue, type Foundations, GROUP_REALIZATIONS, type GlobalProp, type Hole, INTERACTION_KINDS, type IconDecl, type IconSetDecl, type IconsDecl, type Id, type ImageAsset, type InsetValue, LAYOUT_ALIGNS, LAYOUT_DIRECTIONS, LAYOUT_DISTRIBUTES, LAYOUT_KEYS, LAYOUT_RECORD_KEYS, LAYOUT_VALUES, LAYOUT_WRAPS, LENGTH_LITERAL_FNS, LENGTH_TOKEN_TYPE_NAMES, LOGICAL_EDGES, type Layer, type LayoutAlign, type LayoutDirection, type LayoutDistribute, type LayoutRecordKey, type LayoutSpec, type LayoutWrap, type LengthKeyword, type LengthKeywordValue, type LengthValue, LexError, type LiteralChannel, type LiteralFnSpec, type LogicalEdge, MEDIA_TYPES, MILDA_SURFACE_VERSION, type Metadata, type MildaDocumentBase, NODE_KINDS, NODE_ORIGINS, type NodeSpan, type NoneValue, type ObjectField, type OpacityValue, PART_CONFIGS, PART_CONFIG_NAMES, PART_CONFIG_WORDS, PART_KEYWORDS, PHYSICAL_EDGE_ALIASES, POSITION_KINDS, PRELUDE_VERSION, PRESENTATION_KINDS, type ParamBinding, type ParseIssue, type ParseOptions, type ParseResult, type Part, type PartA11y, type PartAction, type PartBehavior, type PartCell, type PartConfigs, type PartContent, type PartContentRule, type PartEmit, type PartForeign, type PartInstance, type PartMediaSample, type PartMediaSource, type PartMotionTransition, type PartRepeat, type PartRepeatSource, type PartRole, type PartSlot, type PartSlotAccepts, type PartSlotArity, type PartSlotSample, type PartState, type PartStateBinding, type PartValue, type PartVariant, type Position, type PositionKind, type Predicate, type PredicateRef, type PreludeDocument, type PresentationRealize, type PrimitiveTokenType, type Project, type ProjectMetadataEntry, type PropConstraint, type PropDef, type PropValue, type RawTokenValue, type Realization, type RealizeCond, type RequiresClause, type ResolvedToken, type RuleSubject, SLOT_ARITIES, SLOT_MODIFIERS, SLOT_ROLES, type ShadowLayer, type ShadowValue, type SharedType, type SkippedChar, type SourcePosition, type SourceRange, type SpanKind, type StackAxis, type StateDef, type StateName, type Substitution, type SvgAsset, TOKEN_TYPES_BY_NAME, TOKEN_TYPE_NAMES, TOKEN_VALUE_KIND, TOKEN_VALUE_KINDS, type TaxonomyNote, type Token$1 as Token, type TokenRef, type TokenType, type TokenValue, type TokenValueSchemaByType, type TonalValue, type Transition, type TransitionTarget, type TypeExpr, type TypeRef, type TypographyValue, type UsageRule, type UsesClause, VALUE_LITERAL_FNS, type ValidationIssue, type VideoAsset, type Wire, allTokensOfType, archetypesByName, atomsByName, camelField, compositesByName, conformance, findToken, kebab as kebabField, lex, parseMildaDocument, preludeV0, resolveToken, tokenTypeFamily, validate };