@tamagui/style-grammar 0.0.0-bootstrap.0 → 3.0.0-beta.643.1

package/types/clauseCapability.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAuBA,cAAc,cAAc,4BAA4B;AAYxD,iBAAiB,iBAAiB;;CAEhC;;CAEA;;CAEA;;;;;;;AAUF,OAAO,iBAAS,iBACd,kBACA,MAAM,2BACL;;AAwCH,YAAY,oBAAoB,WAAW,QAAQ;;;;;AAMnD,iBAAiB,SAAS;;CAExB,QAAQ;;CAER;;AAGF,iBAAiB,iBAAiB;CAChC,WAAW,aAAa,WAAW;CACnC;CACA;;CAEA;;AAGF,iBAAiB,qBAAqB;;;;;;;;;;;CAWpC,SAAS,UAAU,qBAAqB,iBAAiB;CACzD,kBAAkB;;AAGpB,iBAAiB,gBAAgB;CAC/B;;CAEA;CACA,SAAS;;;;;;CAMT,OAAO;;;;;;;;AAWT,OAAO,iBAAS,qBACd,OAAO,iBACP,UAAU,uBACT",
+  "names": [],
+  "sources": [
+    "src/clauseCapability.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "// The platform-clause capability contract and the composed conversion\n// assessment (three-dimension review, 2026-07-31).\n//\n// Three separately-owned dimensions, one composed answer:\n// - PROPERTY: programEligibility (can this prop carry programs at all).\n// - CLAUSE (this file): can a modifier lower on web CSS, and can it evaluate\n//   natively. This is the ONE owner of both capability sets — the web side is\n//   DERIVED from the lowering selector table and the native side is defined\n//   here and consumed by the native evaluator, so the claims cannot drift\n//   from what actually runs.\n// - HOST: owned by the validStyles tables in @tamagui/helpers (enforced at\n//   runtime by the text-only-prop ruling). NOT mirrored here — the consumer\n//   supplies a HostView it already holds (staticConfig for the runtime and\n//   codemod, the serialized config for tooling).\n//\n// The composition lives INSIDE assessFlatConversion so no consumer ever\n// combines axes itself: one question, one structured answer, and \"clean\"\n// means convertible AND evaluable where the author put it.\n\nimport { legacyPartComposite, programEligibility } from './programEligibility'\nimport { defaultStateSelectors } from './lowerProgram'\nimport { parseContainerModifier, parseGroupModifier } from './modifierRegistry'\nimport { nativeGroupSourceableStates, nativeSourceableStates } from './clauseSources'\nimport type { ModifierKind, ModifierRegistryView } from './valueTypes'\n\nconst nativeGroupSourceable: ReadonlySet<string> = new Set(nativeGroupSourceableStates)\n\n/**\n * Web lowerability is DERIVED from the selector table the lowering actually\n * uses, including the lifecycle classes emitted by createComponent.\n */\nconst webLowerableStates: ReadonlySet<string> = new Set(\n  Object.keys(defaultStateSelectors)\n)\n\nexport interface ClauseCapability {\n  /** the clause can lower to web CSS */\n  web: boolean\n  /** the clause can evaluate on native */\n  native: boolean\n  /** why a side is unsupported, for diagnostics */\n  note?: string\n}\n\nconst bothTargets: ClauseCapability = Object.freeze({ web: true, native: true })\n\n/**\n * Per-modifier capability. `kind` comes from the same registry the value was\n * parsed against; an unregistered modifier is a parse error upstream and\n * reports unsupported on both targets here.\n */\nexport function clauseCapability(\n  modifier: string,\n  kind: ModifierKind | undefined\n): ClauseCapability {\n  if (kind === 'media' || kind === 'theme' || kind === 'platform') {\n    return bothTargets\n  }\n  if (kind === 'container') {\n    return bothTargets\n  }\n  if (kind === 'state') {\n    const web = webLowerableStates.has(modifier)\n    const native = nativeSourceableStates.has(modifier)\n    if (web && native) return bothTargets\n    return {\n      web,\n      native,\n      note: !web\n        ? `\"${modifier}:\" cannot lower to web CSS because it has no selector`\n        : `\"${modifier}:\" is a component-tier state with no native source until the behavior packages feed componentState`,\n    }\n  }\n  if (kind === 'group') {\n    const parsed = parseGroupModifier(modifier)\n    if (!parsed)\n      return { web: false, native: false, note: `\"${modifier}:\" is not a group modifier` }\n    const web = webLowerableStates.has(parsed.state)\n    const native = nativeGroupSourceable.has(parsed.state)\n    if (web && native) return bothTargets\n    return {\n      web,\n      native,\n      note: `group state \"${parsed.state}\" has no native source`,\n    }\n  }\n  return {\n    web: false,\n    native: false,\n    note: `\"${modifier}:\" is not a registered modifier`,\n  }\n}\n\n/** file-extension intent: shared files must support BOTH targets */\nexport type ConversionTargets = 'shared' | 'web' | 'native'\n\n/**\n * Host validity as the consumer already holds it — a projection of the\n * component's staticConfig, never a table of this package's own.\n */\nexport interface HostView {\n  /** does this host accept `prop` as a style (validStyles + accept) */\n  accepts(prop: string): boolean\n  /** for diagnostics: the component label the author sees */\n  displayName?: string\n}\n\nexport interface ConversionReason {\n  dimension: 'property' | 'clause' | 'host'\n  modifier?: string\n  message: string\n  /** the action the author takes, stated concretely */\n  remedy: string\n}\n\nexport interface ConversionAssessment {\n  /**\n   * clean: convertible AND evaluable where authored, with ALL THREE\n   * dimensions verified — clean is a promise, so an unchecked dimension can\n   * never produce it. needs-relocation: the conversion is syntactically\n   * right but this site was DETERMINED unable to evaluate it — the remedy\n   * names where it goes. unknown-host: property and clauses verified but the\n   * component identity could not be established, so host validity is\n   * UNVERIFIED rather than fine — the site needs review, not relocation.\n   * ineligible: this property cannot carry the clause spelling at all.\n   */\n  verdict: 'clean' | 'needs-relocation' | 'unknown-host' | 'ineligible'\n  reasons: readonly ConversionReason[]\n}\n\nexport interface ConversionInput {\n  property: string\n  /** modifiers used across the value's clauses, deduplicated by the caller or not */\n  modifiers?: readonly string[]\n  targets: ConversionTargets\n  /**\n   * absent means the consumer could NOT establish the component's identity\n   * (structural provenance proves only direct View/Text and traceable styled\n   * bases today) — the verdict is then at best 'unknown-host', never 'clean'\n   */\n  host?: HostView\n}\n\nconst clean: ConversionAssessment = Object.freeze({ verdict: 'clean', reasons: [] })\n\n/**\n * The one call a converter, lint rule, or report makes before claiming a\n * flat-value suggestion is safe. Composes property eligibility, per-target\n * clause capability, and host validity; consumers never combine axes\n * themselves.\n */\nexport function assessFlatConversion(\n  input: ConversionInput,\n  registry: ModifierRegistryView\n): ConversionAssessment {\n  const reasons: ConversionReason[] = []\n\n  if (programEligibility(input.property) === 'legacy-part') {\n    reasons.push({\n      dimension: 'property',\n      message: `\"${input.property}\" is a part prop with no flat clause spelling`,\n      remedy: `move the condition onto \\`${legacyPartComposite[input.property]}\\``,\n    })\n    return { verdict: 'ineligible', reasons }\n  }\n\n  for (const modifier of input.modifiers ?? []) {\n    const capability = clauseCapability(modifier, registry.get(modifier))\n    const needsWeb = input.targets !== 'native'\n    const needsNative = input.targets !== 'web'\n    if ((needsWeb && !capability.web) || (needsNative && !capability.native)) {\n      const missing = needsWeb && !capability.web ? 'web' : 'native'\n      reasons.push({\n        dimension: 'clause',\n        modifier,\n        message: capability.note ?? `\"${modifier}:\" is not supported on ${missing}`,\n        remedy:\n          missing === 'web'\n            ? `keep the driver-evaluated pseudo prop, or move this usage to a .native.tsx file`\n            : `move this usage to a .web.tsx file, or drop the clause on native`,\n      })\n    }\n  }\n\n  if (input.host && !input.host.accepts(input.property)) {\n    reasons.push({\n      dimension: 'host',\n      message: `\"${input.property}\" is not a valid style on ${input.host.displayName ?? 'this component'} — the runtime drops it`,\n      remedy: `move this style to a component that accepts it (a Text-based component, or html.* on web)`,\n    })\n  }\n\n  if (reasons.length) return { verdict: 'needs-relocation', reasons }\n\n  if (!input.host) {\n    return {\n      verdict: 'unknown-host',\n      reasons: [\n        {\n          dimension: 'host',\n          message: `the component's identity could not be established, so host validity for \"${input.property}\" is unverified`,\n          remedy: `verify the component accepts this style prop, or supply type-aware provenance so the check can run`,\n        },\n      ],\n    }\n  }\n\n  return clean\n}\n"
+  ]
+}

package/types/clausePrecedence.d.ts

@@ -0,0 +1,30 @@
+export { canonicalClauseModifier } from "./modifierRegistry";
+import { type ModifierKind, type ModifierRegistryView } from "./valueTypes";
+export { grammarMaxNonPlatformDepth } from "./valueTypes";
+/**
+* The CSS emitter deliberately caps a condition chain at five distinct
+* non-platform conditions. The parser can represent longer chains, but they
+* cannot be lowered while also giving platform clauses a finite specificity
+* floor above every platform-less clause, so the shared comparator rejects
+* them consistently on every surface.
+*/
+export type ClausePrecedenceKey = readonly [platformRank: number, depth: number, categoryRank: number, withinCategoryRank: number];
+export type OrderedModifierNames = readonly string[] | ReadonlySet<string> | Readonly<Record<string, unknown>>;
+export type ClausePrecedenceOrder = ReadonlyMap<string, number>;
+export declare function createClausePrecedenceOrder(names: OrderedModifierNames | undefined): ClausePrecedenceOrder;
+/** Order-insensitive set key used by every clause merge/emission slot. */
+export declare function clauseConditionSetKey(modifiers: readonly string[]): string;
+export declare function getClausePrecedenceKeyFromKinds(modifiers: readonly string[], kinds: readonly (ModifierKind | undefined)[], order: ClausePrecedenceOrder): ClausePrecedenceKey;
+export declare function getClausePrecedenceKey(modifiers: readonly string[], registry: ModifierRegistryView, order: ClausePrecedenceOrder): ClausePrecedenceKey;
+/** Ascending comparator: a positive result means `left` wins over `right`. */
+export declare function compareClausePrecedence(left: ClausePrecedenceKey, right: ClausePrecedenceKey): number;
+/** Target CSS class specificity, excluding IDs/elements: (0, result, 0). */
+export declare function clauseTargetClassSpecificity(key: ClausePrecedenceKey): number;
+/**
+* Subject-class repetitions needed after self-state selectors contribute
+* their pseudo/attribute specificity naturally. Theme and group scopes use
+* :where(), while media/container wrappers contribute zero.
+*/
+export declare function clauseSubjectClassRepetitions(key: ClausePrecedenceKey, selfStateSpecificity: number): number;
+
+//# sourceMappingURL=clausePrecedence.d.ts.map

