zyzz 0.0.28 → 0.0.29

package/dist/compiler/Native.js

@@ -1,14 +1,6 @@
-import MagicString from 'magic-string';
-import * 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';
 /**
  * Compiles local styles, variants, and variable reads for an explicit native target.
  * @param options - Shared source, destination mappings, and selected set/scheme.
@@ -18,718 +10,22 @@ import * as Walker from 'oxc-walker';
  * @throws {StyleSheet.CompileError} For unsupported native declaration values.
  */
 export function compile(options) {
-    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 = [];
-    function overwrite(start, end, code, expression = false) {
-        edits.push({ start, end, code, expression });
-        module.overwrite(start, end, code);
-    }
-    const recipes = Object.create(null);
-    let dynamic = false;
-    let finite = false;
-    const contexts = new Map();
-    const compiledCalls = new WeakMap();
-    const factories = new Map();
-    const literals = new Map();
-    const initializers = new Map();
-    const stylesByName = new Map();
-    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();
-    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();
-    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.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();
-        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.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, data) {
-        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 = [];
-        const structure = literal.replace(/"(?:[^"\\]|\\.)*"|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?|true|false|null/g, (value, offset) => {
-            // 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, values) {
-        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, name, call, contextOptions = options, compiled, bindings) {
-        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.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,
-                            },
-                        }
-                        : 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.message);
-                }
-            }
-            const defaultVars = call?.nativeContext?.defaultVars ?? contextOptions.set ?? 'default';
-            const tables = new Map();
-            const alternatives = (vars ? Object.keys(vars) : ['default']).map((set) => ({
-                set,
-                schemes: ['light', 'dark'].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 = [];
-                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.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 = [];
-    const explicit = new Set();
-    function binding(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;
-        function original() {
-            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, expression) {
-            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, link = exports[name], input, path = [name]) {
-            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() {
-            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 = [];
-        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 = [];
-    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('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),
+    };
 }
 /** An unsupported native source feature. */
 export class CompileError extends Error {
     /** Stable namespaced diagnostic name. */
     name = 'Native.CompileError';
 }
-// Keep lazy maps independent of the compiler's parser trees and extracted styles.
-function output(module, options) {
-    let sourceMap;
-    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,
-    };
-}
 //# sourceMappingURL=Native.js.map