zyzz 0.0.20 → 0.0.21

package/src/default.ts

@@ -41,11 +41,10 @@ void [spin, ping, pulse, bounce]
  */
 export const tokens = {
   animate: {
-    spin: 'z-kid-7a-79-7a-7a-2d-73-70-69-6e 1s linear infinite',
-    ping: 'z-kid-7a-79-7a-7a-2d-70-69-6e-67 1s cubic-bezier(0, 0, 0.2, 1) infinite',
-    pulse:
-      'z-kid-7a-79-7a-7a-2d-70-75-6c-73-65 2s cubic-bezier(0.4, 0, 0.6, 1) infinite',
-    bounce: 'z-kid-7a-79-7a-7a-2d-62-6f-75-6e-63-65 1s infinite',
+    spin: 'z-kid-zyzz_2d_spin 1s linear infinite',
+    ping: 'z-kid-zyzz_2d_ping 1s cubic-bezier(0, 0, 0.2, 1) infinite',
+    pulse: 'z-kid-zyzz_2d_pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite',
+    bounce: 'z-kid-zyzz_2d_bounce 1s infinite',
   },
   aspect: {
     video: '16 / 9',
@@ -680,13 +679,13 @@ export const tokens = {
 /** Default appearance, restoration script, and authoring helpers with bundled light/dark tokens. */
 // Generated from tokens by scripts/default-theme.ts; edit tokens and regenerate.
 const config = Config.create({
+  id: 'default',
   vars: {
     animate: {
-      spin: 'z-kid-7a-79-7a-7a-2d-73-70-69-6e 1s linear infinite',
-      ping: 'z-kid-7a-79-7a-7a-2d-70-69-6e-67 1s cubic-bezier(0, 0, 0.2, 1) infinite',
-      pulse:
-        'z-kid-7a-79-7a-7a-2d-70-75-6c-73-65 2s cubic-bezier(0.4, 0, 0.6, 1) infinite',
-      bounce: 'z-kid-7a-79-7a-7a-2d-62-6f-75-6e-63-65 1s infinite',
+      spin: 'z-kid-zyzz_2d_spin 1s linear infinite',
+      ping: 'z-kid-zyzz_2d_ping 1s cubic-bezier(0, 0, 0.2, 1) infinite',
+      pulse: 'z-kid-zyzz_2d_pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite',
+      bounce: 'z-kid-zyzz_2d_bounce 1s infinite',
     },
     aspect: {
       video: '16 / 9',

package/src/internal/Authoring.ts

@@ -3,6 +3,7 @@ import type { style } from '../styleFunction.js'
 import * as Html from '../runtime/CompositionHtml.js'
 import * as Identity from './Identity.js'
 import * as Props from '../runtime/Props.js'
+import * as Token from './Token.js'
 import * as Style from '../Style.js'
 import type * as Theme from './Theme.js'
 
@@ -66,10 +67,12 @@ export function create(
   options: Options = {},
 ): style.ReturnType {
   const dynamic = typeof input === 'function'
+  const identity = options.theme?.[Token.definition].contract[Token.identity]
+  const namespace = identity?.startsWith('id-') ? identity.slice(3) : undefined
   const id =
     options.id === undefined
       ? undefined
-      : Identity.requireId(options.id, 'style')
+      : `id-${namespace ? `${namespace}-` : ''}${Identity.requireId(options.id, 'style').slice(3)}`
   if (dynamic && !id) Identity.requireId(undefined, 'Dynamic style')
   if (!dynamic && !id && Object.keys(input as object).length === 0)
     Identity.requireId(undefined, 'Empty style')
@@ -90,6 +93,7 @@ export function create(
           { style: body(input as Record<string, unknown>) },
           { vars: options.theme },
         ).styles[0]!,
+        namespace,
       )
   const props = Props.create({ className })
   const apply = (values?: style.Options & Record<string, unknown>) => {
@@ -128,7 +132,9 @@ export function variants(
   input: Record<string, unknown>,
   options: Options = {},
 ): unknown {
-  const id = Identity.requireId(options.id, 'variants')
+  const identity = options.theme?.[Token.definition].contract[Token.identity]
+  const namespace = identity?.startsWith('id-') ? identity.slice(3) : undefined
+  const id = `id-${namespace ? `${namespace}-` : ''}${Identity.requireId(options.id, 'variants').slice(3)}`
   if (options.theme) {
     const styles = [
       input.base,

package/src/internal/Binding.ts

@@ -15,10 +15,15 @@ export type Kind =
   | 'signedLength'
   | 'signedPercentage'
 
+/** Marks callback inputs that require an explicit custom token escape. */
+export const dynamic = Symbol('zyzz.binding.dynamic')
+
 /** A compiler-assigned web custom property with its scalar domain. */
 export type Reference<kind extends Domain = Domain> = {
   /** Fixed CSS custom-property name. */
   readonly name: `--${string}`
+  /** Internal callback provenance, independent of the emitted variable name. */
+  readonly [dynamic]?: true | undefined
   /** Scalar domain used by authoring types and runtime primitive checks. */
   readonly type: kind
   /** Distinguishes slots from theme references. */

package/src/internal/Configuration.ts

@@ -163,6 +163,9 @@ export function create(
     )
       throw new InvalidError(`Unknown configuration option: ${key}`)
 
+  if (input.id !== undefined && (typeof input.id !== 'string' || !input.id))
+    throw new InvalidError('id must be a nonempty string.')
+
   if (
     input.storageKey !== undefined &&
     (typeof input.storageKey !== 'string' || !input.storageKey)
@@ -291,7 +294,7 @@ export function create(
   function handle(theme: Theme.Definition, name: string) {
     const original = Token.bind(theme, contract)
     const className = () =>
-      `z_theme-${Identity.requireId(typeof input.id === 'string' ? input.id : undefined, 'Config.create')}-${name.replace(/[^a-zA-Z0-9-]/g, (character) => `_${character.charCodeAt(0).toString(16)}_`)}`
+      `z-theme-${Identity.requireId(typeof input.id === 'string' ? input.id : undefined, 'Config.create').slice(3)}-${Identity.name(name)}`
     const select = (options: { colorScheme?: string } = {}) => {
       const scheme = options.colorScheme
       const selection =
@@ -433,7 +436,7 @@ export function create(
   }
 
   const theme =
-    shorthands || input.defaultLayer !== undefined
+    shorthands || input.defaultLayer !== undefined || input.id !== undefined
       ? Token.bind(Theme.define({}), contract)
       : undefined
   return finish({
@@ -452,7 +455,7 @@ export declare namespace create {
     readonly cssOutput?: 'atomic' | 'grouped' | undefined
     /** Fallback CSS layer for bound styles and variants; unlayered when omitted. */
     readonly defaultLayer?: string | undefined
-    /** Stable theme identity required without source rewriting. */
+    /** Consumer-owned namespace; required for uncompiled variable configs. */
     readonly id?: string | undefined
     /** Explicit ordered property aliases; none are installed by default. */
     readonly shorthands?: Shorthands.Map | undefined
@@ -839,7 +842,7 @@ export type VariableOptions = {
   readonly defaultLayer?: string | undefined
   /** Required default key when vars contains named sets. */
   readonly defaultVars?: string | undefined
-  /** Stable identity required without source rewriting. */
+  /** Consumer-owned namespace; required for uncompiled variable configs. */
   readonly id?: string | undefined
   /** Ordered CSS layer names. */
   readonly layers?: readonly string[] | undefined

package/src/internal/Identity.ts

@@ -25,13 +25,6 @@ export function compact(value: string): string {
   return result
 }
 
-/** Encodes an explicit identity without losing punctuation or Unicode distinctions. */
-export function encode(value: string): string {
-  return Array.from(value, (character) =>
-    character.codePointAt(0)!.toString(16),
-  ).join('-')
-}
-
 /** Keeps an authored label readable while its separate hash disambiguates spelling. */
 export function label(value: string): string {
   return (
@@ -42,18 +35,27 @@ export function label(value: string): string {
   )
 }
 
+/** Encodes one name segment, reserving hyphens for path boundaries. */
+export function name(value: string): string {
+  return Array.from(value, (character) =>
+    /^[a-zA-Z0-9]$/.test(character)
+      ? character
+      : `_${character.codePointAt(0)!.toString(16)}_`,
+  ).join('')
+}
+
 /** Requires an explicit identity at an uncompiled authoring boundary. */
 export function requireId(id: string | undefined, kind: string): string {
   if (!id)
     throw new Error(
       `${kind} requires an explicit id without the compiler plugin.`,
     )
-  return `id-${encode(id)}`
+  return `id-${name(id)}`
 }
 
 /** Names one callback input independently of its declaration order. */
 export function slot(id: string, field: string): `--${string}` {
-  return `--z-d${id}-${encode(field)}`
+  return `--z-${id.startsWith('id-') ? id.slice(3) : id}-${name(field)}`
 }
 
 /** Hashes a canonical value using two independent 32-bit accumulators. */
@@ -69,7 +71,7 @@ export function hash(value: string): string {
 }
 
 /** Names ordered style data consistently in runtime and extraction. */
-export function style(input: Style.NamedStyle): string {
+export function style(input: Style.NamedStyle, namespace?: string): string {
   function value(input: Style.Declaration['value']): unknown {
     if (Binding.is(input)) return ['variable', input.name]
     if (Token.is(input))
@@ -105,12 +107,12 @@ export function style(input: Style.NamedStyle): string {
       !!declaration.important,
     ])
   }
-  return `z-content-${hash(JSON.stringify(shape(input)))}`
+  return `z-${namespace ? `${namespace}-` : ''}content-${name(JSON.stringify(shape(input)))}`
 }
 
 /** Names a complete ordered composition, including repeated definitions. */
 export function composition(names: readonly string[]): string {
-  return `z-compose-${hash(JSON.stringify(names))}`
+  return `z-compose-${name(JSON.stringify(names))}`
 }
 
 /** Names a stylesheet declaration with a caller-owned identity. */

package/src/internal/Theme.ts

@@ -599,10 +599,10 @@ function build(
     Object.defineProperty(
       {
         get className(): string {
-          if (scope) return `z_theme-${scope}`
+          if (scope) return `z-theme-${scope}`
           const id = contract[Token.identity]
           if (!id?.startsWith('id-')) throw new MissingTransformError()
-          return `z_theme-${id}-${Identity.hash(JSON.stringify(values))}`
+          return `z-theme-${id.slice(3)}`
         },
         style: (styles?: unknown, options: style.DefinitionOptions = {}) => {
           if (!contract[Token.identity])

package/src/internal/Token.ts

@@ -333,6 +333,7 @@ export function acceptsReference(
 export function bind<tokens extends Theme.Tokens>(
   original: Theme.Definition<tokens>,
   contract: Contract,
+  cssName?: string,
 ): Theme.Definition<tokens> {
   type Tree = { [key: string]: Reference | Tree }
 
@@ -371,7 +372,14 @@ export function bind<tokens extends Theme.Tokens>(
         vars: variables(tokens),
       },
       definition,
-      { value: Object.freeze({ ...metadata, contract, values }) },
+      {
+        value: Object.freeze({
+          ...metadata,
+          ...(cssName !== undefined ? { cssName } : {}),
+          contract,
+          values,
+        }),
+      },
     ),
   ) as Theme.Definition<tokens>
 }
@@ -383,6 +391,8 @@ export const complete = Symbol('zyzz.contract.complete')
 export type Contract = {
   /** Whether values belong to independent variables rather than fixed theme categories. */
   readonly variableSet?: boolean | undefined
+  /** Custom-property spelling retained by older packed producers. */
+  readonly variableNaming?: 'legacy' | 'hashed' | undefined
   /** Configuration-local category-to-property mappings. */
   readonly mappings?: VariableSets.Mappings | false | undefined
   /** Web emission mode retained by configuration-bound theme handles. */
@@ -520,6 +530,8 @@ export function is(value: unknown): value is Reference {
 
 /** Immutable theme data carried directly by each definition. */
 export type Metadata = {
+  /** Authored scope name, independent of private graph ownership. */
+  readonly cssName?: string | undefined
   /** Original segments for typography paths containing query punctuation. */
   readonly paths?: Readonly<Record<string, readonly string[]>> | undefined
   readonly queries?: Query.Metadata | undefined

package/src/internal/VariableSets.ts

@@ -33,7 +33,7 @@ export function theme(
       get: () => {
         const identity = metadata.contract[Token.identity]
         return identity
-          ? `z_theme-${identity}-${Identity.hash(JSON.stringify(metadata.values))}`
+          ? `z-theme-${identity.startsWith('id-') ? identity.slice(3) : Identity.name(identity)}`
           : original.className
       },
       enumerable: true,

package/src/node/Host.ts

@@ -17,6 +17,7 @@ import * as Snapshot from './internal/Snapshot.js'
 import * as Syntax from '../compiler/internal/Syntax.js'
 import * as Source from '../compiler/Source.js'
 import * as Transform from '../compiler/Transform.js'
+import * as ThemeRules from '../web/internal/Themes.js'
 
 /** A successful publication; paths are relative to the output directory. */
 export type Build = {
@@ -458,6 +459,8 @@ export async function create(options: create.Options): Promise<Runtime> {
     }
 
     const graph = compiler.compile({
+      [ThemeRules.shared]:
+        options.modules === false && !native ? 'all' : undefined,
       [Syntax.cache]: snapshot.programs(modules),
       compiler: options.compiler,
       native,

package/src/variable.ts

@@ -38,7 +38,7 @@ export function variable(
 ): unknown {
   const id = typeof kind === 'object' ? kind.id : options?.id
   return Variable.create({
-    name: `--z-v${Identity.requireId(id, 'variable')}`,
+    name: `--z-${Identity.requireId(id, 'variable').slice(3)}`,
     type: typeof kind === 'string' ? kind : '*',
     variable: true,
   })

package/src/vite/index.ts

@@ -1391,9 +1391,14 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
       await updateDiscovery(this.environment, file, change.event)
     },
     async hotUpdate({ file, modules, timestamp, type, server }) {
-      await updateDiscovery(this.environment, file, type)
-
       const state = entries(this.environment)
+      const previous = [...state.values()].map((entry) => ({
+        code: entry.code,
+        file: entry.file,
+        imports: entry.imports,
+      }))
+
+      await updateDiscovery(this.environment, file, type)
       const first = [...state.values()].find(
         (entry) => entry.files.has(file) || eager(file, this.environment),
       )
@@ -1417,17 +1422,41 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
               true,
             ).catch(() => undefined)
           : undefined
-      const affected = new Set(
-        modules.filter((module) => {
-          const entry = module.id && state.get(module.id)
-          return (
-            !output ||
-            !entry ||
-            entry.code !== output.modules[sourceId(entry.file)]?.code ||
-            entry.imports !==
+      const javascriptChanged = await (async () => {
+        if (!output) return true
+
+        // Portable build adapters share this module and do not require Vite.
+        const { transformWithOxc } = await import('vite')
+        const changed = await Promise.all(
+          previous.map(async (entry) => {
+            const code = output.modules[sourceId(entry.file)]?.code
+            if (
+              entry.imports !==
               JSON.stringify(output.imports[sourceId(entry.file)])
-          )
-        }),
+            )
+              return true
+            if (entry.code === code) return false
+            if (entry.code === undefined || code === undefined) return true
+
+            // Generated type assertions can change without changing runtime bindings.
+            const [before, after] = await Promise.all([
+              transformWithOxc(entry.code, entry.file, { sourcemap: false }),
+              transformWithOxc(code, entry.file, { sourcemap: false }),
+            ])
+            return before.code !== after.code
+          }),
+        )
+        return changed.some(Boolean)
+      })()
+      // Compiler-only inputs have watch edges, but their stylesheets update separately.
+      const affected = new Set(
+        modules.filter(
+          (module) =>
+            javascriptChanged ||
+            (module.id
+              ? !output?.modules[sourceId(module.id)]
+              : module.type !== 'asset'),
+        ),
       )
       const ids = new Set<string>()
       if (type === 'delete') ids.add(cssId(file))
@@ -1436,12 +1465,8 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
         if (!entry.files.has(file) && !eager(file, this.environment)) continue
 
         // Theme scopes affect CSS even when Vite's JavaScript import was erased.
-        if (
-          !output ||
-          entry.code !== output.modules[sourceId(entry.file)]?.code ||
-          entry.imports !== JSON.stringify(output.imports[sourceId(entry.file)])
-        )
-          ids.add(entry.file)
+        // Rewritten importers can lose a source edge, so changed bindings must update together.
+        if (javascriptChanged) ids.add(entry.file)
         ids.add(cssId(entry.file))
         ids.add(sharedId)
       }

package/src/web/Css.ts

@@ -4,6 +4,7 @@
  */
 import * as Targets from '../internal/Targets.js'
 import * as ClassName from './internal/ClassName.js'
+import * as Identity from '../internal/Identity.js'
 import * as Contributions from './internal/Contributions.js'
 import * as Binding from '../internal/Binding.js'
 import * as Cascade from '../internal/Cascade.js'
@@ -33,6 +34,7 @@ export function compile<
 >(
   options: compile.Options<name, themeName>,
 ): compile.ReturnType<name, themeName> {
+  const labels = options[ClassName.labels] ?? options.styles[ClassName.labels]
   options = {
     ...options,
     styles: { styles: options.styles.styles.map(Targets.web) },
@@ -417,6 +419,8 @@ export function compile<
 
   const identities = new Map<string, string>()
   const rules = new Map<string, string>()
+  type ConditionalRule = { conditions: readonly string[]; value: string }
+  const conditionalRules = new Map<string, ConditionalRule>()
   const identical = new Map<string, string>()
   const explicitBodies = new Map<string, string>()
   const selectors = new Map<string, string>()
@@ -470,12 +474,18 @@ export function compile<
 
     const names: string[] = explicit === undefined ? [] : [explicit]
     let ordinal = 0
-    const slots = new Map<string, number>()
-    const developmentName = options.scope
-      ? `definition-${styleIndex}`
-      : style.name
-
-    function emit(body: string, label: string, shared: boolean, output = mode) {
+    const cssName = labels?.[style.name]?.name ?? encode(style.name)
+    const cssNamespace =
+      labels?.[style.name]?.namespace ??
+      (options.scope ? Identity.name(options.scope) : undefined)
+
+    function emit(
+      body: string,
+      label: string,
+      shared: boolean,
+      output = mode,
+      conditional?: ConditionalRule,
+    ) {
       if (!body) return
 
       const independent =
@@ -483,12 +493,8 @@ export function compile<
         !options.development &&
         output === mode &&
         options.composition === 'independent'
-      const key = `${output}:${body}`
-      // Development slots belong to each style even when their initial values match.
-      const reusable =
-        explicit === undefined &&
-        !options.development &&
-        (shared || independent)
+      const key = JSON.stringify([cssNamespace, output, body])
+      const reusable = explicit === undefined && (shared || independent)
       const previous = reusable ? identical.get(key) : undefined
       if (previous && !names.includes(previous)) {
         names.push(previous)
@@ -498,43 +504,23 @@ export function compile<
       if (previous) shared = false
 
       // Contextual slots preserve authored ordering; development names survive value edits.
-      const ordinalSlot = ordinal++
-      const slot = options.development ? (slots.get(label) ?? 0) : ordinalSlot
-      slots.set(label, slot + 1)
+      const slot = ordinal++
       const identity = (() => {
         if (explicit !== undefined)
           return `${explicit}-${mode}-${encode(label)}-${slot}`
-        if (
-          output === 'grouped' &&
-          mode === 'grouped' &&
-          !options.development &&
-          options.composition === 'independent'
-        )
-          return `g_${rules.size.toString(36)}`
         if (output === 'grouped' && mode === 'grouped') {
-          const name = options.development ? developmentName : style.name
-          const scope =
-            options.development && options.scope
-              ? `_m${encode(options.scope)}`
-              : ''
-          return `g-${encode(name)}${scope}${slot ? `_s${slot}` : ''}`
+          return `z-${cssNamespace ? `${cssNamespace}-` : ''}${cssName}${slot ? `__${slot}` : ''}`
         }
         return ClassName.create({
           body,
-          context:
-            !shared || options.development
-              ? JSON.stringify([
-                  options.scope,
-                  mode,
-                  options.development ? developmentName : style.name,
-                ])
-              : options.scope,
+          context: !shared ? cssName : undefined,
+          namespace: cssNamespace,
           property: label,
-          slot: !shared || options.development ? slot : undefined,
-          stable: options.development,
+          slot: !shared ? slot : undefined,
         })
       })()
-      const owner = mode === 'atomic' ? `${style.name}:${slot}` : undefined
+      const owner =
+        mode === 'atomic' && !shared ? `${style.name}:${slot}` : undefined
       if (
         (rules.has(identity) && rules.get(identity) !== body) ||
         (owner !== undefined &&
@@ -543,12 +529,19 @@ export function compile<
       )
         diagnostics.push({
           code: 'identity_collision',
-          message: 'Distinct rules produced the same class identifier.',
+          message:
+            'Generated class names conflict. Supply distinct config or style ids.',
           path: [style.name],
         })
 
       if (owner !== undefined) identities.set(identity, owner)
       rules.set(identity, body)
+      if (
+        conditional?.conditions.some((condition) =>
+          /^@(media|supports)\b/.test(condition),
+        )
+      )
+        conditionalRules.set(identity, conditional)
       if (explicit !== undefined) selectors.set(identity, explicit)
       else {
         if (reusable) identical.set(key, identity)
@@ -611,7 +604,7 @@ export function compile<
           !nestedComposition &&
           !conditions.length &&
           groups.get(conflict(property)) !== false
-        emit(body, property, shared)
+        emit(body, property, shared, mode, { conditions, value })
       }
     }
 
@@ -673,7 +666,7 @@ export function compile<
             options.schemes ?? false,
             options[Themes.shared],
           )
-        : { classes: Object.freeze({}), css: '', resources: [] }
+        : { classes: Object.freeze({}), css: '', resources: [], rules: [] }
   } catch (error) {
     throw new CompileError([
       {
@@ -686,20 +679,57 @@ export function compile<
 
   const scopedCss = [
     scopes.css,
-    ...[...rules].map(
-      ([name, body]) => `.${selectors.get(name) ?? name}{${body}}`,
-    ),
+    ...[...rules].map((entry) => {
+      const [name, body] = entry
+      const selector = `.${ClassName.selector(selectors.get(name) ?? name)}`
+      const conditional = conditionalRules.get(name)
+      if (
+        !conditional ||
+        conditional.conditions.some(
+          (condition) =>
+            condition.startsWith('@') &&
+            !/^@(media|supports)\b/.test(condition),
+        )
+      )
+        return `${selector}{${body}}`
+
+      // Inactive conditions must surround the class rather than leave a matched empty wrapper.
+      const conditions = conditional.conditions.filter((condition) =>
+        condition.startsWith('@'),
+      )
+      const nested = conditional.conditions
+        .filter((condition) => !condition.startsWith('@'))
+        .reduceRight(
+          (body, condition) => `${condition}{${body}}`,
+          conditional.value,
+        )
+      return conditions.reduceRight(
+        (body, condition) => `${condition}{${body}}`,
+        `${selector}{${nested}}`,
+      )
+    }),
   ]
     .filter(Boolean)
     .join('\n')
 
-  return Object.freeze({
+  const result = {
     ...(scopes.resources.length ? { [Themes.shared]: scopes.resources } : {}),
     ...(contributionCss ? { contributionCss, scopedCss } : {}),
+    [ClassName.rules]: Object.freeze({
+      ...Object.fromEntries(rules),
+      ...Object.fromEntries(
+        scopes.rules.map((rule) => [
+          `@scope:${rule.selector.slice(1)}:${Identity.name(rule.property)}:${Identity.name(JSON.stringify(rule.conditions))}`,
+          rule.value,
+        ]),
+      ),
+    }),
     classes: Object.freeze(classes),
     css: [contributionCss, scopedCss].filter(Boolean).join('\n'),
     vars: scopes.classes as Readonly<Record<themeName, string>>,
-  })
+  }
+  Object.defineProperty(result, ClassName.rules, { enumerable: false })
+  return Object.freeze(result)
 }
 
 /** Input and output contracts for literal compilation. */
@@ -714,6 +744,8 @@ export declare namespace compile {
   > = {
     /** Separates generated token rules for hosts with independent CSS resources. */
     readonly [Themes.shared]?: 'all' | 'defaults' | undefined
+    /** Readable source bindings and consumer-owned configuration namespaces. */
+    readonly [ClassName.labels]?: ClassName.Labels | undefined
     /** Fixed class identities used by CSS-only consumers. */
     readonly names?: Readonly<Record<string, string>> | undefined
     /**
@@ -726,14 +758,14 @@ export declare namespace compile {
     /** CSS representation; atomic declarations are the default. */
     readonly cssOutput?: 'atomic' | 'grouped' | undefined
     readonly composition?: 'independent' | 'ordered' | undefined
-    /** Stable declaration names for CSS-only development updates. */
+    /** Retains live definitions for development updates. */
     readonly development?: boolean | undefined
     /**
      * Emit the `color-scheme` selection classes. Set by modules whose runtime
      * helpers can apply a scheme, so lowered `light-dark()` resolves there.
      */
     readonly schemes?: boolean | undefined
-    /** Optional module scope for independently delivered stylesheets. */
+    /** Explicit consumer-owned namespace for independently delivered stylesheets. */
     readonly scope?: string | undefined
     /** Ordered definitions; no themes or source adapter is required. */
     readonly styles: Style.Definition<name>
@@ -748,6 +780,8 @@ export declare namespace compile {
     name extends string = string,
     themeName extends string = string,
   > = {
+    /** Exact emitted rule bodies retained for graph-wide collision diagnostics. */
+    readonly [ClassName.rules]: Readonly<Record<string, string>>
     /** Shared token resources omitted from this module's stylesheet. */
     readonly [Themes.shared]?: readonly Themes.Resource[] | undefined
     /** Contribution text separated for graph-wide hoisting. */