package/types/clausePrecedence.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAOA,SAAS,+BAA+B;AACxC,cAEO,mBACA,4BACA;AAEP,SAAS,kCAAkC;;;;;;;;AAS3C,YAAY,gCAEV,sBAEA,eAEA,sBAEA;AAGF,YAAY,2CAER,sBACA,SAAS;AAEb,YAAY,wBAAwB;AAgCpC,OAAO,iBAAS,4BACd,OAAO,mCACN;;AAmCH,OAAO,iBAAS,sBAAsB;AAOtC,OAAO,iBAAS,gCACd,8BACA,iBAAiB,6BACjB,OAAO,wBACN;AAuCH,OAAO,iBAAS,uBACd,8BACA,UAAU,sBACV,OAAO,wBACN;;AASH,OAAO,iBAAS,wBACd,MAAM,qBACN,OAAO;;AAUT,OAAO,iBAAS,6BAA6B,KAAK;;;;;;AASlD,OAAO,iBAAS,8BACd,KAAK,qBACL",
+  "names": [],
+  "sources": [
+    "src/clausePrecedence.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "import { grammarPlatformRank } from './config'\nimport {\n  canonicalClauseModifier,\n  parseContainerModifier,\n  parseGroupModifier,\n} from './modifierRegistry'\n\nexport { canonicalClauseModifier } from './modifierRegistry'\nimport {\n  grammarMaxNonPlatformDepth,\n  type ModifierKind,\n  type ModifierRegistryView,\n} from './valueTypes'\n\nexport { grammarMaxNonPlatformDepth } from './valueTypes'\n\n/**\n * The CSS emitter deliberately caps a condition chain at five distinct\n * non-platform conditions. The parser can represent longer chains, but they\n * cannot be lowered while also giving platform clauses a finite specificity\n * floor above every platform-less clause, so the shared comparator rejects\n * them consistently on every surface.\n */\nexport type ClausePrecedenceKey = readonly [\n  /** no platform = 0; web/native = 1; ios/android/tv = 2; tvos/androidtv = 3 */\n  platformRank: number,\n  /** number of distinct non-platform conditions */\n  depth: number,\n  /** media < container < theme < group < state */\n  categoryRank: number,\n  /** declaration/lifecycle rank inside the highest category */\n  withinCategoryRank: number,\n]\n\nexport type OrderedModifierNames =\n  | readonly string[]\n  | ReadonlySet<string>\n  | Readonly<Record<string, unknown>>\n\nexport type ClausePrecedenceOrder = ReadonlyMap<string, number>\n\nconst categoryRanks: Readonly<Record<Exclude<ModifierKind, 'platform'>, number>> = {\n  media: 0,\n  container: 1,\n  theme: 2,\n  group: 3,\n  state: 4,\n}\n\n// Later lifecycle entries win. Component-tier states follow the interaction\n// states in the order of states.ts's component vocabulary.\nconst stateRanks: Readonly<Record<string, number>> = Object.freeze({\n  hover: 0,\n  'focus-within': 1,\n  focus: 2,\n  'focus-visible': 3,\n  press: 4,\n  active: 4,\n  pressed: 4,\n  disabled: 5,\n  enter: 6,\n  starting: 6,\n  exit: 7,\n  ending: 7,\n  open: 8,\n  checked: 9,\n  highlighted: 10,\n  selected: 11,\n  invalid: 12,\n})\n\nexport function createClausePrecedenceOrder(\n  names: OrderedModifierNames | undefined\n): ClausePrecedenceOrder {\n  const ranks = new Map<string, number>()\n  if (!names) return ranks\n  let rank = 0\n  if (Array.isArray(names)) {\n    for (const name of names) ranks.set(name, rank++)\n  } else if (names instanceof Set) {\n    for (const name of names) ranks.set(name, rank++)\n  } else {\n    for (const name in names as Readonly<Record<string, unknown>>) {\n      ranks.set(name, rank++)\n    }\n  }\n  return ranks\n}\n\nfunction withinCategoryRank(\n  modifier: string,\n  kind: Exclude<ModifierKind, 'platform'>,\n  order: ClausePrecedenceOrder\n): number {\n  if (kind === 'media') return order.get(modifier) ?? 0\n  if (kind === 'container') {\n    const container = parseContainerModifier(modifier)\n    return container ? (order.get(container.size) ?? 0) : 0\n  }\n  if (kind === 'theme') return 0\n  if (kind === 'group') {\n    const group = parseGroupModifier(modifier)\n    return group ? (stateRanks[group.state] ?? 0) : 0\n  }\n  return stateRanks[modifier] ?? 0\n}\n\n/** Order-insensitive set key used by every clause merge/emission slot. */\nexport function clauseConditionSetKey(modifiers: readonly string[]): string {\n  if (modifiers.length === 0) return ''\n  if (modifiers.length === 1) return canonicalClauseModifier(modifiers[0])\n  const unique = new Set(modifiers.map(canonicalClauseModifier))\n  return [...unique].sort().join(':')\n}\n\nexport function getClausePrecedenceKeyFromKinds(\n  modifiers: readonly string[],\n  kinds: readonly (ModifierKind | undefined)[],\n  order: ClausePrecedenceOrder\n): ClausePrecedenceKey {\n  let platformRank = 0\n  let categoryRank = 0\n  let highestWithinCategoryRank = 0\n  const nonPlatform = new Set<string>()\n\n  for (let index = 0; index < modifiers.length; index++) {\n    const modifier = canonicalClauseModifier(modifiers[index])\n    const kind = kinds[index]\n    if (!kind) continue\n    if (kind === 'platform') {\n      platformRank = Math.max(platformRank, grammarPlatformRank(modifier))\n      continue\n    }\n\n    nonPlatform.add(modifier)\n    const nextCategoryRank = categoryRanks[kind]\n    const nextWithinCategoryRank = withinCategoryRank(modifier, kind, order)\n    if (nextCategoryRank > categoryRank) {\n      categoryRank = nextCategoryRank\n      highestWithinCategoryRank = nextWithinCategoryRank\n    } else if (nextCategoryRank === categoryRank) {\n      highestWithinCategoryRank = Math.max(\n        highestWithinCategoryRank,\n        nextWithinCategoryRank\n      )\n    }\n  }\n\n  const depth = nonPlatform.size\n  if (depth > grammarMaxNonPlatformDepth) {\n    throw new Error(\n      `a flat value clause supports at most ${grammarMaxNonPlatformDepth} non-platform conditions; received ${depth} in \"${modifiers.join(':')}:\"`\n    )\n  }\n\n  return [platformRank, depth, categoryRank, highestWithinCategoryRank]\n}\n\nexport function getClausePrecedenceKey(\n  modifiers: readonly string[],\n  registry: ModifierRegistryView,\n  order: ClausePrecedenceOrder\n): ClausePrecedenceKey {\n  const kinds: (ModifierKind | undefined)[] = []\n  for (let index = 0; index < modifiers.length; index++) {\n    kinds.push(registry.get(modifiers[index]))\n  }\n  return getClausePrecedenceKeyFromKinds(modifiers, kinds, order)\n}\n\n/** Ascending comparator: a positive result means `left` wins over `right`. */\nexport function compareClausePrecedence(\n  left: ClausePrecedenceKey,\n  right: ClausePrecedenceKey\n): number {\n  for (let index = 0; index < 4; index++) {\n    const difference = left[index] - right[index]\n    if (difference) return difference\n  }\n  return 0\n}\n\n/** Target CSS class specificity, excluding IDs/elements: (0, result, 0). */\nexport function clauseTargetClassSpecificity(key: ClausePrecedenceKey): number {\n  return 1 + key[1] + key[0] * (grammarMaxNonPlatformDepth + 1)\n}\n\n/**\n * Subject-class repetitions needed after self-state selectors contribute\n * their pseudo/attribute specificity naturally. Theme and group scopes use\n * :where(), while media/container wrappers contribute zero.\n */\nexport function clauseSubjectClassRepetitions(\n  key: ClausePrecedenceKey,\n  selfStateSpecificity: number\n): number {\n  return clauseTargetClassSpecificity(key) - selfStateSpecificity\n}\n"
+  ]
+}

package/types/clauseSources.d.ts

@@ -0,0 +1,12 @@
+/**
+* states the native evaluator can source from component state and lifecycle.
+* component-tier states stay web-only until their behavior packages feed them
+* into component state.
+*/
+export declare const nativeSourceableStates: ReadonlySet<string>;
+/**
+* states a group clause can source natively through componentState.group.
+*/
+export declare const nativeGroupSourceableStates: readonly string[];
+
+//# sourceMappingURL=clauseSources.d.ts.map

package/types/clauseSources.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": ";;;;;AAKA,OAAO,cAAM,wBAAwB;;;;AAerC,OAAO,cAAM",
+  "names": [],
+  "sources": [
+    "src/clauseSources.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "/**\n * states the native evaluator can source from component state and lifecycle.\n * component-tier states stay web-only until their behavior packages feed them\n * into component state.\n */\nexport const nativeSourceableStates: ReadonlySet<string> = new Set([\n  'hover',\n  'press',\n  'active',\n  'focus',\n  'focus-visible',\n  'focus-within',\n  'disabled',\n  'enter',\n  'exit',\n])\n\n/**\n * states a group clause can source natively through componentState.group.\n */\nexport const nativeGroupSourceableStates: readonly string[] = Object.freeze([\n  'hover',\n  'press',\n  'active',\n  'focus',\n  'focus-visible',\n  'focus-within',\n  'disabled',\n])\n"
+  ]
+}

package/types/config.d.ts

