zyzz 0.0.20 → 0.0.22

package/src/compiler/Graph.ts

@@ -6,7 +6,10 @@ import * as Contributions from './internal/Contributions.js'
 import * as Stylesheets from './internal/Stylesheets.js'
 import type * as Mapping from '@jridgewell/gen-mapping'
 import * as Css from '../web/Css.js'
+import * as ClassName from '../web/internal/ClassName.js'
 import * as Native from './Native.js'
+import * as NativeVars from './internal/NativeVars.js'
+import * as NativeStyleSheet from '../react-native/StyleSheet.js'
 import * as Edits from './internal/Edits.js'
 import * as Identity from '../internal/Identity.js'
 import type * as Ast from '@oxc-project/types'
@@ -39,6 +42,8 @@ export declare namespace compile {
 
   /** Source modules available for relative import resolution. */
   type Options = {
+    /** CSS-only hosts publish variable scopes once with shared rules. */
+    readonly [ThemeRules.shared]?: 'all' | 'defaults' | undefined
     /** Host entrypoints emit owned stylesheet effects without packed contracts. */
     readonly [Stylesheets.entry]?: string | undefined
     /** Host syntax from the same immutable source snapshot. */
@@ -156,6 +161,7 @@ type Cache = {
   native: compile.Options['native']
   result: compile.ReturnType
   schemes: boolean
+  shared?: 'all' | 'defaults' | undefined
   sources: Readonly<Record<string, string>>
   themes: Readonly<Record<string, Theme.Definition>>
 }
@@ -193,6 +199,7 @@ function build(options: compile.Options, cache?: Cache): Cache {
   if (cache?.reset !== options.reset) cache = undefined
   if (cache?.cssOutput !== options.cssOutput) cache = undefined
   if (cache?.composition !== options.composition) cache = undefined
+  if (cache?.shared !== options[ThemeRules.shared]) cache = undefined
   if (
     (cache?.entry === undefined) !==
     (options[Stylesheets.entry] === undefined)
@@ -295,7 +302,7 @@ function build(options: compile.Options, cache?: Cache): Cache {
           previous.type !== slot.type)
       )
         throw new Error(
-          `Conflicting packed variable identity: ${slot.name}; compile libraries with package-qualified module IDs.`,
+          `Conflicting packed variable identity: ${slot.name}; supply distinct declaration ids.`,
         )
 
       variableSlots.set(slot.name, {
@@ -1014,7 +1021,7 @@ function build(options: compile.Options, cache?: Cache): Cache {
         )
           fail(
             moduleId,
-            `Conflicting variable identity: ${slot.name}; compile libraries with package-qualified module IDs.`,
+            `Conflicting variable identity: ${slot.name}; supply distinct declaration ids.`,
             call,
           )
 
@@ -1081,10 +1088,82 @@ function build(options: compile.Options, cache?: Cache): Cache {
           : {}),
       }
     }
+    const profiles = new Map<
+      string,
+      {
+        definitions: Map<string, string>
+        reads: Map<number, { name: string; source?: string }>
+      }
+    >()
+    const reserved = new Set(
+      [...identifiers.values()].flatMap((names) => [...names]),
+    )
+    function profile(moduleId: string) {
+      let value = profiles.get(moduleId)
+      if (!value) {
+        value = { definitions: new Map(), reads: new Map() }
+        profiles.set(moduleId, value)
+      }
+      return value
+    }
+    if (ids.some((id) => extracted.get(id)!.nativeVars?.length))
+      NativeStyleSheet.compile({
+        fonts: native.fonts,
+        platform: native.platform,
+        units: native.units,
+        styles: { styles: [] },
+      })
+    for (const moduleId of ids) {
+      for (const read of extracted.get(moduleId)!.nativeVars ?? []) {
+        const owner = owners[read.owner]?.moduleId
+        // Single-file adapters cannot publish changes to dependency modules.
+        // Packed catalogs without source also retain their local fallback.
+        if (
+          native[Edits.runtime] ||
+          !owner ||
+          !Object.hasOwn(options.modules, owner)
+        )
+          continue
+        let value: string
+        try {
+          value = JSON.stringify(
+            NativeVars.compile({
+              ...read,
+              fonts: native.fonts,
+              units: native.units,
+            }),
+          )
+        } catch (error) {
+          throw new Native.CompileError((error as Error).message)
+        }
+        const definitions = profile(owner).definitions
+        let name = definitions.get(value)
+        if (!name) {
+          name = `__zyzzProfile${Identity.hash(value)}`
+          while (reserved.has(name)) name += '_'
+          reserved.add(name)
+          definitions.set(value, name)
+        }
+        const from = moduleId.split('/').slice(0, -1)
+        const to = owner.split('/')
+        while (from.length && from[0] === to[0]) {
+          from.shift()
+          to.shift()
+        }
+        const source =
+          (from.length ? '../'.repeat(from.length) : './') +
+          to.join('/').replace(/\.([cm]?)tsx?$/, '.$1js')
+        profile(moduleId).reads.set(read.start, {
+          name,
+          ...(owner !== moduleId ? { source } : {}),
+        })
+      }
+    }
     const modules = Object.fromEntries(
       ids.map((moduleId) => {
         if (
           previous &&
+          !profiles.size &&
           extracted.get(moduleId) === previous.extracted.get(moduleId)
         )
           return [moduleId, previous.result.modules[moduleId]!]
@@ -1128,6 +1207,7 @@ function build(options: compile.Options, cache?: Cache): Cache {
         }
         const output = Native.compile({
           ...native,
+          [NativeVars.shared]: profiles.get(moduleId),
           moduleId,
           source: options.modules[moduleId]!,
           [Themes.context]: {
@@ -1455,23 +1535,26 @@ function build(options: compile.Options, cache?: Cache): Cache {
   for (const library of Object.values(libraries))
     for (const link of Object.values(library.links)) published(link)
 
-  const atomicOwners = new Map<string, string>()
-  function packedOwners(link: Themes.Link, moduleId: string) {
-    for (const name of link.style?.className?.split(' ') ?? []) {
-      if (
-        !name.startsWith('z-') ||
-        name.startsWith('z-style-') ||
-        name.startsWith('z-content-')
-      )
-        continue
-      if (!atomicOwners.has(name)) atomicOwners.set(name, moduleId)
+  const emittedRules = new Map<string, { body: string; moduleId: string }>()
+  function registerRules(
+    classRules: Readonly<Record<string, string>>,
+    moduleId: string,
+  ) {
+    for (const [name, body] of Object.entries(classRules)) {
+      const previous = emittedRules.get(name)
+      if (previous && previous.body !== body)
+        throw new Css.CompileError([
+          {
+            code: 'identity_collision',
+            message: `Generated ${name.startsWith('@scope:') ? `scope ${name.split(':')[1]}` : `class ${name}`} conflicts with module ${previous.moduleId}. Supply distinct config or style ids.`,
+            path: [moduleId],
+          },
+        ])
+      emittedRules.set(name, { body, moduleId })
     }
-    for (const member of Object.values(link.members ?? {}))
-      packedOwners(member, moduleId)
   }
   for (const [moduleId, library] of Object.entries(libraries))
-    for (const link of Object.values(library.links))
-      packedOwners(link, moduleId)
+    registerRules(library.classRules, moduleId)
   if (options.compiler === false) {
     const identities = new Map<string, string>()
     for (const [moduleId, library] of Object.entries(libraries)) {
@@ -1570,7 +1653,9 @@ function build(options: compile.Options, cache?: Cache): Cache {
         ? previous!.result.modules[moduleId]!
         : Transform.compile({
             [ThemeRules.shared]:
-              options[Stylesheets.entry] === undefined ? 'defaults' : 'all',
+              options[Stylesheets.entry] === undefined
+                ? (options[ThemeRules.shared] ?? 'defaults')
+                : 'all',
             compiler: options.compiler,
             development: options.development,
             composition: options.composition,
@@ -1610,34 +1695,7 @@ function build(options: compile.Options, cache?: Cache): Cache {
     })
     if (transformed.size > 256)
       transformed.delete(transformed.keys().next().value!)
-    // Module-local checks cannot detect truncated ownership hashes colliding across files.
-    const emitted = new Set(
-      Array.from(
-        modules[moduleId]!.css.matchAll(/\.(z-[\w-]+)\{/g),
-        (match) => match[1],
-      ),
-    )
-    for (const value of Object.values(modules[moduleId]!.classes))
-      for (const name of value.split(' ')) {
-        if (
-          options.compiler === false ||
-          !name.startsWith('z-') ||
-          !emitted.has(name)
-        )
-          continue
-
-        const owner = atomicOwners.get(name)
-        if (owner !== undefined && owner !== moduleId)
-          throw new Css.CompileError([
-            {
-              code: 'invalid_name',
-              message: `Atomic class ${name} is also owned by module ${owner}.`,
-              path: [moduleId],
-            },
-          ])
-
-        atomicOwners.set(name, moduleId)
-      }
+    registerRules(modules[moduleId]![ClassName.rules], moduleId)
 
     for (const call of extracted.get(moduleId)!.calls)
       if (
@@ -1651,20 +1709,32 @@ function build(options: compile.Options, cache?: Cache): Cache {
 
   const defaults = new Set<string>()
   const defaultRules = new Map<string, ThemeRules.Rule[]>()
+  const defaultSections: Stylesheets.Section[] = []
   if (options[Stylesheets.entry] === undefined)
     for (const [source, output] of Object.entries(modules))
       for (const resource of output[ThemeRules.shared] ?? []) {
         if (defaults.has(resource.id)) continue
         defaults.add(resource.id)
 
+        if (!resource.rules) {
+          defaultSections.push({
+            css: resource.css,
+            key: resource.id,
+            layers: [],
+            source,
+          })
+          continue
+        }
+
         const rules = defaultRules.get(source) ?? []
-        rules.push(...(resource.rules ?? []))
+        rules.push(...resource.rules)
         defaultRules.set(source, rules)
       }
 
   const shared = defaults.size
     ? renderShared([
         ...sharedSections,
+        ...defaultSections,
         ...[...defaultRules].map(([source, rules]) => ({
           css: ThemeRules.render(rules),
           key: 'theme-defaults',
@@ -1675,6 +1745,22 @@ function build(options: compile.Options, cache?: Cache): Cache {
     : contributions
   const sharedCss = shared.css
 
+  function publishedRules(
+    id: string,
+    visited = new Set<string>(),
+  ): Readonly<Record<string, string>> {
+    if (visited.has(id)) return {}
+    visited.add(id)
+    return Object.assign(
+      {},
+      ...(dependencies[id] ?? []).map((dependency) =>
+        publishedRules(dependency, visited),
+      ),
+      libraries[id]?.classRules,
+      modules[id]?.[ClassName.rules],
+    )
+  }
+
   function publishedStyle(link: Themes.Link): Themes.Link {
     return {
       ...link,
@@ -1733,6 +1819,7 @@ function build(options: compile.Options, cache?: Cache): Cache {
 
   return {
     compiler: options.compiler !== false,
+    shared: options[ThemeRules.shared],
     composition: options.composition,
     cssOutput: options.cssOutput,
     contracts,
@@ -1803,6 +1890,7 @@ function build(options: compile.Options, cache?: Cache): Cache {
                 })),
                 id,
                 configurations(id),
+                publishedRules(id),
               ),
             ]),
         ),
@@ -1825,6 +1913,7 @@ function nativeOutput(
   let sourceMap: Mapping.EncodedSourceMap | undefined
 
   return Object.freeze({
+    [ClassName.rules]: Object.freeze({}),
     classes: Object.freeze({}),
     [Edits.key]: output[Edits.key],
     code: output.code,

package/src/compiler/Native.ts

@@ -5,6 +5,8 @@ import type * as Recipe from '../internal/Recipe.js'
 import * as Source from './Source.js'
 import * as Edits from './internal/Edits.js'
 import * as NativeBindings from './internal/NativeBindings.js'
+import * as NativeMedia from './internal/NativeMedia.js'
+import * as NativeVars from './internal/NativeVars.js'
 import * as Themes from './internal/Themes.js'
 import * as StyleSheet from '../react-native/StyleSheet.js'
 import * as Syntax from './internal/Syntax.js'
@@ -12,7 +14,7 @@ import * as Variants from '../react-native/Variants.js'
 import * as Walker from 'oxc-walker'
 
 /**
- * Compiles local style and variants calls for an explicit native context.
+ * Compiles local styles, variants, and variable reads for an explicit native target.
  * @param options - Shared source, destination mappings, and selected set/scheme.
  * @returns Native callables, source map, and static recipe tables.
  * @throws {Source.ExtractError} For invalid source authoring.
@@ -50,9 +52,13 @@ export function compile(options: compile.Options): compile.ReturnType {
     })
   let helper = '__zyzzNative'
   while (
-    [helper, `${helper}Context`, `${helper}Dynamic`].some((name) =>
-      names.has(name),
-    )
+    [
+      helper,
+      `${helper}Context`,
+      `${helper}Dynamic`,
+      `${helper}Static`,
+      `${helper}Vars`,
+    ].some((name) => names.has(name))
   )
     helper += '_'
   let dynamicHelper = `${helper}Dynamic`
@@ -70,6 +76,7 @@ export function compile(options: compile.Options): compile.ReturnType {
   }
   const recipes: Record<string, Variants.Definition> = Object.create(null)
   let dynamic = false
+  let finite = false
   const contexts = new Map<string, string>()
   const compiledCalls = new WeakMap<
     Variants.Definition,
@@ -92,6 +99,54 @@ export function compile(options: compile.Options): compile.ReturnType {
   }
 
   const staticTables = new Map<Source.Call, Variants.Definition>()
+  if (extracted.nativeVars?.length)
+    StyleSheet.compile({
+      fonts: options.fonts,
+      platform: options.platform,
+      styles: { styles: [] },
+      units: options.units,
+    })
+
+  const shared = options[NativeVars.shared]
+  const variables = new Map(shared?.definitions)
+  const imports = new Set<string>()
+  for (const read of extracted.nativeVars ?? []) {
+    const imported = shared?.reads.get(read.start)
+    if (imported) {
+      if (imported.source)
+        imports.add(
+          `import {${imported.name}} from ${JSON.stringify(imported.source)};`,
+        )
+      const type = typed
+        ? ` as typeof ${options.source.slice(read.start, read.end)}`
+        : ''
+      overwrite(read.start, read.end, `(${imported.name}${type})`, true)
+      continue
+    }
+    const definition = (() => {
+      try {
+        return NativeVars.compile({
+          ...read,
+          fonts: options.fonts,
+          units: options.units,
+        })
+      } catch (error) {
+        throw new CompileError((error as Error).message)
+      }
+    })()
+    const key = JSON.stringify(definition)
+    let name = variables.get(key)
+    if (!name) {
+      name = `${helper}Vars${variables.size}`
+      while (names.has(name)) name += '_'
+      names.add(name)
+      variables.set(key, name)
+    }
+    const type = typed
+      ? ` as typeof ${options.source.slice(read.start, read.end)}`
+      : ''
+    overwrite(read.start, read.end, `(${name}${type})`, true)
+  }
   if (options.contextual) {
     const groups = new Map<StyleSheet.compile.Options['vars'], Source.Call[]>()
     for (const call of extracted.calls) {
@@ -104,6 +159,15 @@ export function compile(options: compile.Options): compile.ReturnType {
       )
         continue
       const vars = call.nativeContext?.vars ?? options.vars
+      try {
+        if (
+          NativeMedia.prepare(stylesByName.get(call.name) ?? [], vars, options)
+        )
+          continue
+      } catch (error) {
+        throw new CompileError((error as Error).message)
+      }
+
       const group = groups.get(vars)
       if (group) group.push(call)
       else groups.set(vars, [call])
@@ -233,9 +297,58 @@ export function compile(options: compile.Options): compile.ReturnType {
     compiled?: Variants.Definition,
     bindings?: ReturnType<typeof NativeBindings.prepare>,
   ): string {
+    const program =
+      Object.keys(recipe.axes).length > 0 ||
+      call?.slots ||
+      call?.recipe?.payloads?.length
+
     if (contextOptions.contextual) {
       const vars = call?.nativeContext?.vars ?? contextOptions.vars
-      if (!call?.slots && !call?.recipe?.payloads?.length)
+      const media = (() => {
+        try {
+          return NativeMedia.prepare(
+            recipe.rules.flatMap((rule) => rule.value.styles),
+            vars,
+            contextOptions,
+          )
+        } catch (error) {
+          throw new CompileError((error as Error).message)
+        }
+      })()
+      if (media) {
+        const profiles = media.selections.map((selection) => {
+          const selected = media.select(selection)
+          const next = {
+            ...recipe,
+            rules: recipe.rules.map((rule) => ({
+              ...rule,
+              value: {
+                ...rule.value,
+                styles: rule.value.styles.map(selected.style),
+              },
+            })),
+          }
+          const source = call?.nativeContext
+            ? {
+                ...call,
+                nativeContext: {
+                  ...call.nativeContext,
+                  vars: selected.vars as typeof call.nativeContext.vars,
+                },
+              }
+            : call
+          const value = callable(next, name, source, {
+            ...contextOptions,
+            vars: selected.vars,
+          })
+          return `${JSON.stringify(selection)}:${value}`
+        })
+        // A single static table cannot represent the responsive callable.
+        delete recipes[name]
+
+        return `${helper}Context.responsive(${JSON.stringify(media.queries)},{${profiles.join(',')}})`
+      }
+      if (!program)
         compiled ??= Variants.compile({
           recipe,
           fonts: contextOptions.fonts,
@@ -245,7 +358,7 @@ export function compile(options: compile.Options): compile.ReturnType {
         })
       else {
         try {
-          bindings = NativeBindings.prepare(recipe, call!, {
+          bindings = NativeBindings.prepare(recipe, call ?? {}, {
             ...contextOptions,
             vars,
           })
@@ -315,18 +428,36 @@ export function compile(options: compile.Options): compile.ReturnType {
       }
       return `${context}(${[...tables.keys()].join(',')})`
     }
-    if (call?.slots || call?.recipe?.payloads?.length) {
-      dynamic = true
+    const axes = Object.entries(recipe.axes)
+      .map(
+        ([axis, choices]) =>
+          `${JSON.stringify(axis)}:readonly ${JSON.stringify(choices)}`,
+      )
+      .join(';')
+
+    if (program) {
+      const scalar = !!(call?.slots || call?.recipe?.payloads?.length)
+      dynamic ||= scalar
+      finite ||= !scalar
       const compiled = (() => {
         try {
-          return NativeBindings.compile(recipe, call, contextOptions, bindings)
+          const compiled = NativeBindings.compile(
+            recipe,
+            call ?? {},
+            contextOptions,
+            bindings,
+          )
+          return scalar ? compiled : NativeBindings.finite(compiled)
         } catch (error) {
           if (error instanceof StyleSheet.CompileError) throw error
           throw new CompileError((error as Error).message)
         }
       })()
-      const value = create(dynamicHelper, compiled)
+      const value = create(scalar ? dynamicHelper : `${helper}Static`, compiled)
       if (!typed) return value
+      if (!call?.slots && !call?.recipe?.payloads?.length)
+        return `(${value} as import('zyzz/runtime').Native.Callable<{${axes}}>)`
+
       let input = call.valuesType ?? '{}'
       if (call.recipe) {
         input = `{${Object.entries(recipe.axes)
@@ -371,12 +502,6 @@ export function compile(options: compile.Options): compile.ReturnType {
           })
     if (options.contextual) compiledCalls.set(compiled, { styles, value })
     if (!typed) return value
-    const axes = Object.entries(compiled.axes)
-      .map(
-        ([axis, choices]) =>
-          `${JSON.stringify(axis)}:readonly ${JSON.stringify(choices)}`,
-      )
-      .join(';')
     return `(${value} as import('zyzz/runtime').Native.Callable<{${axes}}>)`
   }
 
@@ -483,10 +608,9 @@ export function compile(options: compile.Options): compile.ReturnType {
         throw new CompileError(
           `Packed native callable ${name} requires a static recipe contract.`,
         )
-      const expression = callable(
-        recipe,
-        `${specifier}:${name}`,
-        link.style?.dynamic
+      const expression = callable(recipe, `${specifier}:${name}`, {
+        nativeContext: link.style?.nativeContext,
+        ...(link.style?.dynamic
           ? {
               slots: link.style.dynamic.slots,
               recipe: {
@@ -496,8 +620,8 @@ export function compile(options: compile.Options): compile.ReturnType {
                 defaultPayloads: link.style.dynamic.defaultPayloads,
               },
             }
-          : undefined,
-      )
+          : {}),
+      })
       if (!link.style?.dynamic || !typed) return expression
       const type = `typeof import(${JSON.stringify(specifier)})${path
         .map((part) => `[${JSON.stringify(part)}]`)
@@ -698,7 +822,13 @@ export function compile(options: compile.Options): compile.ReturnType {
       imports.length ? `import ${imports.join(',')} from 'zyzz';` : '',
     )
   }
-  if (extracted.calls.length || compositions.length || packed.length) {
+  if (
+    extracted.calls.length ||
+    compositions.length ||
+    packed.length ||
+    variables.size ||
+    imports.size
+  ) {
     let offset = 0
     if (options.source.startsWith('#!')) {
       const newline = /\r\n|[\n\r\u2028\u2029]/.exec(options.source)
@@ -713,7 +843,7 @@ export function compile(options: compile.Options): compile.ReturnType {
       offset = node.end
     }
 
-    const prelude = `\nimport {Native as ${helper}${dynamic ? `,NativeDynamic as ${dynamicHelper}` : ''}${options.contextual ? `,NativeContext as ${helper}Context` : ''}} from 'zyzz/runtime';\n${[...factories].map(([expression, factory]) => `const ${factory.name}=(${factory.parameters.join(',')})=>${expression};`).join('\n')}\n${[...contexts].map(([expression, name]) => `const ${name}=${expression};`).join('\n')}\n${[...compositions, ...packed].join('\n')}\n`
+    const prelude = `\nimport {Native as ${helper}${dynamic ? `,NativeDynamic as ${dynamicHelper}` : ''}${finite ? `,NativeStatic as ${helper}Static` : ''}${options.contextual ? `,NativeContext as ${helper}Context` : ''}${variables.size ? `,NativeVars as ${helper}Vars` : ''}} from 'zyzz/runtime';\n${[...factories].map(([expression, factory]) => `const ${factory.name}=(${factory.parameters.join(',')})=>${expression};`).join('\n')}\n${[...contexts].map(([expression, name]) => `const ${name}=${expression};`).join('\n')}\n${[...variables].map(([value, name]) => `${shared?.definitions.has(value) ? 'export ' : ''}const ${name}=${helper}Vars.create(JSON.parse(${JSON.stringify(value)}));`).join('\n')}\n${[...imports, ...compositions, ...packed].join('\n')}\n`
     module.appendLeft(offset, prelude)
     edits.push({ start: offset, end: offset, code: prelude, expression: false })
   }
@@ -738,6 +868,8 @@ export declare namespace compile {
   type Options = Omit<StyleSheet.compile.Options, 'styles'> & {
     /** Internal Babel emission mode; authoring types are still validated. */
     readonly [Edits.runtime]?: boolean | undefined
+    /** Compiler-owned shared native variable profiles. */
+    readonly [NativeVars.shared]?: NativeVars.Shared | undefined
     /** Compiler-owned graph context. */
     readonly [Themes.context]?: Themes.Context | undefined
     /** Retain every set and scheme for render-local selection. */
@@ -751,7 +883,7 @@ export declare namespace compile {
     /** Label selected from supplied vars. Defaults to the token-fallback default table. */
     readonly set?: string | undefined
   }
-  /** Executable source with immutable recipe tables and authored source mappings. */
+  /** Executable source with immutable native data and authored source mappings. */
   type ReturnType = {
     /** Internal node replacements for syntax-tree adapters. */
     readonly [Edits.key]: readonly Edits.Edit[]
@@ -759,7 +891,7 @@ export declare namespace compile {
     readonly code: string
     /** Version-three source map encoded as JSON. */
     readonly map: string
-    /** All set/scheme tables for each extracted definition. */
+    /** Set/scheme tables for definitions without variant or scalar programs. */
     readonly recipes: Readonly<Record<string, Variants.Definition>>
   }
 }