zyzz 0.0.28 → 0.0.30

package/dist/compiler/Graph.js

@@ -1,1459 +1,74 @@
-/**
- * Links a closed graph of source modules without executing code or reading files.
- * @module
- */
-import * as Contributions from './internal/Contributions.js';
-import * as Stylesheets from './internal/Stylesheets.js';
-import * as Css from '../web/Css.js';
+import * as Addon from '../internal/Addon.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 * as Parser from 'oxc-parser';
-import * as Syntax from './internal/Syntax.js';
-import * as Walker from 'oxc-walker';
-import * as Token from '../internal/Token.js';
-import * as Contract from './internal/Contract.js';
-import * as Relative from './internal/Relative.js';
 import * as ThemeRules from '../web/internal/Themes.js';
-import * as Themes from './internal/Themes.js';
-import * as Source from './Source.js';
-import * as Scope from './internal/Scope.js';
-import * as Static from './internal/Static.js';
-import * as Transform from './Transform.js';
+import * as Results from './internal/Results.js';
+import * as Stylesheets from './internal/Stylesheets.js';
 /** Compiles supplied modules with shared theme contracts and dependency metadata. */
 export function compile(options) {
-    return build(options).result;
+    return Results.graph(Results.call('graph.compile', encode(options)));
 }
-/** Creates an isolated compiler with bounded extraction reuse across source graphs. */
-export function create() {
-    let previous;
-    return Object.freeze({
-        compile(options) {
-            const next = build(options, previous);
-            previous = next;
-            return next.result;
-        },
-    });
+/** The engine's answer when a snapshot names a source it no longer holds. */
+const stale = '{"stale":true}';
+/** Names each source equal to the one `previous` held as `0`. */
+function unchanged(sources, previous) {
+    if (!sources || !previous)
+        return sources;
+    const output = {};
+    for (const [id, source] of Object.entries(sources))
+        output[id] = previous[id] === source ? 0 : source;
+    return output;
 }
-function build(options, cache) {
-    if (!!cache?.native !== !!options.native ||
-        cache?.native?.[Edits.runtime] !== options.native?.[Edits.runtime] ||
-        Object.keys(cache?.native ?? {}).length !==
-            Object.keys(options.native ?? {}).length ||
-        Object.entries(cache?.native ?? {}).some(([key, value]) => {
-            const next = Reflect.get(options.native ?? {}, key);
-            if (key !== 'fonts' && key !== 'vars' && key !== 'units')
-                return value !== next;
-            return (!!value !== !!next ||
-                Object.keys(value ?? {}).length !== Object.keys(next ?? {}).length ||
-                Object.entries(value ?? {}).some(([name, entry]) => Reflect.get(next ?? {}, name) !== entry));
-        }))
-        cache = undefined;
-    if (options.native && options.reset !== undefined)
-        throw new Native.CompileError('The CSS reset is only supported by web builds.');
-    if (options.native && options.compiler === false)
-        throw new Native.CompileError('Native graph compilation requires source rewriting.');
-    if (cache?.compiler !== (options.compiler !== false))
-        cache = undefined;
-    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))
-        cache = undefined;
-    const ids = Object.keys(options.modules).sort();
-    const programs = new Map();
-    function parse(input) {
-        const cached = programs.get(input.moduleId) ?? options[Syntax.cache]?.get(input.moduleId);
-        if (cached)
-            return cached;
-        const parsed = Syntax.parse(input);
-        programs.set(input.moduleId, parsed);
-        return parsed;
-    }
-    const contracts = JSON.stringify(Object.entries(options.contracts ?? {}).sort(([a], [b]) => a.localeCompare(b)));
-    const resolutions = Object.fromEntries([...new Set([...ids, ...Object.keys(options.imports ?? {})])]
-        .sort()
-        .map((id) => [
-        id,
-        options.imports === undefined
-            ? 'relative'
-            : JSON.stringify(Object.entries(options.imports[id] ?? {}).sort(([a], [b]) => a.localeCompare(b))),
-    ]));
-    // Host resolutions remain explicit when generated modules enter or leave the graph.
-    const previous = (() => {
-        if (cache &&
-            cache.contracts === contracts &&
-            cache.development === !!options.development &&
-            (options.imports !== undefined ||
-                (ids.length === Object.keys(cache.sources).length &&
-                    ids.every((id) => Object.hasOwn(cache.sources, id))))) {
-            return cache;
-        }
-        return undefined;
-    })();
-    if (previous &&
-        previous.entry === options[Stylesheets.entry] &&
-        ids.length === Object.keys(previous.sources).length &&
-        Object.keys(resolutions).length ===
-            Object.keys(previous.resolutions).length &&
-        Object.entries(resolutions).every(([id, value]) => value === previous.resolutions[id]) &&
-        ids.every((id) => options.modules[id] === previous.sources[id] &&
-            resolutions[id] === previous.resolutions[id]))
-        return previous;
-    const retained = new Map(previous?.retained);
-    const transformed = new Map(previous?.transformed);
-    const dependencies = Object.create(null);
-    const extracted = new Map();
-    const identifiers = new Map();
-    const owners = Object.create(null);
-    const themes = Object.create(null);
-    const visiting = new Set();
-    const libraries = Object.create(null);
-    const identities = new Map();
-    const variableSlots = new Map();
-    function validateLibraryLink(link, owner) {
-        const variableOwner = owner.includes('/')
-            ? (link.call.variableOwner ?? owner)
-            : owner;
-        for (const slot of Object.values(link.call.variables ?? {})) {
-            const previous = variableSlots.get(slot.name);
-            if (previous &&
-                (previous.owner !== variableOwner ||
-                    previous.binding !== link.binding ||
-                    previous.type !== slot.type))
-                throw new Error(`Conflicting packed variable identity: ${slot.name}; supply distinct declaration ids.`);
-            variableSlots.set(slot.name, {
-                owner: variableOwner,
-                binding: link.binding,
-                type: slot.type,
-            });
-        }
-        for (const member of Object.values(link.members ?? {}))
-            validateLibraryLink(member, owner);
-    }
-    for (const [id, source] of Object.entries(options.contracts ?? {})) {
-        if (Object.hasOwn(options.modules, id))
-            fail(id, 'A module cannot supply both source and a library contract.');
-        try {
-            const library = previous?.libraries[id] ?? Contract.read(source, identities, id);
-            for (const link of Object.values(library.links))
-                validateLibraryLink(link, id);
-            for (const [name, theme] of Object.entries(library.themes)) {
-                if (themes[name] &&
-                    Contract.write({}, { [name]: themes[name] }) !==
-                        Contract.write({}, { [name]: theme }))
-                    throw new Error(`Conflicting library theme identity: ${name}`);
-                themes[name] = theme;
-            }
-            libraries[id] = library;
-        }
-        catch (error) {
-            fail(id, `Invalid library contract: ${error.message}`);
-        }
-    }
-    function fail(moduleId, message, node) {
-        throw new Source.ExtractError([
-            {
-                code: 'unsupported_syntax',
-                end: node?.end ?? 0,
-                message,
-                source: moduleId,
-                start: node?.start ?? 0,
-            },
-        ]);
-    }
-    function resolve(moduleId, specifier, node = { start: 0, end: 0 }) {
-        if (options.imports !== undefined) {
-            const imports = options.imports[moduleId];
-            if (!imports || !Object.hasOwn(imports, specifier))
-                fail(moduleId, `Missing host resolution: ${specifier}`, node);
-            const target = imports[specifier];
-            if (target === null)
-                return undefined;
-            if (target === undefined ||
-                (!Object.hasOwn(options.modules, target) &&
-                    !Object.hasOwn(libraries, target)))
-                fail(moduleId, `Missing host source module: ${specifier}`, node);
-            return target;
-        }
-        try {
-            return Relative.resolve({ moduleId, modules: options.modules, specifier });
-        }
-        catch (error) {
-            fail(moduleId, error.message, node);
-        }
-    }
-    const constants = new Map();
-    function constant(moduleId, name, active = new Set()) {
-        const key = JSON.stringify([moduleId, name]);
-        if (constants.has(key))
-            return constants.get(key);
-        if (active.has(key) || !Object.hasOwn(options.modules, moduleId))
-            return undefined;
-        const next = new Set(active).add(key);
-        const program = parse({
-            moduleId,
-            source: options.modules[moduleId],
-        }).program;
-        const imports = Object.create(null);
-        let local = name;
-        let exported = false;
-        let direct;
-        const stars = [];
-        for (const statement of program.body) {
-            if (statement.type === 'ExportDefaultDeclaration' && name === 'default') {
-                direct = statement.declaration;
-                exported = true;
-            }
-            if (statement.type === 'ExportAllDeclaration' &&
-                statement.exportKind !== 'type' &&
-                !statement.exported &&
-                name !== 'default') {
-                const target = resolve(moduleId, statement.source.value, statement);
-                if (target)
-                    stars.push(target);
-            }
-            if (statement.type !== 'ExportNamedDeclaration' ||
-                statement.exportKind === 'type')
-                continue;
-            if (statement.declaration?.type === 'VariableDeclaration')
-                exported ||= statement.declaration.declarations.some((value) => value.id.type === 'Identifier' && value.id.name === name);
-            for (const specifier of statement.specifiers) {
-                if (specifier.exportKind === 'type')
-                    continue;
-                const alias = specifier.exported.type === 'Identifier'
-                    ? specifier.exported.name
-                    : specifier.exported.value;
-                if (alias !== name)
-                    continue;
-                local =
-                    specifier.local.type === 'Identifier'
-                        ? specifier.local.name
-                        : specifier.local.value;
-                if (statement.source) {
-                    const target = resolve(moduleId, statement.source.value, statement);
-                    return target ? constant(target, local, next) : undefined;
-                }
-                exported = true;
-            }
-        }
-        if (!exported) {
-            const candidates = [
-                ...new Set(stars
-                    .map((target) => constant(target, name, next))
-                    .filter((value) => value !== undefined)),
-            ];
-            const value = candidates.length === 1 ? candidates[0] : undefined;
-            if (value || !stars.length)
-                constants.set(key, value);
-            return value;
-        }
-        if (direct &&
-            [
-                'FunctionDeclaration',
-                'FunctionExpression',
-                'ArrowFunctionExpression',
-                'ClassDeclaration',
-                'ClassExpression',
-            ].includes(direct.type)) {
-            constants.set(key, undefined);
-            return undefined;
-        }
-        for (const statement of program.body) {
-            if (statement.type === 'ImportDeclaration' &&
-                statement.importKind !== 'type') {
-                const target = resolve(moduleId, statement.source.value, statement);
-                if (!target)
-                    continue;
-                for (const specifier of statement.specifiers) {
-                    if (specifier.type === 'ImportNamespaceSpecifier' ||
-                        (specifier.type === 'ImportSpecifier' &&
-                            specifier.importKind === 'type'))
-                        continue;
-                    const imported = specifier.type === 'ImportDefaultSpecifier'
-                        ? 'default'
-                        : specifier.imported.type === 'Identifier'
-                            ? specifier.imported.name
-                            : specifier.imported.value;
-                    const value = constant(target, imported, next);
-                    if (value)
-                        imports[specifier.local.name] = relocate(value, specifier);
-                }
-            }
-        }
-        const scope = new Scope.Tracker({ preserveExitedScopes: true });
-        Walker.walk(program, { scopeTracker: scope });
-        scope.freeze();
-        let value;
-        try {
-            const data = Static.collect(program, scope, imports);
-            value = direct
-                ? data.normalize(direct, new Set(), new Set(), true)
-                : data.exported(local);
-        }
-        catch {
-            return undefined;
-        }
-        if (value && !literal(value))
-            value = undefined;
-        constants.set(key, value);
-        return value;
-    }
-    function literal(node, depth = 0) {
-        if (depth > 64)
-            return false;
-        if (node.type === 'Literal')
-            return (node.value === null ||
-                ['string', 'number', 'boolean'].includes(typeof node.value));
-        if (node.type === 'UnaryExpression')
-            return (['+', '-'].includes(node.operator) &&
-                node.argument.type === 'Literal' &&
-                typeof node.argument.value === 'number');
-        if (node.type === 'TemplateLiteral')
-            return !node.expressions.length;
-        if (node.type === 'ArrayExpression')
-            return node.elements.every((value) => value && literal(value, depth + 1));
-        return (node.type === 'ObjectExpression' &&
-            node.properties.every((property) => property.type === 'Property' &&
-                !property.method &&
-                property.kind === 'init' &&
-                (!property.computed || property.key.type === 'Literal') &&
-                literal(property.value, depth + 1)));
-    }
-    function relocate(node, span) {
-        const copy = structuredClone(node);
-        Walker.walk(copy, {
-            enter(node) {
-                node.start = span.start;
-                node.end = span.end;
-            },
-        });
-        return copy;
-    }
-    const factoryPrograms = new Map();
-    function factory(moduleId, name, seen = new Set()) {
-        if (moduleId === 'zyzz/web')
-            return Contributions.factories.includes(name) ? name : undefined;
-        const key = `${moduleId}#${name}`;
-        if (seen.has(key) || !Object.hasOwn(options.modules, moduleId))
-            return undefined;
-        const next = new Set(seen).add(key);
-        const program = factoryPrograms.get(moduleId) ??
-            Parser.parseSync('barrel.ts', options.modules[moduleId], {
-                sourceType: 'module',
-            }).program;
-        factoryPrograms.set(moduleId, program);
-        const target = (specifier, node) => specifier === 'zyzz/web' ? specifier : resolve(moduleId, specifier, node);
-        for (const node of program.body) {
-            if (node.type !== 'ExportNamedDeclaration' || node.exportKind === 'type')
-                continue;
-            const declaration = node.declaration;
-            if (declaration?.type === 'VariableDeclaration' &&
-                declaration.declarations.some((item) => item.id.type === 'Identifier' && item.id.name === name))
-                return undefined;
-            if ((declaration?.type === 'FunctionDeclaration' ||
-                declaration?.type === 'ClassDeclaration') &&
-                declaration.id?.name === name)
-                return undefined;
-            for (const specifier of node.specifiers) {
-                if (specifier.exportKind === 'type')
-                    continue;
-                const exported = specifier.exported.type === 'Identifier'
-                    ? specifier.exported.name
-                    : specifier.exported.value;
-                if (exported !== name)
-                    continue;
-                const local = specifier.local.type === 'Identifier'
-                    ? specifier.local.name
-                    : specifier.local.value;
-                if (node.source) {
-                    const id = target(node.source.value, node);
-                    return id ? factory(id, local, next) : undefined;
-                }
-                for (const declaration of program.body) {
-                    if (declaration.type !== 'ImportDeclaration' ||
-                        declaration.importKind === 'type')
-                        continue;
-                    for (const imported of declaration.specifiers) {
-                        if (imported.type !== 'ImportSpecifier' ||
-                            imported.importKind === 'type' ||
-                            imported.local.name !== local)
-                            continue;
-                        const id = target(declaration.source.value, declaration);
-                        return id
-                            ? factory(id, imported.imported.type === 'Identifier'
-                                ? imported.imported.name
-                                : imported.imported.value, next)
-                            : undefined;
-                    }
-                }
-                return undefined;
-            }
-        }
-        for (const node of program.body) {
-            if (node.type === 'ExportAllDeclaration' &&
-                node.exportKind !== 'type' &&
-                !node.exported) {
-                const id = target(node.source.value, node);
-                const found = id ? factory(id, name, next) : undefined;
-                if (found)
-                    return found;
-            }
-        }
-        return undefined;
-    }
-    function visit(moduleId) {
-        const cached = extracted.get(moduleId);
-        if (cached)
-            return cached;
-        if (visiting.has(moduleId))
-            fail(moduleId, 'Circular source dependencies are not supported yet.');
-        visiting.add(moduleId);
-        const source = options.modules[moduleId];
-        const snapshot = previous?.retained.get(moduleId) ??
-            (previous && Object.hasOwn(previous.sources, moduleId)
-                ? {
-                    dependencies: previous.result.dependencies[moduleId],
-                    extracted: previous.extracted.get(moduleId),
-                    inputs: new Map(previous.result.dependencies[moduleId].map((target) => [
-                        target,
-                        previous.libraries[target] ?? previous.extracted.get(target),
-                    ])),
-                    resolution: previous.resolutions[moduleId],
-                    source: previous.sources[moduleId],
-                }
-                : undefined);
-        if (snapshot &&
-            source === snapshot.source &&
-            resolutions[moduleId] === snapshot.resolution &&
-            snapshot.dependencies.every((target) => Object.hasOwn(libraries, target)
-                ? libraries[target] === snapshot.inputs.get(target)
-                : Object.hasOwn(options.modules, target) &&
-                    visit(target) === snapshot.inputs.get(target))) {
-            return retain(moduleId, snapshot.extracted, snapshot.dependencies);
-        }
-        // Validate identity and syntax through the public source boundary before linking.
-        Source.extract({ moduleId, source: '' });
-        const parsed = parse({ moduleId, source });
-        if (parsed.errors.length)
-            Source.extract({ moduleId, source });
-        factoryPrograms.set(moduleId, parsed.program);
-        const names = new Set();
-        identifiers.set(moduleId, names);
-        Walker.walk(parsed.program, {
-            enter(node) {
-                if (node.type === 'Identifier')
-                    names.add(node.name);
-                if (options.imports === undefined &&
-                    node.type === 'ImportExpression' &&
-                    (node.source.type !== 'Literal' ||
-                        typeof node.source.value !== 'string' ||
-                        node.source.value.startsWith('.')))
-                    fail(moduleId, 'Source graph dependencies require static imports.', node);
-            },
-        });
-        const values = Object.create(null);
-        const links = Object.create(null);
-        const forwarded = Object.create(null);
-        const explicit = new Set();
-        const stars = [];
-        const imports = new Set();
-        function exportedBindings(node) {
-            if (node.type === 'Identifier')
-                explicit.add(node.name);
-            else if (node.type === 'ObjectPattern')
-                for (const property of node.properties)
-                    exportedBindings(property.type === 'Property' ? property.value : property.argument);
-            else if (node.type === 'ArrayPattern')
-                for (const element of node.elements) {
-                    if (element)
-                        exportedBindings(element);
-                }
-            else if (node.type === 'AssignmentPattern')
-                exportedBindings(node.left);
-            else if (node.type === 'RestElement')
-                exportedBindings(node.argument);
-        }
-        for (const node of parsed.program.body) {
-            if (node.type === 'ExportNamedDeclaration' &&
-                !node.source &&
-                node.exportKind !== 'type') {
-                for (const specifier of node.specifiers)
-                    if (specifier.exportKind !== 'type')
-                        explicit.add(specifier.exported.type === 'Identifier'
-                            ? specifier.exported.name
-                            : specifier.exported.value);
-                if (node.declaration?.type === 'VariableDeclaration')
-                    for (const declaration of node.declaration.declarations)
-                        exportedBindings(declaration.id);
-                else if ((node.declaration?.type === 'FunctionDeclaration' ||
-                    node.declaration?.type === 'ClassDeclaration') &&
-                    node.declaration.id)
-                    explicit.add(node.declaration.id.name);
-            }
-            if ((node.type !== 'ImportDeclaration' &&
-                node.type !== 'ExportNamedDeclaration' &&
-                node.type !== 'ExportAllDeclaration') ||
-                !node.source)
-                continue;
-            if (node.type === 'ImportDeclaration'
-                ? node.importKind === 'type'
-                : node.exportKind === 'type')
-                continue;
-            if ('specifiers' in node &&
-                node.specifiers.length &&
-                node.specifiers.every((specifier) => specifier.type === 'ImportSpecifier'
-                    ? specifier.importKind === 'type'
-                    : specifier.type === 'ExportSpecifier' &&
-                        specifier.exportKind === 'type'))
-                continue;
-            const target = resolve(moduleId, node.source.value, node);
-            if (!target)
-                continue;
-            imports.add(target);
-            const contracts = libraries[target]?.links ?? visit(target).themeExports ?? {};
-            function namespace(name) {
-                const first = Object.values(contracts)[0];
-                if (!first)
-                    return undefined;
-                return {
-                    binding: `z-style-${Identity.hash(JSON.stringify([moduleId, name]))}-namespace`,
-                    call: { start: -1, end: -1, name: '', tokenType: '{}' },
-                    definition: first.definition,
-                    kind: 'style-reference',
-                    members: contracts,
-                };
-            }
-            if (node.type === 'ImportDeclaration') {
-                for (const specifier of node.specifiers) {
-                    if (specifier.type === 'ImportNamespaceSpecifier') {
-                        if (Object.values(contracts).some((link) => link.kind !== 'style-reference'))
-                            fail(moduleId, 'Import theme contracts by name; namespace imports are not supported.', specifier);
-                        const link = namespace(specifier.local.name);
-                        if (link)
-                            links[specifier.local.name] = link;
-                        continue;
-                    }
-                    if (specifier.type === 'ImportSpecifier' &&
-                        specifier.importKind === 'type')
-                        continue;
-                    const name = (() => {
-                        if (specifier.type === 'ImportDefaultSpecifier') {
-                            return 'default';
-                        }
-                        if (specifier.imported.type === 'Identifier') {
-                            return specifier.imported.name;
-                        }
-                        return specifier.imported.value;
-                    })();
-                    if (Object.hasOwn(contracts, name))
-                        links[specifier.local.name] = contracts[name];
-                    else {
-                        const value = constant(target, name);
-                        if (value)
-                            values[specifier.local.name] = relocate(value, specifier);
-                    }
-                }
-            }
-            else if (node.type === 'ExportAllDeclaration') {
-                if (node.exported) {
-                    if (Object.values(contracts).some((link) => link.kind !== 'style-reference'))
-                        fail(moduleId, 'Namespace theme re-exports are not supported.', node);
-                    const name = node.exported.type === 'Identifier'
-                        ? node.exported.name
-                        : node.exported.value;
-                    explicit.add(name);
-                    const link = namespace(name);
-                    if (link)
-                        forwarded[name] = link;
-                }
-                else
-                    stars.push(contracts);
-            }
-            else {
-                for (const specifier of node.specifiers) {
-                    if (specifier.exportKind === 'type')
-                        continue;
-                    const name = specifier.local.type === 'Identifier'
-                        ? specifier.local.name
-                        : specifier.local.value;
-                    const exported = specifier.exported.type === 'Identifier'
-                        ? specifier.exported.name
-                        : specifier.exported.value;
-                    explicit.add(exported);
-                    if (Object.hasOwn(contracts, name))
-                        forwarded[exported] = contracts[name];
-                }
-            }
-        }
-        const factories = Object.create(null);
-        for (const node of parsed.program.body) {
-            if (node.type !== 'ImportDeclaration' ||
-                node.importKind === 'type' ||
-                node.specifiers.every((specifier) => specifier.type === 'ImportSpecifier' &&
-                    specifier.importKind === 'type') ||
-                ['zyzz', 'zyzz/web'].includes(node.source.value))
-                continue;
-            const target = resolve(moduleId, node.source.value, node);
-            if (!target)
-                continue;
-            for (const specifier of node.specifiers) {
-                if (specifier.type !== 'ImportSpecifier' ||
-                    specifier.importKind === 'type')
-                    continue;
-                const name = specifier.imported.type === 'Identifier'
-                    ? specifier.imported.name
-                    : specifier.imported.value;
-                const found = factory(target, name);
-                if (found)
-                    factories[specifier.local.name] = found;
-            }
-        }
-        const result = Source.extract({
-            target: options.native ? 'native' : 'web',
-            compiler: options.compiler,
-            moduleId,
-            source,
-            [Themes.context]: { constants: values, factories, links, parsed },
-        });
-        function outputLink(link) {
-            return {
-                ...link,
-                ...(link.style
-                    ? {
-                        style: {
-                            ...link.style,
-                            style: {
-                                ...link.style.style,
-                                cssOutput: link.style.style.cssOutput ?? options.cssOutput ?? 'atomic',
-                            },
-                        },
-                    }
-                    : {}),
-                ...(link.members
-                    ? {
-                        members: Object.fromEntries(Object.entries(link.members).map(([name, member]) => [
-                            name,
-                            outputLink(member),
-                        ])),
-                    }
-                    : {}),
-            };
-        }
-        const exports = Object.assign(Object.create(null), forwarded, Object.fromEntries(Object.entries(result.themeExports ?? {}).map(([name, link]) => [
-            name,
-            outputLink(link),
-        ])));
-        for (const name of Object.keys(result.themeExports ?? {}))
-            explicit.add(name);
-        for (const contracts of stars)
-            for (const [name, link] of Object.entries(contracts)) {
-                if (name === 'default' || explicit.has(name))
-                    continue;
-                const previous = exports[name];
-                if (previous &&
-                    (previous.binding !== link.binding || previous.kind !== link.kind))
-                    fail(moduleId, `Ambiguous theme re-export: ${name}`);
-                exports[name] = link;
-            }
-        const linked = Object.freeze({
-            ...result,
-            themeExports: Object.freeze(exports),
-        });
-        return retain(moduleId, linked, Object.freeze([...imports]));
-    }
-    function retain(moduleId, result, imports) {
-        for (const call of result.variableCalls ?? [])
-            for (const slot of Object.values(call.slots)) {
-                const owner = moduleId.replace(/\.[cm]?[jt]sx?$/, '');
-                const previous = variableSlots.get(slot.name);
-                if (previous &&
-                    (previous.owner !== owner || previous.type !== slot.type))
-                    fail(moduleId, `Conflicting variable identity: ${slot.name}; supply distinct declaration ids.`, call);
-                variableSlots.set(slot.name, {
-                    owner,
-                    binding: `source:${call.start}`,
-                    type: slot.type,
-                });
-            }
-        extracted.set(moduleId, result);
-        dependencies[moduleId] = imports;
-        retained.delete(moduleId);
-        retained.set(moduleId, {
-            dependencies: imports,
-            extracted: result,
-            inputs: new Map(imports.map((target) => [
-                target,
-                libraries[target] ?? extracted.get(target),
-            ])),
-            resolution: resolutions[moduleId],
-            source: options.modules[moduleId],
-        });
-        if (retained.size > 256)
-            retained.delete(retained.keys().next().value);
-        for (const call of result.themeCalls)
-            for (const name of new Set([
-                call.name,
-                ...Object.values(call.members ?? {}),
-            ]))
-                owners[name] = {
-                    call: { ...call, name },
-                    moduleId,
-                    source: options.modules[moduleId],
-                };
-        Object.assign(themes, result.vars);
-        visiting.delete(moduleId);
-        return result;
-    }
-    for (const moduleId of ids)
-        visit(moduleId);
-    if (options.native) {
-        const native = options.native;
-        function packedLink(link) {
-            return {
-                ...link,
-                ...(link.style
-                    ? { style: { ...link.style, className: link.style.className ?? '' } }
-                    : {}),
-                ...(link.members
-                    ? {
-                        members: Object.fromEntries(Object.entries(link.members).map(([name, link]) => [
-                            name,
-                            packedLink(link),
-                        ])),
-                    }
-                    : {}),
-            };
-        }
-        const profiles = new Map();
-        const reserved = new Set([...identifiers.values()].flatMap((names) => [...names]));
-        function profile(moduleId) {
-            let value = profiles.get(moduleId);
-            if (!value) {
-                value = { definitions: new Map(), reads: new Map() };
-                profiles.set(moduleId, value);
-            }
-            return value;
-        }
-        function encode(read) {
-            try {
-                return JSON.stringify(NativeVars.compile({
-                    ...read,
-                    fonts: native.fonts,
-                    units: native.units,
-                }));
-            }
-            catch (error) {
-                throw new Native.CompileError(error.message);
-            }
-        }
-        function define(owner, value) {
-            const definitions = profile(owner).definitions;
-            let name = definitions.get(value);
-            if (!name) {
-                // Hashing the owner keeps names independent of which modules share the graph.
-                name = `__zyzzProfile${Identity.hash(owner + value)}`;
-                while (reserved.has(name))
-                    name += '_';
-                reserved.add(name);
-                definitions.set(value, name);
-            }
-            return name;
-        }
-        if (ids.some((id) => extracted.get(id).nativeVars?.length))
-            NativeStyleSheet.compile({
-                fonts: native.fonts,
-                platform: native.platform,
-                units: native.units,
-                styles: { styles: [] },
-            });
-        // Single-file adapters compile each owner without its consumers, so owners publish every exported profile.
-        if (native[Edits.runtime])
-            for (const moduleId of ids)
-                for (const link of Object.values(extracted.get(moduleId).themeExports ?? {})) {
-                    if (owners[link.call.name]?.moduleId !== moduleId ||
-                        !(link.call.variableSet ||
-                            (link.kind === 'config' &&
-                                link.call.variableConfig &&
-                                !link.call.initialization &&
-                                !link.call.root)))
-                        continue;
-                    const value = (() => {
-                        try {
-                            return encode(Themes.varsRead(link));
-                        }
-                        catch {
-                            // Consumers that read this profile report the same error.
-                            return undefined;
-                        }
-                    })();
-                    if (value !== undefined)
-                        define(moduleId, value);
-                }
-        for (const moduleId of ids) {
-            for (const read of extracted.get(moduleId).nativeVars ?? []) {
-                const owner = owners[read.owner]?.moduleId;
-                // Packed catalogs without source retain their local fallback.
-                if (!owner || !Object.hasOwn(options.modules, owner))
-                    continue;
-                const value = encode(read);
-                const name = native[Edits.runtime]
-                    ? profiles.get(owner)?.definitions.get(value)
-                    : define(owner, value);
-                if (!name)
-                    continue;
-                const source = (() => {
-                    if (owner === moduleId)
-                        return undefined;
-                    // Host identities are opaque, so reuse the consumer's own resolved specifier.
-                    if (native[Edits.runtime] && options.imports) {
-                        const imports = options.imports[moduleId] ?? {};
-                        return Object.keys(imports).find((key) => imports[key] === owner);
-                    }
-                    const from = moduleId.split('/').slice(0, -1);
-                    const to = owner.split('/');
-                    while (from.length && from[0] === to[0]) {
-                        from.shift();
-                        to.shift();
-                    }
-                    return ((from.length ? '../'.repeat(from.length) : './') +
-                        to.join('/').replace(/\.([cm]?)tsx?$/, '.$1js'));
-                })();
-                if (owner !== moduleId && !source)
-                    continue;
-                profile(moduleId).reads.set(read.start, {
-                    name,
-                    ...(source ? { source } : {}),
-                });
-            }
-        }
-        const modules = Object.fromEntries(ids.map((moduleId) => {
-            // Single-file profiles derive only from this module's extraction and its dependencies.
-            if (previous &&
-                (native[Edits.runtime] || !profiles.size) &&
-                extracted.get(moduleId) === previous.extracted.get(moduleId))
-                return [moduleId, previous.result.modules[moduleId]];
-            const imported = Object.create(null);
-            for (const statement of parse({
-                moduleId,
-                source: options.modules[moduleId],
-            }).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;
-                if ('specifiers' in statement &&
-                    statement.specifiers.length &&
-                    statement.specifiers.every((specifier) => specifier.type === 'ImportSpecifier'
-                        ? specifier.importKind === 'type'
-                        : specifier.type === 'ExportSpecifier' &&
-                            specifier.exportKind === 'type'))
-                    continue;
-                const target = resolve(moduleId, statement.source.value, statement);
-                if (target && libraries[target])
-                    imported[statement.source.value] = libraries[target].links;
-            }
-            const output = Native.compile({
-                ...native,
-                [NativeVars.shared]: profiles.get(moduleId),
-                moduleId,
-                source: options.modules[moduleId],
-                [Themes.context]: {
-                    parsed: parse({ moduleId, source: options.modules[moduleId] }),
-                    identifiers: identifiers.get(moduleId),
-                    extracted: extracted.get(moduleId),
-                    libraries: imported,
-                    links: {},
-                },
-            });
-            return [moduleId, nativeOutput(output)];
-        }));
-        return {
-            compiler: true,
-            composition: options.composition,
-            contracts,
-            cssOutput: options.cssOutput,
-            development: !!options.development,
-            extracted,
-            libraries: Object.freeze(libraries),
-            native: {
-                ...options.native,
-                ...(options.native.fonts && { fonts: { ...options.native.fonts } }),
-                ...(options.native.vars && { vars: { ...options.native.vars } }),
-                ...(options.native.units && { units: { ...options.native.units } }),
-            },
-            reset: options.reset,
-            entry: options[Stylesheets.entry],
-            retained,
-            transformed,
-            resolutions: Object.freeze(resolutions),
-            result: Object.freeze({
-                contracts: Object.freeze(Object.fromEntries(ids
-                    .filter((id) => Object.keys(extracted.get(id).themeExports ?? {}).length)
-                    .map((id) => [
-                    id,
-                    Contract.write(Object.fromEntries(Object.entries(extracted.get(id).themeExports ?? {}).map(([name, link]) => [name, packedLink(link)])), themes, [], id),
-                ]))),
-                dependencies: Object.freeze(dependencies),
-                modules: Object.freeze(modules),
-            }),
-            schemes: false,
-            sources: Object.freeze({ ...options.modules }),
-            themes: Object.freeze(themes),
-        };
-    }
-    const modules = Object.create(null);
-    const sharedThemes = Object.freeze(themes);
-    const sections = new Map();
-    for (const id of ids) {
-        const extractedModule = extracted.get(id);
-        const contributions = extractedModule.contributions ?? [];
-        if (!contributions.length) {
-            sections.set(id, []);
-            continue;
-        }
-        sections.set(id, contributions.map((contribution, index) => ({
-            source: id,
-            namespaces: extractedModule.namespaces,
-            key: String(index),
-            css: contribution.kind === 'layers'
-                ? ''
-                : (Css.compile({
-                    styles: { styles: [] },
-                    vars: sharedThemes,
-                    contributions: [contribution],
-                }).contributionCss ?? ''),
-            layers: contribution.kind === 'layers' ? [contribution.names] : [],
-            content: options.modules[id],
-            start: extractedModule.contributionStarts?.[index] ?? 0,
-        })));
-    }
-    for (const [id, library] of Object.entries(libraries))
-        sections.set(id, library.stylesheets.map((section) => {
-            let owner = id;
-            for (const specifier of section.dependency ?? []) {
-                const target = resolve(owner, specifier);
-                if (!target || !Object.hasOwn(libraries, target))
-                    fail(id, 'Repacked stylesheet dependencies require supplied library contracts.');
-                owner = target;
-            }
-            return {
-                ...section,
-                owner,
-                source: Stylesheets.resolve(owner, section.source),
-            };
-        }));
-    const resetOwners = ids.filter((id) => options.modules[id].includes('zyzz/reset.css') &&
-        parse({
-            moduleId: id,
-            source: options.modules[id],
-        }).program.body.some((node) => node.type === 'ImportDeclaration' &&
-            node.source.value === 'zyzz/reset.css'));
-    const layerNames = [
-        ...new Set(ids.flatMap((id) => reachable(id).flatMap((section) => section.layers.flat()))),
-    ].filter((name) => name !== 'reset');
-    for (const resetOwner of resetOwners) {
-        const entryLayers = [
-            ...new Set(reachable(resetOwner).flatMap((section) => section.layers.flat())),
-        ].filter((name) => name !== 'reset');
-        sections.set(resetOwner, [
-            {
-                source: resetOwner,
-                key: 'optional-reset-order',
-                css: '',
-                layers: entryLayers.length
-                    ? entryLayers.map((name) => ['reset', name])
-                    : [['reset']],
-            },
-            ...(sections.get(resetOwner) ?? []),
-        ]);
-    }
-    function dependencyPath(from, to) {
-        const queue = [{ id: from, path: [] }];
-        const seen = new Set();
-        while (queue.length) {
-            const current = queue.shift();
-            if (current.id === to)
-                return current.path;
-            if (seen.has(current.id))
-                continue;
-            seen.add(current.id);
-            for (const [specifier, target] of Object.entries(options.imports?.[current.id] ?? {}))
-                if (target)
-                    queue.push({ id: target, path: [...current.path, specifier] });
-        }
-        fail(from, 'Repacked stylesheet ownership requires a resolved dependency path.');
-    }
-    function reachable(id, visited = new Set()) {
-        if (visited.has(id))
-            return [];
-        visited.add(id);
-        return [
-            ...(dependencies[id] ?? []).flatMap((dependency) => reachable(dependency, visited)),
-            ...(sections.get(id) ?? []),
-        ];
-    }
-    const sharedVisited = new Set();
-    const packed = [];
-    const sharedSections = (() => {
-        try {
-            const entry = options[Stylesheets.entry];
-            const packedSections = entry === undefined
-                ? []
-                : (dependencies[entry] ?? [])
-                    .filter((id) => Object.hasOwn(libraries, id))
-                    .flatMap((id) => reachable(id, sharedVisited));
-            const sharedSections = entry === undefined
-                ? ids.flatMap((id) => reachable(id, sharedVisited))
-                : (sections.get(entry) ?? []);
-            if (packedSections.length) {
-                // Validate combined ownership and ordering before splitting independently loaded resources.
-                Stylesheets.render([...packedSections, ...sharedSections]);
-                for (const section of packedSections) {
-                    packed.push({
-                        id: JSON.stringify([section.owner, section.source, section.key]),
-                        ...Stylesheets.render([section]),
-                    });
-                }
-            }
-            const resetSource = (options.reset === undefined ? undefined : 'zyzz/reset.css') ??
-                resetOwners[0] ??
-                sharedSections.find((section) => section.key === 'optional-reset-order')
-                    ?.source;
-            if (packed.length) {
-                const order = Stylesheets.render([
-                    ...(resetSource === undefined
-                        ? []
-                        : [
-                            {
-                                source: resetSource,
-                                css: '',
-                                layers: layerNames.length
-                                    ? layerNames.map((name) => ['reset', name])
-                                    : [['reset']],
-                            },
-                        ]),
-                    ...[...packedSections, ...sharedSections].map((section) => ({
-                        ...section,
-                        css: '',
-                    })),
-                ]);
-                if (order.css)
-                    packed.unshift({ ...order, id: order.css });
-            }
-            return [
-                ...(resetSource === undefined
-                    ? []
-                    : [
-                        {
-                            source: resetSource,
-                            key: 'optional-reset-graph-order',
-                            css: '',
-                            layers: layerNames.length
-                                ? layerNames.map((name) => ['reset', name])
-                                : [['reset']],
-                        },
-                    ]),
-                ...sharedSections,
-                ...(options.reset === undefined || entry !== undefined
-                    ? []
-                    : [
-                        {
-                            source: 'zyzz/reset.css',
-                            key: 'optional-reset',
-                            css: options.reset,
-                            content: options.reset,
-                            layers: [['reset']],
-                        },
-                    ]),
-            ];
-        }
-        catch (error) {
-            return fail(error instanceof Stylesheets.ConflictError ? error.source : ids[0], error.message);
-        }
-    })();
-    function renderShared(sections) {
-        try {
-            return Stylesheets.render(sections);
-        }
-        catch (error) {
-            return fail(error instanceof Stylesheets.ConflictError ? error.source : ids[0], error.message);
-        }
-    }
-    const contributions = renderShared(sharedSections);
-    // Every stylesheet includes all graph scopes, including unimported alternatives.
-    const names = Object.keys(themes);
-    const previousNames = Object.keys(previous?.themes ?? {});
-    const sameThemes = previous &&
-        names.length === previousNames.length &&
-        names.every((name, index) => name === previousNames[index] && previous.themes[name] === themes[name]);
-    const styleClasses = Object.create(null);
-    function published(link) {
-        if (link.style?.className !== undefined)
-            styleClasses[link.binding] = link.style.className;
-        for (const member of Object.values(link.members ?? {}))
-            published(member);
-    }
-    for (const library of Object.values(libraries))
-        for (const link of Object.values(library.links))
-            published(link);
-    const emittedRules = new Map();
-    function registerRules(classRules, moduleId) {
-        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 [moduleId, library] of Object.entries(libraries))
-        registerRules(library.classRules, moduleId);
-    if (options.compiler === false) {
-        const identities = new Map();
-        for (const [moduleId, library] of Object.entries(libraries)) {
-            function register(name, signature) {
-                const previous = identities.get(name);
-                if (previous !== undefined && previous !== signature)
-                    fail(moduleId, 'The same explicit identity is used for different definitions.');
-                identities.set(name, signature);
-            }
-            for (const [name, theme] of Object.entries(library.themes)) {
-                const data = theme[Token.definition];
-                if (data.contract[Token.identity]?.startsWith('id-'))
-                    register(`theme:${name}`, JSON.stringify(data.values));
-            }
-            function styles(link) {
-                for (const name of link.style?.className?.split(' ') ?? [])
-                    if (name.startsWith('z-style-id-'))
-                        register(name, Identity.style(link.style.style));
-                for (const member of Object.values(link.members ?? {}))
-                    styles(member);
-            }
-            for (const link of Object.values(library.links))
-                styles(link);
-        }
-        for (const [moduleId, module] of extracted) {
-            function register(name, signature) {
-                const previous = identities.get(name);
-                if (previous !== undefined && previous !== signature)
-                    return fail(moduleId, 'The same explicit identity is used for different definitions.');
-                identities.set(name, signature);
-            }
-            for (const [name, theme] of Object.entries(module.vars)) {
-                const data = theme[Token.definition];
-                if (data.contract[Token.identity]?.startsWith('id-'))
-                    register(`theme:${name}`, JSON.stringify(data.values));
-            }
-            for (const contribution of module.contributions ?? [])
-                if ('name' in contribution)
-                    register(`${contribution.kind}:${contribution.name}`, Css.compile({
-                        styles: { styles: [] },
-                        contributions: [contribution],
-                    }).css);
-            for (const call of module.calls) {
-                if (!call.portable?.startsWith('z-style-id-'))
-                    continue;
-                const signature = Identity.style(module.styles.styles.find((style) => style.name === call.name));
-                const previous = identities.get(call.portable);
-                if (previous !== undefined && previous !== signature)
-                    return fail(moduleId, 'The same explicit style id is used for different declarations.');
-                identities.set(call.portable, signature);
-            }
-        }
-    }
-    // Selection anywhere in the graph applies scheme classes beside scopes every
-    // stylesheet carries, so each stylesheet declares the matching color-scheme.
-    const schemes = [...extracted.values()].some((module) => Boolean(module.themeAppearances?.length ||
-        module.themeScripts?.length ||
-        module.themeSelections?.length));
-    const ownerSignature = JSON.stringify(owners);
-    const units = ClassName.registry();
-    const closures = new Map();
-    function closure(moduleId) {
-        const cached = closures.get(moduleId);
-        if (cached)
-            return cached;
-        const result = new Set();
-        closures.set(moduleId, result);
-        for (const dependency of dependencies[moduleId] ?? []) {
-            result.add(dependency);
-            for (const nested of closure(dependency))
-                result.add(nested);
-        }
-        return result;
-    }
-    // Hosts that compile a module within several graphs must name it the same in
-    // each, so it may reuse only names its dependencies introduce.
-    function visible(moduleId) {
-        if (options[ClassName.complete])
-            return undefined;
-        return (owner) => closure(moduleId).has(owner);
-    }
-    function restore(moduleId, output) {
-        return units.restore({
-            owner: moduleId,
-            used: output[ClassName.units] ?? new Map(),
-            visible: visible(moduleId),
-        });
-    }
-    // Extraction visits dependencies first; their emitted classes must precede consumers.
-    for (const moduleId of extracted.keys()) {
-        const cached = transformed.get(moduleId);
-        const reusable = cached &&
-            cached.extracted === extracted.get(moduleId) &&
-            cached.schemes === schemes &&
-            Object.keys(cached.themes).length === names.length &&
-            names.every((name) => cached.themes[name] === themes[name]) &&
-            Object.entries(cached.classes).every(([name, value]) => styleClasses[name] === value) &&
-            cached.owners === ownerSignature &&
-            restore(moduleId, cached.output);
-        modules[moduleId] = reusable
-            ? cached.output
-            : sameThemes &&
-                previous.schemes === schemes &&
-                extracted.get(moduleId) === previous.extracted.get(moduleId) &&
-                restore(moduleId, previous.result.modules[moduleId])
-                ? previous.result.modules[moduleId]
-                : Transform.compile({
-                    [ClassName.units]: units.scope({
-                        owner: moduleId,
-                        qualifier: Identity.compact(moduleId).slice(-6),
-                        visible: visible(moduleId),
-                    }),
-                    [ThemeRules.shared]: options[Stylesheets.entry] === undefined
-                        ? (options[ThemeRules.shared] ?? 'defaults')
-                        : 'all',
-                    compiler: options.compiler,
-                    development: options.development,
-                    composition: options.composition,
-                    cssOutput: options.cssOutput,
-                    moduleId,
-                    schemes,
-                    source: options.modules[moduleId],
-                    [Themes.context]: {
-                        parsed: parse({ moduleId, source: options.modules[moduleId] }),
-                        extracted: Object.freeze({
-                            ...extracted.get(moduleId),
-                            vars: sharedThemes,
-                            contributions: undefined,
-                        }),
-                        links: {},
-                        owners,
-                        styleClasses,
-                    },
-                });
-        transformed.delete(moduleId);
-        transformed.set(moduleId, {
-            classes: Object.fromEntries(extracted
-                .get(moduleId)
-                .calls.flatMap((call) => (call.runtimeComposition ?? []).map((input) => [
-                input.name,
-                styleClasses[input.name],
-            ]))),
-            extracted: extracted.get(moduleId),
-            owners: ownerSignature,
-            output: modules[moduleId],
-            schemes,
-            themes: sharedThemes,
-        });
-        if (transformed.size > 256)
-            transformed.delete(transformed.keys().next().value);
-        registerRules(modules[moduleId][ClassName.rules], moduleId);
-        for (const call of extracted.get(moduleId).calls)
-            if (call.identity &&
-                !call.composition &&
-                !call.runtimeComposition &&
-                !call.compositionCase)
-                styleClasses[call.identity] = modules[moduleId].classes[call.name];
-    }
-    const defaults = new Set();
-    const defaultRules = new Map();
-    const defaultSections = [];
-    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);
-                defaultRules.set(source, rules);
-            }
-    const shared = defaults.size
-        ? renderShared([
-            ...sharedSections,
-            ...defaultSections,
-            ...[...defaultRules].map(([source, rules]) => ({
-                css: ThemeRules.render(rules),
-                key: 'theme-defaults',
-                layers: [],
-                source,
-            })),
-        ])
-        : contributions;
-    const sharedCss = shared.css;
-    function publishedRules(id, visited = new Set()) {
-        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) {
-        return {
-            ...link,
-            ...(link.style
-                ? {
-                    style: {
-                        ...link.style,
-                        className: styleClasses[link.binding] ?? link.style.className,
-                    },
-                }
-                : {}),
-            ...(link.members
-                ? {
-                    members: Object.fromEntries(Object.entries(link.members).map(([name, member]) => [
-                        name,
-                        publishedStyle(member),
-                    ])),
-                }
-                : {}),
-        };
-    }
-    // A configuration whose module uses root controls or the script publishes its
-    // catalog, exported or not, so initialization restores selections it persists.
-    function configurations(id) {
-        const module = extracted.get(id);
-        return module.themeCalls
-            .filter((call) => call.appearance &&
-            call.options &&
-            (module.themeAppearances?.includes(call.name) ||
-                module.themeScripts?.includes(call.name)))
-            .map((call) => {
-            const themeNames = call.options?.themes;
-            return {
-                identity: sharedThemes[call.name]?.[Token.definition].contract[Token.identity] ?? call.name,
-                ...(typeof call.options?.storageKey === 'string'
-                    ? { storageKey: call.options.storageKey }
-                    : {}),
-                themes: themeNames && typeof themeNames === 'object'
-                    ? Object.keys(themeNames)
-                    : [],
-            };
-        });
-    }
+/** The engine's graph input. */
+function encode(options) {
     return {
-        compiler: options.compiler !== false,
-        shared: options[ThemeRules.shared],
+        complete: options[ClassName.complete],
+        compiler: options.compiler,
         composition: options.composition,
+        contracts: options.contracts,
         cssOutput: options.cssOutput,
-        contracts,
-        development: !!options.development,
-        extracted,
-        libraries: Object.freeze(libraries),
-        native: undefined,
-        reset: options.reset,
+        development: options.development,
         entry: options[Stylesheets.entry],
-        retained,
-        transformed,
-        resolutions: Object.freeze(resolutions),
-        result: Object.freeze({
-            ...(options[Stylesheets.entry] !== undefined &&
-                options.reset !== undefined
-                ? {
-                    [Stylesheets.reset]: {
-                        id: 'zyzz/reset.css',
-                        ...Stylesheets.render([
-                            {
-                                content: options.reset,
-                                css: options.reset,
-                                layers: [['reset']],
-                                source: 'zyzz/reset.css',
-                            },
-                        ]),
-                    },
-                }
-                : {}),
-            ...(packed.length ? { [Stylesheets.packed]: packed } : {}),
-            ...(sharedCss
-                ? {
-                    sharedCss,
-                    sharedCssMap: shared.map,
-                    sharedAssets: shared.assets,
-                    sharedAssetOwners: shared.owners,
-                }
-                : {}),
-            contracts: Object.freeze(Object.fromEntries((options[Stylesheets.entry] === undefined ? ids : [])
-                .filter((id) => Object.keys(extracted.get(id).themeExports ?? {}).length ||
-                reachable(id).length ||
-                configurations(id).length)
-                .map((id) => [
-                id,
-                Contract.write(Object.fromEntries(Object.entries(extracted.get(id).themeExports ?? {}).map(([name, link]) => [name, publishedStyle(link)])), sharedThemes, reachable(id).map((section) => ({
-                    ...section,
-                    owner: undefined,
-                    dependency: section.owner && section.owner !== id
-                        ? dependencyPath(id, section.owner)
-                        : undefined,
-                    source: Stylesheets.relative(section.owner ?? id, section.source),
-                })), id, configurations(id), publishedRules(id)),
-            ]))),
-            dependencies: Object.freeze(dependencies),
-            modules: Object.freeze(Object.fromEntries(ids.map((id) => [id, modules[id]]))),
-        }),
-        schemes,
-        sources: Object.freeze({ ...options.modules }),
-        themes: sharedThemes,
+        imports: options.imports,
+        lean: options[Results.lean],
+        modules: options.modules,
+        native: options.native && Results.native(options.native),
+        reset: options.reset,
+        shared: options[ThemeRules.shared],
     };
 }