@@ -0,0 +1,44 @@
+import type { GrammarConfigView } from "./candidate";
+type Names = readonly string[] | ReadonlySet<string> | Readonly<Record<string, unknown>>;
+type GrammarFontConfig = {
+	size?: Readonly<Record<string, unknown>>;
+	weight?: Readonly<Record<string, unknown>>;
+	lineHeight?: Readonly<Record<string, unknown>>;
+	letterSpacing?: Readonly<Record<string, unknown>>;
+};
+export type GrammarSourceConfig = {
+	shorthands?: Readonly<Record<string, string>>;
+	media?: Names;
+	themes?: Readonly<Record<string, unknown>>;
+	tokensParsed?: Partial<Record<"space" | "size" | "radius" | "zIndex" | "color", Readonly<Record<string, unknown>>>>;
+	fontsParsed?: Readonly<Record<string, GrammarFontConfig | undefined>>;
+};
+export type CreateGrammarConfigViewOptions = {
+	platformNames?: Names;
+	/** overrides the derived container size set (the web adapter's resolved set) */
+	containerSizeNames?: readonly string[];
+};
+/**
+* The one owner of "does this media query measure a size". A `hover` or
+* `pointer` key measures nothing a container has, so it gets no `@` form.
+* Accepts the query TEXT (`(min-width: 900px)`) or the config's media OBJECT
+* (`{ minWidth: 900 }`) — both spellings of the same fact.
+*/
+export declare function isContainerSizeQuery(query: unknown): boolean;
+export declare const grammarPlatformNames: ReadonlySet<string>;
+export declare const grammarPlatformGroups: ReadonlyMap<string, ReadonlySet<string>>;
+/**
+* Platform clause specificity, mirroring the runtime directStyle ranks: a TV
+* variant beats its base platform, which beats `native`, independent of
+* authored order. Non-platform modifiers never rank.
+*/
+export declare function grammarPlatformRank(modifier: string): number;
+/**
+* Creates the dependency-free config projection consumed by the shared style grammar.
+* Runtime and compiler integrations must classify candidates through this same view so
+* a candidate cannot be claimed by one side and emitted by the other.
+*/
+export declare function createGrammarConfigView(config: GrammarSourceConfig, options?: CreateGrammarConfigViewOptions): GrammarConfigView;
+export {};
+
+//# sourceMappingURL=config.d.ts.map

package/types/config.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAAA,cAAc,yBAAyB;KAGlC,4BAA4B,sBAAsB,SAAS;KAE3D,oBAAoB;CACvB,OAAO,SAAS;CAChB,SAAS,SAAS;CAClB,aAAa,SAAS;CACtB,gBAAgB,SAAS;;AAG3B,YAAY,sBAAsB;CAChC,aAAa,SAAS;CACtB,QAAQ;CACR,SAAS,SAAS;CAClB,eAAe,QACb,OACE,UAAU,SAAS,WAAW,WAAW,SACzC,SAAS;CAGb,cAAc,SAAS,eAAe;;AAGxC,YAAY,iCAAiC;CAC3C,gBAAgB;;CAEhB;;;;;;;;AASF,OAAO,iBAAS,qBAAqB;AAiBrC,OAAO,cAAM,sBAAsB;AAUnC,OAAO,cAAM,uBAAuB,oBAAoB;;;;;;AAcxD,OAAO,iBAAS,oBAAoB;;;;;;AA0BpC,OAAO,iBAAS,wBACd,QAAQ,qBACR,UAAS,iCACR",
+  "names": [],
+  "sources": [
+    "src/config.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "import type { GrammarConfigView } from './candidate'\nimport type { TokenCategory } from './registry'\n\ntype Names = readonly string[] | ReadonlySet<string> | Readonly<Record<string, unknown>>\n\ntype GrammarFontConfig = {\n  size?: Readonly<Record<string, unknown>>\n  weight?: Readonly<Record<string, unknown>>\n  lineHeight?: Readonly<Record<string, unknown>>\n  letterSpacing?: Readonly<Record<string, unknown>>\n}\n\nexport type GrammarSourceConfig = {\n  shorthands?: Readonly<Record<string, string>>\n  media?: Names\n  themes?: Readonly<Record<string, unknown>>\n  tokensParsed?: Partial<\n    Record<\n      'space' | 'size' | 'radius' | 'zIndex' | 'color',\n      Readonly<Record<string, unknown>>\n    >\n  >\n  fontsParsed?: Readonly<Record<string, GrammarFontConfig | undefined>>\n}\n\nexport type CreateGrammarConfigViewOptions = {\n  platformNames?: Names\n  /** overrides the derived container size set (the web adapter's resolved set) */\n  containerSizeNames?: readonly string[]\n}\n\n/**\n * The one owner of \"does this media query measure a size\". A `hover` or\n * `pointer` key measures nothing a container has, so it gets no `@` form.\n * Accepts the query TEXT (`(min-width: 900px)`) or the config's media OBJECT\n * (`{ minWidth: 900 }`) — both spellings of the same fact.\n */\nexport function isContainerSizeQuery(query: unknown): boolean {\n  if (typeof query === 'string') {\n    return (\n      query.includes('width') ||\n      query.includes('height') ||\n      query.includes('inline-size') ||\n      query.includes('block-size')\n    )\n  }\n  if (query && typeof query === 'object') {\n    for (const key in query as Readonly<Record<string, unknown>>) {\n      if (/width|height|size/i.test(key)) return true\n    }\n  }\n  return false\n}\n\nexport const grammarPlatformNames: ReadonlySet<string> = new Set([\n  'web',\n  'native',\n  'android',\n  'ios',\n  'tv',\n  'androidtv',\n  'tvos',\n])\n\nexport const grammarPlatformGroups: ReadonlyMap<string, ReadonlySet<string>> = new Map([\n  ['native', new Set(['android', 'ios', 'androidtv', 'tvos'])],\n  ['tv', new Set(['androidtv', 'tvos'])],\n  // react-native-tvos reports Platform.OS 'android'/'ios' on TV devices, so the\n  // base platform contains its TV variant (matches runtime platformMatches)\n  ['android', new Set(['androidtv'])],\n  ['ios', new Set(['tvos'])],\n])\n\n/**\n * Platform clause specificity, mirroring the runtime directStyle ranks: a TV\n * variant beats its base platform, which beats `native`, independent of\n * authored order. Non-platform modifiers never rank.\n */\nexport function grammarPlatformRank(modifier: string): number {\n  return modifier === 'native' || modifier === 'web'\n    ? 1\n    : modifier === 'androidtv' || modifier === 'tvos'\n      ? 3\n      : 2\n}\n\nfunction addNames(target: Set<string>, source: Names | undefined): void {\n  if (!source) return\n  if (Array.isArray(source)) {\n    for (const key of source) target.add(key)\n    return\n  }\n  if (source instanceof Set) {\n    for (const key of source) target.add(key)\n    return\n  }\n  for (const key in source) target.add(key)\n}\n\n/**\n * Creates the dependency-free config projection consumed by the shared style grammar.\n * Runtime and compiler integrations must classify candidates through this same view so\n * a candidate cannot be claimed by one side and emitted by the other.\n */\nexport function createGrammarConfigView(\n  config: GrammarSourceConfig,\n  options: CreateGrammarConfigViewOptions = {}\n): GrammarConfigView {\n  const tokenNames: Record<TokenCategory, Set<string>> = {\n    space: new Set(),\n    size: new Set(),\n    radius: new Set(),\n    zIndex: new Set(),\n    color: new Set(),\n    fontFamily: new Set(),\n    fontSize: new Set(),\n    fontWeight: new Set(),\n    lineHeight: new Set(),\n    letterSpacing: new Set(),\n  }\n\n  for (const category of ['space', 'size', 'radius', 'zIndex', 'color'] as const) {\n    addNames(tokenNames[category], config.tokensParsed?.[category])\n  }\n\n  for (const themeName in config.themes) {\n    const theme = config.themes[themeName]\n    if (theme && typeof theme === 'object' && !Array.isArray(theme)) {\n      addNames(tokenNames.color, theme as Readonly<Record<string, unknown>>)\n    }\n  }\n\n  for (const familyName in config.fontsParsed) {\n    tokenNames.fontFamily.add(familyName)\n    const font = config.fontsParsed[familyName]\n    addNames(tokenNames.fontSize, font?.size)\n    addNames(tokenNames.fontWeight, font?.weight)\n    addNames(tokenNames.lineHeight, font?.lineHeight)\n    addNames(tokenNames.letterSpacing, font?.letterSpacing)\n  }\n\n  // container size derivation needs query information, which only the\n  // record form of `media` carries (values are media objects or query text).\n  // a bare name list stays undefined = unknown, and the modifier registry\n  // refuses container claims for it rather than guessing\n  let containerSizeNames = options.containerSizeNames\n  if (\n    containerSizeNames === undefined &&\n    config.media &&\n    !Array.isArray(config.media) &&\n    !(config.media instanceof Set)\n  ) {\n    const derived: string[] = []\n    const media = config.media as Readonly<Record<string, unknown>>\n    for (const key in media) {\n      if (isContainerSizeQuery(media[key])) derived.push(key)\n    }\n    containerSizeNames = derived\n  }\n\n  return {\n    shorthands: config.shorthands,\n    mediaNames: config.media,\n    themeNames: config.themes,\n    platformNames: options.platformNames ?? grammarPlatformNames,\n    tokenNames,\n    containerSizeNames,\n  }\n}\n"
+  ]
+}

package/types/evaluateProgram.d.ts

@@ -0,0 +1,27 @@
+import { type ClausePrecedenceOrder } from "./clausePrecedence";
+import type { ModifierRegistryView, ParsedValue } from "./valueTypes";
+export interface ActiveConditions {
+	states: ReadonlySet<string>;
+	themes: ReadonlySet<string>;
+	media: ReadonlySet<string>;
+	/** config declaration order; falls back to `media` insertion order in tests */
+	mediaOrder?: ClausePrecedenceOrder;
+	platform: string;
+	groups: (modifier: string) => boolean;
+	/**
+	* whether a container query modifier (`@sm`, `@sm/card`) currently holds.
+	* Like groups, this is a callback because the answer lives with the component
+	* tree: resolving it needs the measured size of the nearest or named
+	* container, whose measurement timing is its own design item.
+	*/
+	containers: (modifier: string) => boolean;
+}
+/**
+* Resolves a program to one payload using the shared fixed precedence key.
+* Authored order only breaks exact-key ties, so a later restatement of the
+* same normalized condition set wins while distinct condition sets are stable
+* under reordering.
+*/
+export declare function evaluateProgram(value: ParsedValue, registry: ModifierRegistryView, active: ActiveConditions): string | null;
+
+//# sourceMappingURL=evaluateProgram.d.ts.map

package/types/evaluateProgram.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AACA,cAMO,6BACA;AACP,cAA4B,sBAAsB,mBAAmB;AAErE,iBAAiB,iBAAiB;CAChC,QAAQ;CACR,QAAQ;CACR,OAAO;;CAEP,aAAa;CACb;CACA,SAAS;;;;;;;CAOT,aAAa;;;;;;;;AASf,OAAO,iBAAS,gBACd,OAAO,aACP,UAAU,sBACV,QAAQ",
+  "names": [],
+  "sources": [
+    "src/evaluateProgram.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "import { grammarPlatformGroups } from './config'\nimport {\n  canonicalClauseModifier,\n  compareClausePrecedence,\n  createClausePrecedenceOrder,\n  getClausePrecedenceKeyFromKinds,\n  type ClausePrecedenceKey,\n  type ClausePrecedenceOrder,\n} from './clausePrecedence'\nimport type { ModifierKind, ModifierRegistryView, ParsedValue } from './valueTypes'\n\nexport interface ActiveConditions {\n  states: ReadonlySet<string>\n  themes: ReadonlySet<string>\n  media: ReadonlySet<string>\n  /** config declaration order; falls back to `media` insertion order in tests */\n  mediaOrder?: ClausePrecedenceOrder\n  platform: string\n  groups: (modifier: string) => boolean\n  /**\n   * whether a container query modifier (`@sm`, `@sm/card`) currently holds.\n   * Like groups, this is a callback because the answer lives with the component\n   * tree: resolving it needs the measured size of the nearest or named\n   * container, whose measurement timing is its own design item.\n   */\n  containers: (modifier: string) => boolean\n}\n\n/**\n * Resolves a program to one payload using the shared fixed precedence key.\n * Authored order only breaks exact-key ties, so a later restatement of the\n * same normalized condition set wins while distinct condition sets are stable\n * under reordering.\n */\nexport function evaluateProgram(\n  value: ParsedValue,\n  registry: ModifierRegistryView,\n  active: ActiveConditions\n): string | null {\n  let payload: string | null = null\n  let found = false\n  let best: ClausePrecedenceKey | undefined\n  const order = active.mediaOrder ?? createClausePrecedenceOrder(active.media)\n\n  for (let clauseIndex = 0; clauseIndex < value.clauses.length; clauseIndex++) {\n    const clause = value.clauses[clauseIndex]\n    let matches = true\n    const kinds: (ModifierKind | undefined)[] = []\n\n    for (\n      let modifierIndex = 0;\n      modifierIndex < clause.modifiers.length;\n      modifierIndex++\n    ) {\n      const modifier = canonicalClauseModifier(clause.modifiers[modifierIndex])\n      const kind = registry.get(modifier)\n      kinds.push(kind)\n\n      if (kind === 'state') {\n        matches = active.states.has(modifier)\n      } else if (kind === 'theme') {\n        matches = active.themes.has(modifier)\n      } else if (kind === 'media') {\n        matches = active.media.has(modifier)\n      } else if (kind === 'platform') {\n        matches =\n          modifier === active.platform ||\n          (grammarPlatformGroups.get(modifier)?.has(active.platform) ?? false)\n      } else if (kind === 'group') {\n        matches = active.groups(modifier)\n      } else if (kind === 'container') {\n        matches = active.containers(modifier)\n      } else {\n        matches = false\n      }\n\n      if (!matches) break\n    }\n\n    if (!matches) continue\n\n    const precedence = getClausePrecedenceKeyFromKinds(clause.modifiers, kinds, order)\n    if (best && compareClausePrecedence(precedence, best) < 0) continue\n\n    payload = clause.payload\n    best = precedence\n    found = true\n  }\n\n  return found ? payload : value.base\n}\n"
+  ]
+}

