zyzz 0.0.28 → 0.0.30

package/src/compiler/Native.ts

@@ -1,17 +1,10 @@
 /** Rewrites shared authoring to native tables and ordered runtime bindings. @module */
-import type * as Ast from '@oxc-project/types'
-import MagicString from 'magic-string'
-import type * as Recipe from '../internal/Recipe.js'
-import * as Source from './Source.js'
+import type * as Source from './Source.js'
+import * as Context from './internal/Context.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'
-import * as Variants from '../react-native/Variants.js'
-import * as Walker from 'oxc-walker'
+import * as Results from './internal/Results.js'
+import type * as StyleSheet from '../react-native/StyleSheet.js'
+import type * as Variants from '../react-native/Variants.js'
 
 /**
  * Compiles local styles, variants, and variable reads for an explicit native target.
@@ -22,836 +15,19 @@ import * as Walker from 'oxc-walker'
  * @throws {StyleSheet.CompileError} For unsupported native declaration values.
  */
 export function compile(options: compile.Options): compile.ReturnType {
-  const typed = !options[Edits.runtime] && /\.[cm]?tsx?$/.test(options.moduleId)
-  const extracted =
-    options[Themes.context]?.extracted ??
-    Source.extract({
-      moduleId: options.moduleId,
-      source: options.source,
-      target: 'native',
-      [Themes.context]: options[Themes.context],
-    })
-  if (
-    extracted.contributions?.length ||
-    extracted.variableCalls?.length ||
-    extracted.themeReferences.length ||
-    extracted.themeSelections?.length ||
-    (!options.contextual &&
-      (extracted.themeAppearances?.length || extracted.themeScripts?.length))
-  )
-    throw new CompileError(
-      'Native static modules do not support CSS contributions, variables, or web set controls.',
-    )
-  const parsed = options[Themes.context]?.parsed ?? Syntax.parse(options)
-  const names = new Set(options[Themes.context]?.identifiers)
-  if (!options[Themes.context]?.identifiers)
-    Walker.walk(parsed.program, {
-      enter(node) {
-        if (node.type === 'Identifier') names.add(node.name)
-      },
-    })
-  let helper = '__zyzzNative'
-  while (
-    [
-      helper,
-      `${helper}Context`,
-      `${helper}Dynamic`,
-      `${helper}Static`,
-      `${helper}Vars`,
-    ].some((name) => names.has(name))
-  )
-    helper += '_'
-  let dynamicHelper = `${helper}Dynamic`
-  while (names.has(dynamicHelper)) dynamicHelper += '_'
-  const module = new MagicString(options.source)
-  const edits: Edits.Edit[] = []
-  function overwrite(
-    start: number,
-    end: number,
-    code: string,
-    expression = false,
-  ) {
-    edits.push({ start, end, code, expression })
-    module.overwrite(start, end, code)
-  }
-  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,
-    {
-      styles: Readonly<Record<string, StyleSheet.NativeStyle>>
-      value: string
-    }
-  >()
-  const factories = new Map<string, { name: string; parameters: string[] }>()
-  const literals = new Map<string, string>()
-  const initializers = new Map<string, { name: string; values: string[] }>()
-  const stylesByName = new Map<
-    string,
-    (typeof extracted.styles.styles)[number][]
-  >()
-  for (const style of extracted.styles.styles) {
-    const styles = stylesByName.get(style.name)
-    if (styles) styles.push(style)
-    else stylesByName.set(style.name, [style])
-  }
-
-  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) {
-      if (
-        call.recipe ||
-        call.staticRecipe ||
-        call.dynamicRecipe ||
-        call.slots ||
-        call.output === 'html'
-      )
-        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])
-    }
-    for (const [vars, calls] of groups) {
-      if (calls.length < 2) continue
-      try {
-        const compiled = StyleSheet.compile({
-          fonts: options.fonts,
-          platform: options.platform,
-          styles: {
-            styles: calls.map((call) => ({
-              name: call.name,
-              declarations: [],
-              rules: (stylesByName.get(call.name) ?? []).map((style) => ({
-                style,
-              })),
-            })),
-          },
-          vars,
-          units: options.units,
-        })
-        for (const call of calls) {
-          const styles = Object.fromEntries(
-            Object.entries(compiled.styles).map(([set, schemes]) => [
-              set,
-              Object.freeze({
-                light: Object.freeze({ '0': schemes.light[call.name]! }),
-                dark: Object.freeze({ '0': schemes.dark[call.name]! }),
-              }),
-            ]),
-          )
-          staticTables.set(
-            call,
-            Object.freeze({
-              axes: Object.freeze({}),
-              defaults: Object.freeze({}),
-              styles: Object.freeze(styles),
-            }),
-          )
-        }
-      } catch (error) {
-        // Recompile failures individually to retain authored error order and paths.
-        if (!(error instanceof StyleSheet.CompileError)) throw error
-      }
-    }
-  }
-
-  for (const call of extracted.calls) {
-    if (
-      (call.recipe && !call.staticRecipe && !call.dynamicRecipe) ||
-      call.output === 'html'
-    )
-      throw new CompileError(
-        'Native source compilation does not support named conditions or HTML output.',
-      )
-    const recipe = call.staticRecipe ??
-      call.dynamicRecipe ?? {
-        axes: {},
-        defaults: {},
-        rules: [
-          {
-            matches: [],
-            value: {
-              styles: stylesByName.get(call.name) ?? [],
-            },
-          },
-        ],
-      }
-    overwrite(
-      call.start,
-      call.end,
-      callable(recipe, call.name, call, options, staticTables.get(call)),
-      true,
-    )
-  }
-
-  function create(name: string, data: unknown): string {
-    const literal = JSON.stringify(data)
-    if (!options[Edits.runtime] || extracted.calls.length < 2)
-      return `${name}.create(${literal})`
-    const key = `${name}:${literal}`
-    const cached = literals.get(key)
-    if (cached) return cached
-    const values: string[] = []
-    const structure = literal.replace(
-      /"(?:[^"\\]|\\.)*"|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?|true|false|null/g,
-      (value: string, offset: number) => {
-        // Serialized property names precede colons; only value tokens become parameters.
-        if (literal[offset + value.length] === ':') return value
-        const parameter = `v${values.length}`
-        values.push(value)
-        return parameter
-      },
-    )
-    const expression = `${name}.create(${structure})`
-    const value =
-      values.length > 64
-        ? `${name}.create(${literal})`
-        : factory(expression, values)
-    literals.set(key, value)
-    return value
-  }
-
-  function factory(expression: string, values: string[]): string {
-    let definition = factories.get(expression)
-    if (!definition) {
-      let name = `${helper}Factory${factories.size}`
-      while (names.has(name)) name += '_'
-      names.add(name)
-      definition = { name, parameters: values.map((_, index) => `v${index}`) }
-      factories.set(expression, definition)
-    }
-    const value = `${definition.name}(${values.join(',')})`
-    initializers.set(value, { name: definition.name, values })
-    return value
-  }
-
-  function callable(
-    recipe: Recipe.Definition,
-    name: string,
-    call?: Pick<
-      Source.Call,
-      'slots' | 'recipe' | 'valuesType' | 'recipeTypes' | 'nativeContext'
-    >,
-    contextOptions = options,
-    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
-      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,
-          platform: contextOptions.platform,
-          vars,
-          units: contextOptions.units,
-        })
-      else {
-        try {
-          bindings = NativeBindings.prepare(recipe, call ?? {}, {
-            ...contextOptions,
-            vars,
-          })
-        } catch (error) {
-          if (error instanceof StyleSheet.CompileError) throw error
-          throw new CompileError((error as Error).message)
-        }
-      }
-      const defaultVars =
-        call?.nativeContext?.defaultVars ?? contextOptions.set ?? 'default'
-      const tables = new Map<string, string>()
-      const alternatives = (vars ? Object.keys(vars) : ['default']).map(
-        (set) => ({
-          set,
-          schemes: (['light', 'dark'] as const).map((colorScheme) => {
-            const value = callable(
-              recipe,
-              name,
-              call,
-              {
-                ...contextOptions,
-                contextual: false,
-                vars,
-                set,
-                colorScheme,
-              },
-              compiled,
-              bindings,
-            )
-            if (!tables.has(value))
-              tables.set(value, `${helper}Table${tables.size}`)
-            return { colorScheme, value }
-          }),
-        }),
-      )
-      const entries = alternatives.map(
-        ({ set, schemes }) =>
-          `${JSON.stringify(set)}:{${schemes.map(({ colorScheme, value }) => `${JSON.stringify(colorScheme)}:${tables.get(value)}`).join(',')}}`,
-      )
-      const parameters = [...tables.values()].map((name, index) =>
-        typed ? `${name}:T${index}` : name,
-      )
-      const types = typed
-        ? `<${parameters.map((_, index) => `const T${index} extends (input:never)=>import('zyzz/runtime').Native.Props<object>`).join(',')},>`
-        : ''
-      const expression = `${types}(${parameters.join(',')})=>${helper}Context.create({${entries.join(',')}},${JSON.stringify(defaultVars)})`
-      let context = contexts.get(expression)
-      if (!context) {
-        context = `${helper}ContextFactory${contexts.size}`
-        while (names.has(context)) context += '_'
-        names.add(context)
-        contexts.set(expression, context)
-      }
-      const inputs = [...tables.keys()].map((value) => initializers.get(value))
-      if (inputs.every((input) => input !== undefined)) {
-        const values: string[] = []
-        const arguments_ = inputs.map((input) => {
-          const parameters = input.values.map((value) => {
-            const parameter = `v${values.length}`
-            values.push(value)
-            return parameter
-          })
-          return `${input.name}(${parameters.join(',')})`
-        })
-        if (values.length <= 64)
-          return factory(`${context}(${arguments_.join(',')})`, values)
-      }
-      return `${context}(${[...tables.keys()].join(',')})`
-    }
-    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 {
-          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(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)
-          .map(([axis, choices]) => {
-            const types = choices.map((choice) =>
-              call.recipeTypes?.[axis]?.[choice]
-                ? `{${JSON.stringify(choice)}:${call.recipeTypes[axis]![choice]}}`
-                : choice === 'true' || choice === 'false'
-                  ? choice
-                  : JSON.stringify(choice),
-            )
-            return `${JSON.stringify(axis)}?:${types.join('|')}|null|undefined`
-          })
-          .join(';')}}`
-      }
-      return `(${value} as import('zyzz/runtime').NativeDynamic.${call.recipe ? 'RecipeCallable' : 'Callable'}<${input}>)`
-    }
-    compiled ??= Variants.compile({
-      recipe,
-      fonts: contextOptions.fonts,
-      platform: contextOptions.platform,
-      vars: contextOptions.vars,
-      units: contextOptions.units,
-    })
-    recipes[name] = compiled
-    const styles = StyleSheet.select(compiled.styles, {
-      set: contextOptions.set ?? 'default',
-      colorScheme: contextOptions.colorScheme,
-    })
-    const cached = compiledCalls.get(compiled)
-    const value =
-      cached &&
-      Object.keys(cached.styles).length === Object.keys(styles).length &&
-      Object.entries(styles).every(
-        ([name, style]) => cached.styles[name] === style,
-      )
-        ? cached.value
-        : create(helper, {
-            axes: compiled.axes,
-            defaults: compiled.defaults,
-            styles,
-          })
-    if (options.contextual) compiledCalls.set(compiled, { styles, value })
-    if (!typed) return value
-    return `(${value} as import('zyzz/runtime').Native.Callable<{${axes}}>)`
-  }
-
-  const packed: string[] = []
-  const explicit = new Set<string>()
-  function binding(node: Ast.Node) {
-    if (node.type === 'Identifier') explicit.add(node.name)
-    else if (node.type === 'ObjectPattern')
-      for (const property of node.properties)
-        binding(
-          property.type === 'RestElement' ? property.argument : property.value,
-        )
-    else if (node.type === 'ArrayPattern')
-      for (const element of node.elements) {
-        if (element) binding(element)
-      }
-    else if (node.type === 'AssignmentPattern') binding(node.left)
-    else if (node.type === 'RestElement') binding(node.argument)
-  }
-  for (const statement of parsed.program.body) {
-    if (
-      statement.type !== 'ExportNamedDeclaration' ||
-      statement.exportKind === 'type'
-    )
-      continue
-    for (const specifier of statement.specifiers)
-      if (specifier.exportKind !== 'type')
-        explicit.add(
-          specifier.exported.type === 'Identifier'
-            ? specifier.exported.name
-            : specifier.exported.value,
-        )
-    const declaration = statement.declaration
-    if (declaration?.type === 'VariableDeclaration') {
-      for (const item of declaration.declarations) binding(item.id)
-    } else if (
-      declaration &&
-      'id' in declaration &&
-      declaration.id?.type === 'Identifier'
-    )
-      explicit.add(declaration.id.name)
-  }
-  for (const statement of parsed.program.body) {
-    if (
-      (statement.type !== 'ImportDeclaration' &&
-        statement.type !== 'ExportNamedDeclaration' &&
-        statement.type !== 'ExportAllDeclaration') ||
-      !statement.source
-    )
-      continue
-    if (
-      (statement.type === 'ImportDeclaration' &&
-        statement.importKind === 'type') ||
-      (statement.type !== 'ImportDeclaration' &&
-        statement.exportKind === 'type')
-    )
-      continue
-    const specifier = statement.source.value
-    const exports = options[Themes.context]?.libraries?.[specifier]
-    if (!exports) continue
-
-    let imported: string | undefined
-    function original(): string {
-      if (imported) return imported
-      imported = `${helper}Namespace${packed.length}`
-      while (names.has(imported)) imported += '_'
-      names.add(imported)
-      packed.push(`import * as ${imported} from ${JSON.stringify(specifier)};`)
-      return imported
-    }
-
-    function overlay(original: string, expression: string): string {
-      let overrides = `${helper}Members${packed.length}`
-      while (names.has(overrides)) overrides += '_'
-      names.add(overrides)
-      packed.push(`const ${overrides}=${expression};`)
-      // Getter descriptors retain live bindings outside the recipe contract.
-      return `Object.freeze(Object.defineProperties({...${original},...${overrides}},Object.fromEntries(Object.keys(${original}).filter(key=>!Object.hasOwn(${overrides},key)).map(key=>[key,{get:()=>Reflect.get(${original},key)}]))))`
-    }
-
-    function value(
-      name: string,
-      link = exports![name],
-      input?: string,
-      path: readonly string[] = [name],
-    ): string | undefined {
-      if (!link || link.kind !== 'style-reference') return undefined
-      if (link.members) {
-        const source = input ?? `${original()}[${JSON.stringify(name)}]`
-        const expression = `{${Object.entries(link.members)
-          .map(
-            ([member, link]) =>
-              `[${JSON.stringify(member)}]:${value(`${name}.${member}`, link, `${source}[${JSON.stringify(member)}]`, [...path, member])}`,
-          )
-          .join(',')}}`
-        return overlay(source, expression)
-      }
-      const recipe = link.style?.staticRecipe ?? link.style?.dynamic?.recipe
-      if (
-        !recipe ||
-        link.style?.output ||
-        (link.style?.slots.length && !link.style.dynamic)
-      )
-        throw new CompileError(
-          `Packed native callable ${name} requires a static recipe contract.`,
-        )
-      const expression = callable(recipe, `${specifier}:${name}`, {
-        nativeContext: link.style?.nativeContext,
-        ...(link.style?.dynamic
-          ? {
-              slots: link.style.dynamic.slots,
-              recipe: {
-                axes: recipe.axes,
-                defaults: recipe.defaults,
-                payloads: link.style.dynamic.payloads,
-                defaultPayloads: link.style.dynamic.defaultPayloads,
-              },
-            }
-          : {}),
-      })
-      if (!link.style?.dynamic || !typed) return expression
-      const type = `typeof import(${JSON.stringify(specifier)})${path
-        .map((part) => `[${JSON.stringify(part)}]`)
-        .join('')}`
-      return `(${expression} as import('zyzz/runtime').NativeDynamic.From<${type}>)`
-    }
-
-    function namespace(): string | undefined {
-      if (
-        !Object.values(exports!).some((link) => link.kind === 'style-reference')
-      )
-        return undefined
-      const imported = original()
-      const members = Object.keys(exports!).flatMap((name) => {
-        const expression = value(
-          name,
-          exports![name],
-          `${imported}[${JSON.stringify(name)}]`,
-        )
-        return expression === undefined
-          ? []
-          : [`[${JSON.stringify(name)}]:${expression}`]
-      })
-      return overlay(imported, `{${members.join(',')}}`)
-    }
-
-    if (statement.type === 'ExportAllDeclaration') {
-      if (statement.exported) {
-        const expression = namespace()
-        if (expression === undefined) continue
-        let local = `${helper}Export${packed.length}`
-        while (names.has(local)) local += '_'
-        names.add(local)
-        const name =
-          statement.exported.type === 'Identifier'
-            ? statement.exported.name
-            : statement.exported.value
-        packed.push(
-          `const ${local}=${expression};export {${local} as ${JSON.stringify(name)}};`,
-        )
-        overwrite(statement.start, statement.end, '')
-        continue
-      }
-      for (const name of Object.keys(exports)) {
-        if (name === 'default' || explicit.has(name)) continue
-        const expression = value(name)
-        if (expression === undefined) continue
-        explicit.add(name)
-        let local = `${helper}Export${packed.length}`
-        while (names.has(local)) local += '_'
-        names.add(local)
-        packed.push(
-          `const ${local}=${expression};export {${local} as ${JSON.stringify(name)}};`,
-        )
-      }
-      continue
-    }
-    const kept: string[] = []
-    for (const specifier of statement.specifiers) {
-      if (specifier.type === 'ImportNamespaceSpecifier') {
-        const expression = namespace()
-        if (expression === undefined) {
-          packed.push(
-            `import * as ${specifier.local.name} from ${JSON.stringify(statement.source.value)};`,
-          )
-        } else packed.push(`const ${specifier.local.name}=${expression};`)
-        continue
-      }
-      if (
-        (specifier.type === 'ImportSpecifier' &&
-          specifier.importKind === 'type') ||
-        (specifier.type === 'ExportSpecifier' &&
-          specifier.exportKind === 'type')
-      ) {
-        kept.push(options.source.slice(specifier.start, specifier.end))
-        continue
-      }
-      const imported =
-        specifier.type === 'ImportDefaultSpecifier'
-          ? 'default'
-          : specifier.type === 'ImportSpecifier'
-            ? specifier.imported
-            : specifier.local
-      const name =
-        typeof imported === 'string'
-          ? imported
-          : imported.type === 'Identifier'
-            ? imported.name
-            : imported.value
-      const expression = value(name)
-      if (expression === undefined) {
-        if (specifier.type === 'ImportDefaultSpecifier')
-          kept.push(`default as ${specifier.local.name}`)
-        else kept.push(options.source.slice(specifier.start, specifier.end))
-        continue
-      }
-      if (specifier.type === 'ExportSpecifier') {
-        let local = `${helper}Export${packed.length}`
-        while (names.has(local)) local += '_'
-        names.add(local)
-        const exported =
-          specifier.exported.type === 'Identifier'
-            ? specifier.exported.name
-            : specifier.exported.value
-        packed.push(
-          `const ${local}=${expression};export {${local} as ${JSON.stringify(exported)}};`,
-        )
-      } else packed.push(`const ${specifier.local.name}=${expression};`)
-    }
-    const keyword = statement.type === 'ImportDeclaration' ? 'import' : 'export'
-    overwrite(
-      statement.start,
-      statement.end,
-      kept.length
-        ? `${keyword} {${kept.join(',')}} from ${JSON.stringify(statement.source.value)};`
-        : `import ${JSON.stringify(statement.source.value)};`,
-    )
-  }
-  const compositions: string[] = []
-  for (const statement of parsed.program.body) {
-    if (
-      statement.type === 'ExportAllDeclaration' &&
-      statement.source.value === 'zyzz' &&
-      statement.exportKind !== 'type'
-    )
-      throw new CompileError(
-        'Native modules require named re-exports from zyzz.',
-      )
-    if (
-      statement.type === 'ExportNamedDeclaration' &&
-      statement.source?.value === 'zyzz' &&
-      statement.exportKind !== 'type'
-    ) {
-      const cx = statement.specifiers.filter(
-        (specifier) =>
-          specifier.exportKind !== 'type' &&
-          (specifier.local.type === 'Identifier'
-            ? specifier.local.name
-            : specifier.local.value) === 'cx',
-      )
-      if (!cx.length) continue
-      let binding = `${helper}Compose`
-      while (names.has(binding)) binding += '_'
-      names.add(binding)
-      compositions.push(`const ${binding}=${helper}.compose;`)
-      const kept = statement.specifiers
-        .filter((specifier) => !cx.includes(specifier))
-        .map((specifier) =>
-          options.source.slice(specifier.start, specifier.end),
-        )
-      const exports = cx.map(
-        (specifier) =>
-          `${binding} as ${options.source.slice(specifier.exported.start, specifier.exported.end)}`,
-      )
-      overwrite(
-        statement.start,
-        statement.end,
-        `${kept.length ? `export {${kept.join(',')}} from 'zyzz';` : ''}export {${exports.join(',')}};`,
-      )
-      continue
-    }
-    if (
-      statement.type !== 'ImportDeclaration' ||
-      statement.source.value !== 'zyzz' ||
-      statement.importKind === 'type'
-    )
-      continue
-    const cx = statement.specifiers.filter(
-      (specifier) =>
-        specifier.type === 'ImportSpecifier' &&
-        specifier.importKind !== 'type' &&
-        (specifier.imported.type === 'Identifier'
-          ? specifier.imported.name
-          : specifier.imported.value) === 'cx',
-    )
-    if (!cx.length) continue
-    compositions.push(
-      ...cx.map(
-        (specifier) => `const ${specifier.local.name}=${helper}.compose;`,
-      ),
-    )
-    const kept = statement.specifiers.filter(
-      (specifier) => !cx.includes(specifier),
-    )
-    const named = kept
-      .filter((specifier) => specifier.type === 'ImportSpecifier')
-      .map((specifier) => options.source.slice(specifier.start, specifier.end))
-    const other = kept
-      .filter((specifier) => specifier.type !== 'ImportSpecifier')
-      .map((specifier) => options.source.slice(specifier.start, specifier.end))
-    const imports = [
-      ...other,
-      ...(named.length ? [`{${named.join(',')}}`] : []),
-    ]
-    overwrite(
-      statement.start,
-      statement.end,
-      imports.length ? `import ${imports.join(',')} from 'zyzz';` : '',
-    )
-  }
-  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)
-      offset = newline
-        ? newline.index + newline[0].length
-        : options.source.length
-    }
-
-    for (const node of parsed.program.body) {
-      if (node.type !== 'ExpressionStatement' || !node.directive) break
-
-      offset = node.end
-    }
-
-    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 })
-  }
-  return output(module, {
-    edits,
+  const output = Results.call<Results.NativeOutput>('native.compile', {
+    ...Results.native(options),
+    context: options[Context.key] === true,
     moduleId: options.moduleId,
-    recipes: Object.freeze(recipes),
+    source: options.source,
   })
+
+  return {
+    [Edits.key]: output.edits,
+    code: output.code,
+    map: output.map,
+    recipes: Results.frozen(output.recipes) as compile.ReturnType['recipes'],
+  }
 }
 
 /** Native source compilation contracts. */
@@ -868,10 +44,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
+    /** Compiles the module as a member of an adapter-owned graph. */
+    readonly [Context.key]?: true | undefined
     /** Retain every set and scheme for render-local selection. */
     readonly contextual?: boolean | undefined
     /** Scheme compiled into this module's callables. Recompile to select another scheme. */
@@ -901,30 +75,3 @@ export class CompileError extends Error {
   /** Stable namespaced diagnostic name. */
   override name = 'Native.CompileError'
 }
-
-// Keep lazy maps independent of the compiler's parser trees and extracted styles.
-function output(
-  module: MagicString,
-  options: {
-    readonly edits: readonly Edits.Edit[]
-    readonly moduleId: string
-    readonly recipes: compile.ReturnType['recipes']
-  },
-): compile.ReturnType {
-  let sourceMap: string | undefined
-
-  return {
-    [Edits.key]: options.edits,
-    code: module.toString(),
-    get map() {
-      return (sourceMap ??= module
-        .generateMap({
-          hires: true,
-          includeContent: true,
-          source: options.moduleId,
-        })
-        .toString())
-    },
-    recipes: options.recipes,
-  }
-}