-// A returned lazy map must not retain the graph compilation context.
-function nativeOutput(output) {
-    let sourceMap;
+/** Creates an isolated compiler with bounded extraction reuse across source graphs. */
+export function create() {
+    const decoded = new Map();
+    // The engine compiler owns the caches, and collecting this object releases them.
+    let engine;
+    let result;
+    // The engine holds the sources of its last decoded snapshot, so a source equal to the one sent
+    // last crosses the boundary as `0`. A failed call leaves nothing sent, which resends every source.
+    let sent;
     return Object.freeze({
-        [ClassName.rules]: Object.freeze({}),
-        classes: Object.freeze({}),
-        [Edits.key]: output[Edits.key],
-        code: output.code,
-        css: '',
-        cssMap: {
-            version: 3,
-            names: [],
-            sources: [],
-            mappings: '',
-        },
-        get map() {
-            return (sourceMap ??= JSON.parse(output.map));
+        compile(options) {
+            engine ??= new (Addon.load().Graph)();
+            const input = encode(options);
+            const previous = sent;
+            sent = undefined;
+            const text = (() => {
+                if (!previous)
+                    return engine.compile(JSON.stringify(input));
+                const output = engine.compile(JSON.stringify({
+                    ...input,
+                    contracts: unchanged(input.contracts, previous.contracts),
+                    modules: unchanged(input.modules, previous.modules),
+                }));
+                return output === stale ? engine.compile(JSON.stringify(input)) : output;
+            })();
+            result = Results.graph(Results.decode(text), result, decoded);
+            // Hosts may update their records in place, so the sent text is copied.
+            sent = {
+                contracts: input.contracts && { ...input.contracts },
+                modules: { ...input.modules },
+            };
+            return result;
         },
-        vars: Object.freeze({}),
     });
 }
 //# sourceMappingURL=Graph.js.map