package/types/fontShorthand.d.ts

@@ -0,0 +1,25 @@
+import type { ParsedValue } from "./valueTypes";
+interface FontShorthandTargets {
+	style: readonly string[];
+	weight: readonly string[];
+	size: readonly string[];
+	lineHeight: readonly string[];
+	family: readonly string[];
+}
+/** authored prop -> the true longhands each component kind lands on */
+export declare const fontShorthandTargets: Readonly<Record<string, FontShorthandTargets>>;
+export interface FontShorthandError {
+	code: "unsupported-font-component";
+	component: string;
+	where: "base" | number;
+}
+export declare function splitFontValue(value: ParsedValue): {
+	entries: Array<{
+		property: string;
+		value: ParsedValue;
+	}>;
+	errors: FontShorthandError[];
+};
+export {};
+
+//# sourceMappingURL=fontShorthand.d.ts.map

package/types/fontShorthand.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAYA,cAA4B,mBAAmB;UAErC,qBAAqB;CAC7B;CACA;CACA;CACA;CACA;;;AAIF,OAAO,cAAM,sBAAsB,SAAS,eAAe;AAqC3D,iBAAiB,mBAAmB;CAClC,MAAM;CACN;CACA,OAAO;;AAWT,OAAO,iBAAS,eAAe,OAAO,cAAc;CAClD,SAAS,MAAM;EAAE;EAAkB,OAAO;;CAC1C,QAAQ",
+  "names": [],
+  "sources": [
+    "src/fontShorthand.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "// The font shorthand: value-dependent splitting of the resetting CSS `font`\n// shorthand into per-longhand programs, completing the family model. The\n// micro-syntax is positional — optional style/weight components, then the\n// size (optionally `size/line-height`), then the family tail, which is joined\n// verbatim so comma lists and quoted names survive.\n//\n// Conservative by design: ambiguous or unsupported components (`normal`,\n// `small-caps`, stretch keywords, system font keywords, size keywords) error\n// so the whole value stays on the legacy path rather than converting into a\n// subtly different meaning.\n\nimport { splitTopLevelComponents } from './backgroundFamily'\nimport type { ParsedClause, ParsedValue } from './valueTypes'\n\ninterface FontShorthandTargets {\n  style: readonly string[]\n  weight: readonly string[]\n  size: readonly string[]\n  lineHeight: readonly string[]\n  family: readonly string[]\n}\n\n/** authored prop -> the true longhands each component kind lands on */\nexport const fontShorthandTargets: Readonly<Record<string, FontShorthandTargets>> = {\n  font: {\n    style: ['fontStyle'],\n    weight: ['fontWeight'],\n    size: ['fontSize'],\n    lineHeight: ['lineHeight'],\n    family: ['fontFamily'],\n  },\n}\n\nconst styleKeywords = new Set(['italic', 'oblique'])\nconst weightKeywords = new Set(['bold', 'bolder', 'lighter'])\n// `normal` is ambiguous (style, variant, or weight), and these have no\n// cross-platform longhand contribution\nconst unsupportedKeywords = new Set([\n  'normal',\n  'small-caps',\n  'ultra-condensed',\n  'extra-condensed',\n  'condensed',\n  'semi-condensed',\n  'semi-expanded',\n  'expanded',\n  'extra-expanded',\n  'ultra-expanded',\n  // system font keywords have no longhand equivalent at all\n  'caption',\n  'icon',\n  'menu',\n  'message-box',\n  'small-caption',\n  'status-bar',\n])\n\nconst sizePattern = /^-?(\\d+\\.?\\d*|\\.\\d+)(?:[a-z%]+)?$/i\nconst weightNumberPattern = /^[1-9]00$/\n\nexport interface FontShorthandError {\n  code: 'unsupported-font-component'\n  component: string\n  where: 'base' | number\n}\n\ntype FontKind = keyof FontShorthandTargets\n\ninterface MutableProgram {\n  base: string | null\n  clauses: ParsedClause[]\n  present: boolean\n}\n\nexport function splitFontValue(value: ParsedValue): {\n  entries: Array<{ property: string; value: ParsedValue }>\n  errors: FontShorthandError[]\n} {\n  const targets = fontShorthandTargets.font\n  const errors: FontShorthandError[] = []\n  const kinds: readonly FontKind[] = ['style', 'weight', 'size', 'lineHeight', 'family']\n  const programs: Record<FontKind, MutableProgram> = {\n    style: { base: null, clauses: [], present: false },\n    weight: { base: null, clauses: [], present: false },\n    size: { base: null, clauses: [], present: false },\n    lineHeight: { base: null, clauses: [], present: false },\n    family: { base: null, clauses: [], present: false },\n  }\n\n  for (let clauseIndex = -1; clauseIndex < value.clauses.length; clauseIndex++) {\n    const isBase = clauseIndex === -1\n    const payload = isBase ? value.base : value.clauses[clauseIndex].payload\n    if (payload === null) continue\n    const where = isBase ? ('base' as const) : clauseIndex\n\n    const components = splitTopLevelComponents(payload)\n    const found: Partial<Record<FontKind, string>> = {}\n    let sizeIndex = -1\n\n    for (let index = 0; index < components.length; index++) {\n      const component = components[index]\n      const lower = component.toLowerCase()\n      if (unsupportedKeywords.has(lower)) {\n        errors.push({ code: 'unsupported-font-component', component, where })\n        continue\n      }\n      if (styleKeywords.has(lower)) {\n        if (found.style !== undefined) {\n          errors.push({ code: 'unsupported-font-component', component, where })\n          continue\n        }\n        found.style = component\n        continue\n      }\n      if (weightKeywords.has(lower) || weightNumberPattern.test(component)) {\n        if (found.weight !== undefined) {\n          errors.push({ code: 'unsupported-font-component', component, where })\n          continue\n        }\n        found.weight = component\n        continue\n      }\n      const slash = component.indexOf('/')\n      const sizePart = slash === -1 ? component : component.slice(0, slash)\n      if (sizePattern.test(sizePart)) {\n        if (found.size !== undefined) {\n          errors.push({ code: 'unsupported-font-component', component, where })\n          continue\n        }\n        found.size = sizePart\n        if (slash !== -1) found.lineHeight = component.slice(slash + 1)\n        sizeIndex = index\n        // everything after the size is the family, joined verbatim\n        const family = components.slice(index + 1).join(' ')\n        if (family) found.family = family\n        break\n      }\n      // a component before the size that nothing classified\n      errors.push({ code: 'unsupported-font-component', component, where })\n    }\n\n    if (sizeIndex === -1) {\n      errors.push({\n        code: 'unsupported-font-component',\n        component: payload,\n        where,\n      })\n    }\n\n    for (const kind of kinds) {\n      const component = found[kind]\n      if (component === undefined) continue\n      const program = programs[kind]\n      program.present = true\n      if (isBase) {\n        program.base = component\n      } else {\n        program.clauses.push({\n          modifiers: value.clauses[clauseIndex].modifiers,\n          payload: component,\n        })\n      }\n    }\n  }\n\n  const entries: Array<{ property: string; value: ParsedValue }> = []\n  for (const kind of kinds) {\n    const program = programs[kind]\n    if (!program.present) continue\n    const shared: ParsedValue = { base: program.base, clauses: program.clauses }\n    for (const longhand of targets[kind]) {\n      entries.push({ property: longhand, value: shared })\n    }\n  }\n\n  return { entries, errors }\n}\n"
+  ]
+}

package/types/geometricShorthand.d.ts

@@ -0,0 +1,21 @@
+import type { ParsedValue } from "./valueTypes";
+export interface GeometricShorthandError {
+	code: "unsupported-geometric-payload";
+	payload: string;
+	where: "base" | number;
+}
+/**
+* Splits a geometric shorthand's parsed program into per-longhand programs by
+* slot. Returns null when `prop` is not a geometric shorthand, or when every
+* payload is single-component (nothing to distribute — the caller's ordinary
+* expansion handles that identically and cheaper).
+*/
+export declare function splitGeometricShorthandValue(prop: string, value: ParsedValue): {
+	entries: Array<{
+		property: string;
+		value: ParsedValue;
+	}>;
+	errors: GeometricShorthandError[];
+} | null;
+
+//# sourceMappingURL=geometricShorthand.d.ts.map

package/types/geometricShorthand.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAeA,cAA4B,mBAAmB;AAS/C,iBAAiB,wBAAwB;CACvC,MAAM;CACN;CACA,OAAO;;;;;;;;AAST,OAAO,iBAAS,6BACd,cACA,OAAO,cACN;CACD,SAAS,MAAM;EAAE;EAAkB,OAAO;;CAC1C,QAAQ",
+  "names": [],
+  "sources": [
+    "src/geometricShorthand.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "// Geometric shorthand slot semantics for program values (design record,\n// \"Bare numbers resolve config-first ... and per component value:\n// `p=\"4 8\"` resolves both\"). A multi-component payload on a geometric\n// shorthand distributes by the CSS slot pattern — sides alternate for two\n// values, three values mirror the second, four map directly — producing one\n// SINGLE-component program per longhand. Without this, every side received\n// the whole multi-value payload and the browser dropped the declaration\n// silently.\n//\n// Function values and slash syntax (`borderRadius=\"8px / 4px\"`) do not\n// distribute faithfully and return an error, which keeps the value on the\n// single-program path where the payload-shape diagnostic reports it.\n\nimport { splitTopLevelComponents } from './backgroundFamily'\nimport { longhandExpansionTable } from './programs'\nimport type { ParsedClause, ParsedValue } from './valueTypes'\n\n// identical index patterns for box sides (T/R/B/L) and radius corners\n// (TL/TR/BR/BL); two-slot pairs (horizontal/vertical, gap) take one or two\nconst slotPatterns: Record<number, Record<number, readonly number[]>> = {\n  4: { 1: [0, 0, 0, 0], 2: [0, 1, 0, 1], 3: [0, 1, 2, 1], 4: [0, 1, 2, 3] },\n  2: { 1: [0, 0], 2: [0, 1] },\n}\n\nexport interface GeometricShorthandError {\n  code: 'unsupported-geometric-payload'\n  payload: string\n  where: 'base' | number\n}\n\n/**\n * Splits a geometric shorthand's parsed program into per-longhand programs by\n * slot. Returns null when `prop` is not a geometric shorthand, or when every\n * payload is single-component (nothing to distribute — the caller's ordinary\n * expansion handles that identically and cheaper).\n */\nexport function splitGeometricShorthandValue(\n  prop: string,\n  value: ParsedValue\n): {\n  entries: Array<{ property: string; value: ParsedValue }>\n  errors: GeometricShorthandError[]\n} | null {\n  const longhands = longhandExpansionTable[prop]\n  if (!longhands) return null\n  const patterns = slotPatterns[longhands.length]\n  if (!patterns) return null\n\n  // fast path: nothing multi-component, nothing to do\n  let hasMulti = false\n  const payloadComponents: string[][] = []\n  for (let index = -1; index < value.clauses.length; index++) {\n    const payload = index === -1 ? value.base : value.clauses[index].payload\n    if (payload === null) {\n      payloadComponents.push([])\n      continue\n    }\n    if (payload.includes('/')) return null\n    const components = splitTopLevelComponents(payload)\n    payloadComponents.push(components)\n    if (components.length > 1) hasMulti = true\n  }\n  if (!hasMulti) return null\n\n  const errors: GeometricShorthandError[] = []\n  // per longhand: pick this slot's component from every payload\n  const perLonghand: Array<{ base: string | null; clauses: ParsedClause[] }> =\n    longhands.map(() => ({ base: null, clauses: [] }))\n\n  for (let index = -1; index < value.clauses.length; index++) {\n    const payload = index === -1 ? value.base : value.clauses[index].payload\n    if (payload === null) continue\n    const components = payloadComponents[index + 1]\n    const pattern = patterns[components.length]\n    if (!pattern) {\n      errors.push({\n        code: 'unsupported-geometric-payload',\n        payload,\n        where: index === -1 ? 'base' : index,\n      })\n      continue\n    }\n    for (let slot = 0; slot < longhands.length; slot++) {\n      const component = components[pattern[slot]]\n      if (index === -1) {\n        perLonghand[slot].base = component\n      } else {\n        perLonghand[slot].clauses.push({\n          modifiers: value.clauses[index].modifiers,\n          payload: component,\n        })\n      }\n    }\n  }\n\n  if (errors.length) return { entries: [], errors }\n\n  return {\n    entries: longhands.map((longhand, slot) => ({\n      property: longhand,\n      value: { base: perLonghand[slot].base, clauses: perLonghand[slot].clauses },\n    })),\n    errors,\n  }\n}\n"
+  ]
+}

package/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./runtime";
+
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAAA,cAAc",
+  "names": [],
+  "sources": [
+    "src/index.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "export * from './runtime'\n"
+  ]
+}

package/types/lowerProgram.d.ts

@@ -0,0 +1,73 @@
+import { type ClausePrecedenceOrder } from "./clausePrecedence";
+import type { LonghandProgram, ModifierRegistryView } from "./valueTypes";
+/**
+* Where a condition's selector fragment is matched, relative to the subject: on
+* the subject itself, strictly above it, or either.
+*/
+export type ConditionScope = "self" | "within" | "is-or-within";
+export interface ConditionSelector {
+	/** compound selector piece, eg `:hover`, `.t_dark`, `[aria-disabled]` */
+	fragment: string;
+	/** defaults to `self` */
+	scope?: ConditionScope;
+	/**
+	* capability guard the rule must nest in, eg `(hover: hover)` so touch
+	* devices never sticky-trigger hover styles
+	*/
+	media?: string;
+}
+/**
+* Interaction-state selector spellings: `disabled` is an attribute rather than
+* `:disabled`, and enter matches the unmounted class on the subject or above it.
+* Mirrored as data instead of imported because this package must not depend on
+* @tamagui/web.
+*
+* Lifecycle clauses use classes supplied by createComponent. `is-or-within`
+* lets a presence boundary carry the lifecycle state for descendants too.
+*/
+export declare const defaultStateSelectors: Readonly<Record<string, ConditionSelector>>;
+export interface LowerProgramOptions {
+	/** classifies each modifier; the same registry the value was parsed against */
+	registry: ModifierRegistryView;
+	/** opaque stamp for the resolved config that produced these payloads */
+	configRevision: string;
+	/** media key -> the `@media` condition text, eg `(max-width: 860px)` */
+	mediaQueries?: Readonly<Record<string, string>>;
+	/**
+	* media key -> the `@container` condition text, eg `(min-width: 24rem)`. Sizes
+	* are the same keys as `mediaQueries`, but the query text differs: container
+	* queries measure the container, not the viewport, so the caller derives both
+	* from config.
+	*/
+	containerQueries?: Readonly<Record<string, string>>;
+	/** modifier -> selector, defaults to `defaultStateSelectors` */
+	stateSelectors?: Readonly<Record<string, ConditionSelector>>;
+	/** precomputed media declaration order; derived from mediaQueries by default */
+	precedenceOrder?: ClausePrecedenceOrder;
+	/** theme class prefix; `t_` gives `.t_dark` */
+	themeClassPrefix?: string;
+	/** group class prefix; `t_group_` gives `.t_group_card` */
+	groupClassPrefix?: string;
+}
+export interface LoweredProgram {
+	className: string;
+	/** base rule first, then one rule per emitted clause in precedence order */
+	rules: string[];
+	/**
+	* Present when the program writes a per-axis custom property (`x`, `y`,
+	* `scaleX`, `scaleY`). The composing rule turns the axis variables into the
+	* real CSS property and is identical for every element using that axis group,
+	* so it carries its own class name and hash: the caller adds this class too and
+	* insertion dedups it to one rule per sheet. Its specificity is the same
+	* (0,1,0) as every other rule here.
+	*/
+	composition?: {
+		/** the CSS property being composed, and the classNames key to store it under */
+		property: string;
+		className: string;
+		rules: string[];
+	};
+}
+export declare function lowerProgram(program: LonghandProgram, options: LowerProgramOptions): LoweredProgram;
+
+//# sourceMappingURL=lowerProgram.d.ts.map

package/types/lowerProgram.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAyBA,cAOO,6BACA;AAIP,cAAc,iBAAiB,4BAA4B;;;;;AAM3D,YAAY,iBAAiB,SAAS,WAAW;AAEjD,iBAAiB,kBAAkB;;CAEjC;;CAEA,QAAQ;;;;;CAKR;;;;;;;;;;;AAYF,OAAO,cAAM,uBAAuB,SAAS,eAAe;AAoC5D,iBAAiB,oBAAoB;;CAEnC,UAAU;;CAEV;;CAEA,eAAe,SAAS;;;;;;;CAOxB,mBAAmB,SAAS;;CAE5B,iBAAiB,SAAS,eAAe;;CAEzC,kBAAkB;;CAElB;;CAEA;;AAGF,iBAAiB,eAAe;CAC9B;;CAEA;;;;;;;;;CASA,cAAc;;EAEZ;EACA;EACA;;;AA6CJ,OAAO,iBAAS,aACd,SAAS,iBACT,SAAS,sBACR",
+  "names": [],
+  "sources": [
+    "src/lowerProgram.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "// Web lowering: one program becomes one contiguous block of CSS rules.\n//\n// See plans/dom-tailwind-flat-values.md — \"The program block encoding\". The\n// invariants this file exists to hold:\n//\n// - every condition anchors on the subject class, Tailwind-group style, so a\n//   clause is exactly ONE selector: conditions chain as `:where()` on the\n//   subject in authored modifier order. Ancestor-scoped conditions become a\n//   descendant test inside their own `:where()` (`.t_dark *`), which makes each\n//   one independent, so nesting order between them never matters and no\n//   ancestor-permutation selectors exist;\n// - rule order is ascending clause precedence; selector specificity encodes\n//   depth, while platform clauses receive a floor above the maximum\n//   non-platform depth. Self states contribute naturally; media/container\n//   wrappers and :where()-scoped theme/group ancestors contribute zero;\n// - the block is inserted contiguously, so cross-program order never matters and\n//   append-at-end is always safe.\n//\n// Payloads are emitted verbatim. Token resolution, opacity composition, and\n// value validation all happen upstream: this layer receives CSS-ready payloads,\n// and the same resolved program is what the class name hashes, so a program has\n// exactly one identity. Rule injection through a payload is structurally\n// impossible because the parser rejects a top-level `{`, `}`, or `;`.\n\nimport { parseContainerModifier, parseGroupModifier } from './modifierRegistry'\nimport {\n  canonicalClauseModifier,\n  clauseConditionSetKey,\n  clauseSubjectClassRepetitions,\n  compareClausePrecedence,\n  createClausePrecedenceOrder,\n  getClausePrecedenceKey,\n  type ClausePrecedenceOrder,\n} from './clausePrecedence'\nimport { transformAxisCompositions } from './transformFamily'\nimport { programClassName } from './programHash'\nimport { stateToSelector } from './states'\nimport type { LonghandProgram, ModifierRegistryView } from './valueTypes'\n\n/**\n * Where a condition's selector fragment is matched, relative to the subject: on\n * the subject itself, strictly above it, or either.\n */\nexport type ConditionScope = 'self' | 'within' | 'is-or-within'\n\nexport interface ConditionSelector {\n  /** compound selector piece, eg `:hover`, `.t_dark`, `[aria-disabled]` */\n  fragment: string\n  /** defaults to `self` */\n  scope?: ConditionScope\n  /**\n   * capability guard the rule must nest in, eg `(hover: hover)` so touch\n   * devices never sticky-trigger hover styles\n   */\n  media?: string\n}\n\n/**\n * Interaction-state selector spellings: `disabled` is an attribute rather than\n * `:disabled`, and enter matches the unmounted class on the subject or above it.\n * Mirrored as data instead of imported because this package must not depend on\n * @tamagui/web.\n *\n * Lifecycle clauses use classes supplied by createComponent. `is-or-within`\n * lets a presence boundary carry the lifecycle state for descendants too.\n */\nexport const defaultStateSelectors: Readonly<Record<string, ConditionSelector>> =\n  Object.freeze({\n    hover: { fragment: ':hover', media: '(hover: hover)' },\n    // the press modifier's CSS pseudo name is `active`\n    press: { fragment: ':active' },\n    // the registered alias of press\n    active: { fragment: ':active' },\n    focus: { fragment: ':focus' },\n    'focus-visible': { fragment: ':focus-visible' },\n    'focus-within': { fragment: ':focus-within' },\n    disabled: { fragment: '[aria-disabled]' },\n    enter: { fragment: '.t_unmounted', scope: 'is-or-within' },\n    exit: { fragment: '.t_exiting', scope: 'is-or-within' },\n    // component-tier states, from the shared state vocabulary's web selectors\n    ...(Object.fromEntries(\n      Object.entries(stateToSelector).map(([state, selector]) => [\n        state,\n        { fragment: selector },\n      ])\n    ) as Record<string, ConditionSelector>),\n  })\n\n// core writes the unnamed group's class as `t_group_true`, from the boolean\n// `group` prop (see getSplitStyles' group class name construction)\nconst unnamedGroup = 'true'\n\n// a capability guard (hover: hover) wraps once even when the subject and a\n// group both carry the hover state in one clause\nfunction pushCapabilityGuard(wrappers: string[], media: string): void {\n  const guard = `@media ${media}`\n  for (let index = 0; index < wrappers.length; index++) {\n    if (wrappers[index] === guard) return\n  }\n  wrappers.push(guard)\n}\n\nexport interface LowerProgramOptions {\n  /** classifies each modifier; the same registry the value was parsed against */\n  registry: ModifierRegistryView\n  /** opaque stamp for the resolved config that produced these payloads */\n  configRevision: string\n  /** media key -> the `@media` condition text, eg `(max-width: 860px)` */\n  mediaQueries?: Readonly<Record<string, string>>\n  /**\n   * media key -> the `@container` condition text, eg `(min-width: 24rem)`. Sizes\n   * are the same keys as `mediaQueries`, but the query text differs: container\n   * queries measure the container, not the viewport, so the caller derives both\n   * from config.\n   */\n  containerQueries?: Readonly<Record<string, string>>\n  /** modifier -> selector, defaults to `defaultStateSelectors` */\n  stateSelectors?: Readonly<Record<string, ConditionSelector>>\n  /** precomputed media declaration order; derived from mediaQueries by default */\n  precedenceOrder?: ClausePrecedenceOrder\n  /** theme class prefix; `t_` gives `.t_dark` */\n  themeClassPrefix?: string\n  /** group class prefix; `t_group_` gives `.t_group_card` */\n  groupClassPrefix?: string\n}\n\nexport interface LoweredProgram {\n  className: string\n  /** base rule first, then one rule per emitted clause in precedence order */\n  rules: string[]\n  /**\n   * Present when the program writes a per-axis custom property (`x`, `y`,\n   * `scaleX`, `scaleY`). The composing rule turns the axis variables into the\n   * real CSS property and is identical for every element using that axis group,\n   * so it carries its own class name and hash: the caller adds this class too and\n   * insertion dedups it to one rule per sheet. Its specificity is the same\n   * (0,1,0) as every other rule here.\n   */\n  composition?: {\n    /** the CSS property being composed, and the classNames key to store it under */\n    property: string\n    className: string\n    rules: string[]\n  }\n}\n\nfunction hyphenate(property: string): string {\n  let out = ''\n  for (let index = 0; index < property.length; index++) {\n    const code = property.charCodeAt(index)\n    out +=\n      code >= 65 && code <= 90 ? `-${property[index].toLowerCase()}` : property[index]\n  }\n  return out\n}\n\nfunction conditionSelector(\n  fragment: string,\n  scope: ConditionScope,\n  zeroSpecificity: boolean\n): string {\n  const pseudo = zeroSpecificity ? 'where' : 'is'\n  if (scope === 'within') return `:${pseudo}(${fragment} *)`\n  if (scope === 'is-or-within') {\n    return `:${pseudo}(${fragment}, ${fragment} *)`\n  }\n  return zeroSpecificity ? `:where(${fragment})` : fragment\n}\n\ntype PointerEventsMode = 'auto' | 'none' | 'box-none' | 'box-only'\n\nfunction isPointerEventsMode(value: string): value is PointerEventsMode {\n  return (\n    value === 'auto' || value === 'none' || value === 'box-none' || value === 'box-only'\n  )\n}\n\nfunction pointerEventsCSS(mode: PointerEventsMode): {\n  subject: 'auto' | 'none'\n  children: 'auto' | 'none'\n} {\n  return {\n    subject: mode === 'none' || mode === 'box-none' ? 'none' : 'auto',\n    children: mode === 'none' || mode === 'box-only' ? 'none' : 'auto',\n  }\n}\n\nexport function lowerProgram(\n  program: LonghandProgram,\n  options: LowerProgramOptions\n): LoweredProgram {\n  const {\n    registry,\n    configRevision,\n    mediaQueries,\n    containerQueries,\n    stateSelectors = defaultStateSelectors,\n    precedenceOrder = createClausePrecedenceOrder(mediaQueries),\n    themeClassPrefix = 't_',\n    groupClassPrefix = 't_group_',\n  } = options\n\n  const className = programClassName(program.property, program.value, configRevision)\n  const declaration = hyphenate(program.property)\n  const rules: string[] = []\n\n  // React Native's box-only/box-none values need a subject rule and a direct-child\n  // rule. If either appears in a program, every clause emits both halves so moving\n  // between (for example) box-none and none cannot leave the base child rule active.\n  const pointerEventsProgram =\n    program.property === 'pointerEvents' &&\n    [program.value.base, ...program.value.clauses.map((clause) => clause.payload)].some(\n      (value) => value === 'box-none' || value === 'box-only'\n    )\n\n  const pushRule = (selector: string, wrappers: readonly string[], value: string) => {\n    if (pointerEventsProgram && isPointerEventsMode(value)) {\n      const pointerEvents = pointerEventsCSS(value)\n      rules.push(\n        wrapAtRules(`${selector}{${declaration}:${pointerEvents.subject}}`, wrappers)\n      )\n      rules.push(\n        wrapAtRules(`${selector}>*{${declaration}:${pointerEvents.children}}`, wrappers)\n      )\n      return\n    }\n    rules.push(wrapAtRules(`${selector}{${declaration}:${value}}`, wrappers))\n  }\n\n  if (program.value.base !== null) {\n    pushRule(`.${className}`, [], program.value.base)\n  }\n\n  const clauseSlots = new Map<\n    string,\n    { clause: (typeof program.value.clauses)[number]; index: number }\n  >()\n  for (let index = 0; index < program.value.clauses.length; index++) {\n    const clause = program.value.clauses[index]\n    clauseSlots.set(clauseConditionSetKey(clause.modifiers), { clause, index })\n  }\n  const clauses = [...clauseSlots.values()]\n    .map((entry) => ({\n      ...entry,\n      precedence: getClausePrecedenceKey(\n        entry.clause.modifiers,\n        registry,\n        precedenceOrder\n      ),\n    }))\n    .sort(\n      (left, right) =>\n        compareClausePrecedence(left.precedence, right.precedence) ||\n        left.index - right.index\n    )\n\n  for (const { clause, precedence } of clauses) {\n    let selectorSuffix = ''\n    let selfStateSpecificity = 0\n    // at-rule preludes wrapping this clause, outermost first in authored order\n    const wrappers: string[] = []\n    let skip = false\n    const seenModifiers = new Set<string>()\n\n    for (const authoredModifier of clause.modifiers) {\n      const modifier = canonicalClauseModifier(authoredModifier)\n      if (seenModifiers.has(modifier)) continue\n      seenModifiers.add(modifier)\n      const kind = registry.get(modifier)\n\n      if (kind === 'platform') {\n        // a web clause applies here exactly as if unconditional at its position;\n        // every other platform's clause belongs to native and is not web CSS\n        if (modifier !== 'web') skip = true\n        continue\n      }\n\n      if (kind === 'media') {\n        const query = mediaQueries?.[modifier]\n        if (!query) {\n          throw new Error(\n            `cannot lower \"${modifier}:\" — no media query was provided for media key \"${modifier}\"`\n          )\n        }\n        wrappers.push(`@media ${query}`)\n        continue\n      }\n\n      if (kind === 'container') {\n        const container = parseContainerModifier(modifier)!\n        const query = containerQueries?.[container.size]\n        if (!query) {\n          throw new Error(\n            `cannot lower \"${modifier}:\" — no container query was provided for size \"${container.size}\"`\n          )\n        }\n        wrappers.push(\n          container.container === null\n            ? `@container ${query}`\n            : `@container ${container.container} ${query}`\n        )\n        continue\n      }\n\n      if (kind === 'state') {\n        const state = stateSelectors[modifier]\n        if (!state) {\n          throw new Error(\n            `cannot lower \"${modifier}:\" — the state has no web selector, so it cannot become CSS`\n          )\n        }\n        selectorSuffix += conditionSelector(state.fragment, state.scope ?? 'self', false)\n        selfStateSpecificity++\n        if (state.media) pushCapabilityGuard(wrappers, state.media)\n        continue\n      }\n\n      if (kind === 'theme') {\n        // the theme class is on the subject or anywhere above it\n        selectorSuffix += conditionSelector(\n          `.${themeClassPrefix}${modifier}`,\n          'is-or-within',\n          true\n        )\n        continue\n      }\n\n      if (kind === 'group') {\n        const group = parseGroupModifier(modifier)!\n        const state = stateSelectors[group.state]\n        if (!state) {\n          throw new Error(\n            `cannot lower \"${modifier}:\" — the group state \"${group.state}\" has no web selector`\n          )\n        }\n        // a group is always a parent, never the subject itself\n        selectorSuffix += conditionSelector(\n          `.${groupClassPrefix}${group.group ?? unnamedGroup}${state.fragment}`,\n          'within',\n          true\n        )\n        if (state.media) pushCapabilityGuard(wrappers, state.media)\n        continue\n      }\n\n      throw new Error(\n        `cannot lower \"${modifier}:\" — it is not a registered modifier, so the value was never validated`\n      )\n    }\n\n    if (skip) continue\n\n    const selector =\n      `.${className}`.repeat(\n        clauseSubjectClassRepetitions(precedence, selfStateSpecificity)\n      ) + selectorSuffix\n    pushRule(selector, wrappers, clause.payload)\n  }\n\n  const composition = transformAxisCompositions[program.property]\n  if (!composition) return { className, rules }\n\n  // one shared rule per axis group: same text, same hash, inserted once\n  const compositionClassName = programClassName(\n    composition.property,\n    { base: composition.value, clauses: [] },\n    configRevision\n  )\n  const localDefaults = Object.entries(composition.defaults)\n    .map(([property, value]) => `${property}:${value}`)\n    .join(';')\n  return {\n    className,\n    rules,\n    composition: {\n      property: composition.property,\n      className: compositionClassName,\n      rules: [\n        `:where(.${compositionClassName}){${localDefaults}}`,\n        `.${compositionClassName}{${composition.property}:${composition.value}}`,\n      ],\n    },\n  }\n}\n\n/**\n * Media and container conditions wrap outermost, first authored outermost, and\n * both share one list so a chain mixing them keeps authored order. Nesting is\n * AND for arbitrary query texts, where joining with ` and ` would break on query\n * lists and on `screen and (…)` forms. Specificity is unmoved either way.\n */\nfunction wrapAtRules(rule: string, wrappers: readonly string[]): string {\n  let out = rule\n  for (let index = wrappers.length - 1; index >= 0; index--) {\n    out = `${wrappers[index]} {${out}}`\n  }\n  return out\n}\n"
+  ]
+}

package/types/mergeFlatValues.d.ts

@@ -0,0 +1,14 @@
+import type { ParsedValue } from "./valueTypes";
+/** Prints one parsed value without changing payloads, modifier order, or clause order. */
+export declare function formatParsedValue(value: ParsedValue): string;
+/**
+* Combine two flat values for the same property, later winning.
+*
+* The merge unit is the clause, so a later `borderColor="green"` overrides the
+* earlier base without erasing an earlier `press:transparent`. Style values
+* that carry no clause take the cheap path and the later one simply wins,
+* which is every ordinary prop.
+*/
+export declare function mergeFlatValues(earlier: unknown, later: unknown): unknown;
+
+//# sourceMappingURL=mergeFlatValues.d.ts.map

package/types/mergeFlatValues.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAEA,cAAoC,mBAAmB;;AAGvD,OAAO,iBAAS,kBAAkB,OAAO;;;;;;;;;AAyBzC,OAAO,iBAAS,gBAAgB,kBAAkB",
+  "names": [],
+  "sources": [
+    "src/mergeFlatValues.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "import { mergeProgramValues } from './programs'\nimport { parseValue } from './valueParser'\nimport type { ModifierRegistryView, ParsedValue } from './valueTypes'\n\n/** Prints one parsed value without changing payloads, modifier order, or clause order. */\nexport function formatParsedValue(value: ParsedValue): string {\n  const parts: string[] = []\n  if (value.base !== null) parts.push(value.base)\n  for (const clause of value.clauses) {\n    parts.push(`${clause.modifiers.join(':')}:${clause.payload}`)\n  }\n  return parts.join(' ')\n}\n\n// merging only needs the parser to split a base from its clauses, and the\n// parser consults the registry for exactly one thing: whether a modifier is\n// registered at all. Nothing about the split depends on which kind comes back.\n// An accepting view therefore parses identically to a configured one, and it\n// keeps values whose modifiers this site cannot resolve (for example, a\n// config's media keys) mergeable instead of quietly dropping their clauses.\nconst acceptAnyModifier: ModifierRegistryView = { get: () => 'state' }\n\n/**\n * Combine two flat values for the same property, later winning.\n *\n * The merge unit is the clause, so a later `borderColor=\"green\"` overrides the\n * earlier base without erasing an earlier `press:transparent`. Style values\n * that carry no clause take the cheap path and the later one simply wins,\n * which is every ordinary prop.\n */\nexport function mergeFlatValues(earlier: unknown, later: unknown): unknown {\n  if (typeof earlier !== 'string' || typeof later !== 'string') return later\n  // a clause needs a colon; skipping the parse here keeps ordinary props off\n  // the grammar path entirely\n  if (!earlier.includes(':') && !later.includes(':')) return later\n\n  const earlierParsed = parseValue(earlier, acceptAnyModifier)\n  if (!earlierParsed.ok) return later\n  const laterParsed = parseValue(later, acceptAnyModifier)\n  if (!laterParsed.ok) return later\n  if (!earlierParsed.value.clauses.length && !laterParsed.value.clauses.length) {\n    return later\n  }\n\n  return formatParsedValue(mergeProgramValues(earlierParsed.value, laterParsed.value))\n}\n"
+  ]
+}

package/types/modifierRegistry.d.ts

@@ -0,0 +1,70 @@
+import type { GrammarConfigView } from "./candidate";
+import { type ModifierRegistryView } from "./valueTypes";
+type Names = readonly string[] | ReadonlySet<string> | Readonly<Record<string, unknown>>;
+export interface ModifierRegistryResult {
+	registry: ModifierRegistryView;
+	/** one human-readable line per name collision, in registration order */
+	diagnostics: string[];
+}
+export interface CreateModifierRegistryOptions {
+	/**
+	* The media keys that measure a size, so `@key` is a meaningful container
+	* query. A `hover` or `pointer` media key measures nothing a container has, and
+	* `@container (hover: none)` is valid syntax with no meaning, so those keys have
+	* no `@` form.
+	*
+	* Overrides the view's derived `containerSizeNames`. When NEITHER is
+	* supplied the sizes are unknown: no container modifier registers and a
+	* diagnostic says so — an unknowable set refuses rather than over-claims.
+	* A caller with genuinely no container concept passes `[]` explicitly.
+	*/
+	containerSizeNames?: Names;
+}
+/**
+* Every built-in interaction/state modifier spelling: the modifiers of the core
+* pseudo-style props, their aliases, and the component-tier state words the
+* behavior packages expose through DOM attributes.
+*/
+export declare const stateModifierNames: readonly string[];
+/**
+* Theme conditions name a root theme. Nested themes still inherit from that
+* root, so `dark:` applies within `dark_blue`, but `dark_blue:` is not a
+* condition of its own.
+*/
+export declare function isRootThemeName(name: string): boolean;
+export interface GroupModifier {
+	/** the state the parent group must be in, always a built-in state modifier */
+	state: string;
+	/** the group name, or null for the nearest unnamed group */
+	group: string | null;
+}
+/** Canonical spelling used by slot identity, precedence, hashing, and matching. */
+export declare function canonicalClauseModifier(name: string): string;
+/**
+* Parameterized group modifiers use Tailwind's spelling: `group-hover` for the
+* nearest unnamed group and `group-hover/card` for a named one. The state part
+* must be a built-in state modifier; the name part is an identifier. Returns
+* null for anything else, which is what makes the spelling a single source of
+* truth for both registration and lowering.
+*/
+export declare function parseGroupModifier(name: string): GroupModifier | null;
+export interface ContainerModifier {
+	/** the size condition; the registry only accepts a registered media name here */
+	size: string;
+	/** the container name, or null for the nearest container */
+	container: string | null;
+}
+/**
+* Container query modifiers own the `@` prefix: `@sm` targets the nearest
+* container and `@sm/card` a named one (plan decisions 17-18). Plain `sm:` stays
+* a viewport media query, which is why the prefix is reserved.
+*
+* This parses the spelling only. Whether `size` names a registered media key is
+* config-dependent, so the registry checks that on lookup and lowering resolves
+* the query text — the same split groups use for their state part.
+*/
+export declare function parseContainerModifier(name: string): ContainerModifier | null;
+export declare function createModifierRegistry(view: GrammarConfigView, options?: CreateModifierRegistryOptions): ModifierRegistryResult;
+export {};
+
+//# sourceMappingURL=modifierRegistry.d.ts.map

package/types/modifierRegistry.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAWA,cAAc,yBAAyB;AAIvC,cAGO,4BACA;KAEF,4BAA4B,sBAAsB,SAAS;AAEhE,iBAAiB,uBAAuB;CACtC,UAAU;;CAEV;;AAGF,iBAAiB,8BAA8B;;;;;;;;;;;;CAY7C,qBAAqB;;;;;;;AAQvB,OAAO,cAAM;;;;;;AAeb,OAAO,iBAAS,gBAAgB;AAIhC,iBAAiB,cAAc;;CAE7B;;CAEA;;;AAIF,OAAO,iBAAS,wBAAwB;;;;;;;;AAsBxC,OAAO,iBAAS,mBAAmB,eAAe;AAYlD,iBAAiB,kBAAkB;;CAEjC;;CAEA;;;;;;;;;;;AAkBF,OAAO,iBAAS,uBAAuB,eAAe;AA6CtD,OAAO,iBAAS,uBACd,MAAM,mBACN,UAAS,gCACR",
+  "names": [],
+  "sources": [
+    "src/modifierRegistry.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "// The one global modifier namespace the flat value grammar parses against.\n//\n// Built from the existing built-in state vocabulary plus the config's media\n// keys, platform names, and root theme names, with parameterized group\n// modifiers resolved on lookup. There is a single namespace on purpose: a name\n// may mean exactly one thing, so a config whose media key collides with a state\n// or theme name gets a diagnostic instead of a silent choice. Registration order\n// is state, media, platform, theme, and first registration wins.\n//\n// See plans/dom-tailwind-flat-values.md — \"Conditions\".\n\nimport type { GrammarConfigView } from './candidate'\nimport { grammarPlatformNames } from './config'\nimport { coreStateModifierNames, modifierAliases } from './stateModifiers'\nimport { componentStateNames } from './states'\nimport {\n  grammarMaxNonPlatformDepth,\n  type ModifierKind,\n  type ModifierRegistryView,\n} from './valueTypes'\n\ntype Names = readonly string[] | ReadonlySet<string> | Readonly<Record<string, unknown>>\n\nexport interface ModifierRegistryResult {\n  registry: ModifierRegistryView\n  /** one human-readable line per name collision, in registration order */\n  diagnostics: string[]\n}\n\nexport interface CreateModifierRegistryOptions {\n  /**\n   * The media keys that measure a size, so `@key` is a meaningful container\n   * query. A `hover` or `pointer` media key measures nothing a container has, and\n   * `@container (hover: none)` is valid syntax with no meaning, so those keys have\n   * no `@` form.\n   *\n   * Overrides the view's derived `containerSizeNames`. When NEITHER is\n   * supplied the sizes are unknown: no container modifier registers and a\n   * diagnostic says so — an unknowable set refuses rather than over-claims.\n   * A caller with genuinely no container concept passes `[]` explicitly.\n   */\n  containerSizeNames?: Names\n}\n\n/**\n * Every built-in interaction/state modifier spelling: the modifiers of the core\n * pseudo-style props, their aliases, and the component-tier state words the\n * behavior packages expose through DOM attributes.\n */\nexport const stateModifierNames: readonly string[] = Object.freeze([\n  ...coreStateModifierNames,\n  ...Object.keys(modifierAliases),\n  ...componentStateNames,\n])\n\nconst stateModifierSet: ReadonlySet<string> = new Set(stateModifierNames)\n\nconst groupPrefixLength = 'group-'.length\n\n/**\n * Theme conditions name a root theme. Nested themes still inherit from that\n * root, so `dark:` applies within `dark_blue`, but `dark_blue:` is not a\n * condition of its own.\n */\nexport function isRootThemeName(name: string): boolean {\n  return name.length > 0 && !name.includes('_')\n}\n\nexport interface GroupModifier {\n  /** the state the parent group must be in, always a built-in state modifier */\n  state: string\n  /** the group name, or null for the nearest unnamed group */\n  group: string | null\n}\n\n/** Canonical spelling used by slot identity, precedence, hashing, and matching. */\nexport function canonicalClauseModifier(name: string): string {\n  const direct = modifierAliases[name]\n  if (direct) return direct\n  if (name.startsWith('group-')) {\n    const group = parseGroupModifier(name)\n    if (group) {\n      const state = modifierAliases[group.state] ?? group.state\n      if (state !== group.state) {\n        return group.group === null ? `group-${state}` : `group-${state}/${group.group}`\n      }\n    }\n  }\n  return name\n}\n\n/**\n * Parameterized group modifiers use Tailwind's spelling: `group-hover` for the\n * nearest unnamed group and `group-hover/card` for a named one. The state part\n * must be a built-in state modifier; the name part is an identifier. Returns\n * null for anything else, which is what makes the spelling a single source of\n * truth for both registration and lowering.\n */\nexport function parseGroupModifier(name: string): GroupModifier | null {\n  if (!name.startsWith('group-')) return null\n  const slash = name.indexOf('/')\n  if (slash === -1) {\n    const state = name.slice(groupPrefixLength)\n    return stateModifierSet.has(state) ? { state, group: null } : null\n  }\n  if (!isModifierName(name, slash + 1, name.length)) return null\n  const state = name.slice(groupPrefixLength, slash)\n  return stateModifierSet.has(state) ? { state, group: name.slice(slash + 1) } : null\n}\n\nexport interface ContainerModifier {\n  /** the size condition; the registry only accepts a registered media name here */\n  size: string\n  /** the container name, or null for the nearest container */\n  container: string | null\n}\n\ninterface ModifierTrieNode {\n  modifiers: readonly string[]\n  children: Map<string, ModifierTrieNode>\n  next?: readonly string[]\n}\n\n/**\n * Container query modifiers own the `@` prefix: `@sm` targets the nearest\n * container and `@sm/card` a named one (plan decisions 17-18). Plain `sm:` stays\n * a viewport media query, which is why the prefix is reserved.\n *\n * This parses the spelling only. Whether `size` names a registered media key is\n * config-dependent, so the registry checks that on lookup and lowering resolves\n * the query text — the same split groups use for their state part.\n */\nexport function parseContainerModifier(name: string): ContainerModifier | null {\n  if (name.charCodeAt(0) !== 64 /* @ */) return null\n  const slash = name.indexOf('/')\n  if (slash === -1) {\n    return isModifierName(name, 1, name.length)\n      ? { size: name.slice(1), container: null }\n      : null\n  }\n  if (!isModifierName(name, 1, slash) || !isModifierName(name, slash + 1, name.length)) {\n    return null\n  }\n  return { size: name.slice(1, slash), container: name.slice(slash + 1) }\n}\n\n/** the shared identifier rule for the parameterized parts of a modifier */\nfunction isModifierName(text: string, start: number, end: number): boolean {\n  if (start >= end) return false\n  for (let index = start; index < end; index++) {\n    const code = text.charCodeAt(index)\n    if (\n      !(code >= 97 && code <= 122) && // a-z\n      !(code >= 65 && code <= 90) && // A-Z\n      !(code >= 48 && code <= 57) && // 0-9\n      code !== 45 && // -\n      code !== 95 // _\n    ) {\n      return false\n    }\n  }\n  return true\n}\n\nfunction forEachName(source: Names | undefined, visit: (name: string) => void): void {\n  if (!source) return\n  if (Array.isArray(source)) {\n    for (const name of source) visit(name)\n    return\n  }\n  if (source instanceof Set) {\n    for (const name of source) visit(name)\n    return\n  }\n  for (const name in source as Readonly<Record<string, unknown>>) visit(name)\n}\n\nexport function createModifierRegistry(\n  view: GrammarConfigView,\n  options: CreateModifierRegistryOptions = {}\n): ModifierRegistryResult {\n  const names = new Map<string, ModifierKind>()\n  const diagnostics: string[] = []\n  const completionNames: string[] = []\n\n  // options override the view's derived set. an undefined BOTH falls back to\n  // every-media-name for now — that over-claim is scheduled for removal with\n  // its own caller sweep; views built from media records already carry the\n  // correct derived subset\n  const sizeSource = options.containerSizeNames ?? view.containerSizeNames\n  let containerSizes: Set<string> | null = null\n  if (sizeSource !== undefined) {\n    containerSizes = new Set()\n    forEachName(sizeSource, (name) => containerSizes!.add(name))\n  }\n\n  const register = (name: string, kind: ModifierKind): void => {\n    if (name.charCodeAt(0) === 64 /* @ */) {\n      // the `@` prefix belongs to container queries, so no configured name may\n      // take it; otherwise `@sm:` would mean two things\n      diagnostics.push(\n        `modifier \"${name}\" is not registered: the \"@\" prefix is reserved for container query modifiers, so it cannot be a ${kind} name`\n      )\n      return\n    }\n    const existing = names.get(name)\n    if (existing !== undefined) {\n      if (existing !== kind) {\n        diagnostics.push(\n          `modifier \"${name}\" is already registered as a ${existing} modifier, so the ${kind} name is ignored`\n        )\n      }\n      return\n    }\n    if (parseGroupModifier(name) !== null) {\n      diagnostics.push(\n        `modifier \"${name}\" shadows the group modifier of the same spelling, which can no longer be used as a ${kind} name`\n      )\n    }\n    names.set(name, kind)\n    completionNames.push(name)\n  }\n\n  // when the caller or the view declares which sizes a container can measure,\n  // that list is the whole rule. Otherwise any registered media name works\n  // (legacy fallback, removal pending its caller sweep)\n  const isContainerSize = (size: string): boolean =>\n    containerSizes ? containerSizes.has(size) : names.get(size) === 'media'\n\n  for (const name of stateModifierNames) register(name, 'state')\n  forEachName(view.mediaNames, (name) => register(name, 'media'))\n  forEachName(view.platformNames ?? grammarPlatformNames, (name) =>\n    register(name, 'platform')\n  )\n  forEachName(view.themeNames, (name) => {\n    if (isRootThemeName(name)) register(name, 'theme')\n  })\n\n  for (const name of stateModifierNames) {\n    const group = `group-${name}`\n    if (names.get(group) === undefined) completionNames.push(group)\n  }\n  if (containerSizes) {\n    for (const size of containerSizes) {\n      if (isContainerSize(size)) completionNames.push(`@${size}`)\n    }\n  } else {\n    for (const name of completionNames.slice()) {\n      if (names.get(name) === 'media') completionNames.push(`@${name}`)\n    }\n  }\n\n  const kindOrder: Readonly<Record<ModifierKind, number>> = {\n    platform: 0,\n    theme: 1,\n    container: 2,\n    media: 3,\n    group: 4,\n    state: 5,\n  }\n  const modifierTrie: ModifierTrieNode = {\n    modifiers: [],\n    children: new Map(),\n  }\n\n  const get = (name: string): ModifierKind | undefined => {\n    const kind = names.get(name)\n    if (kind !== undefined) return kind\n    if (parseGroupModifier(name) !== null) return 'group'\n    const container = parseContainerModifier(name)\n    if (container !== null && isContainerSize(container.size)) return 'container'\n    return undefined\n  }\n\n  return {\n    registry: {\n      get,\n      next(modifiers: readonly string[]): readonly string[] {\n        let node = modifierTrie\n        for (const authored of modifiers) {\n          const canonical = canonicalClauseModifier(authored)\n          let child = node.children.get(canonical)\n          if (!child) {\n            child = {\n              modifiers: [...node.modifiers, canonical],\n              children: new Map(),\n            }\n            node.children.set(canonical, child)\n          }\n          node = child\n        }\n        if (node.next) return node.next\n\n        const used = new Set<string>()\n        const usedKinds = new Set<ModifierKind>()\n        let highestOrder = -1\n        let nonPlatformDepth = 0\n\n        for (const canonical of node.modifiers) {\n          if (used.has(canonical)) {\n            node.next = []\n            return node.next\n          }\n          used.add(canonical)\n          const kind = get(canonical)\n          if (!kind || usedKinds.has(kind) || kindOrder[kind] < highestOrder) {\n            node.next = []\n            return node.next\n          }\n          usedKinds.add(kind)\n          highestOrder = kindOrder[kind]\n          if (kind !== 'platform') {\n            nonPlatformDepth++\n            if (nonPlatformDepth > grammarMaxNonPlatformDepth) {\n              node.next = []\n              return node.next\n            }\n          }\n        }\n\n        const next: string[] = []\n        for (const name of completionNames) {\n          const canonical = canonicalClauseModifier(name)\n          if (canonical !== name) continue\n          if (used.has(canonical)) continue\n          const kind = get(name)\n          if (!kind || kindOrder[kind] < highestOrder) continue\n          if (usedKinds.has(kind)) continue\n          if (kind !== 'platform' && nonPlatformDepth >= grammarMaxNonPlatformDepth) {\n            continue\n          }\n          next.push(name)\n        }\n        node.next = next\n        return node.next\n      },\n    },\n    diagnostics,\n  }\n}\n"
+  ]
+}