@swiftbrowser/cli 0.6.7 → 0.7.0

package/dist/wasmCompiler.js

@@ -0,0 +1,628 @@
+// Building the staged app with the Swift compiler and linker built as
+// WebAssembly (@swiftbrowser/wasm-compiler, docs/in-browser-compiler.md
+// Milestone 2) instead of `swift build`: what the browser playground does,
+// and what needs no Swift install. compiler.ts decides when it runs
+// (SWIFTBROWSER_COMPILER).
+//
+// It reproduces SwiftPM's release build of the staging package (stage.ts):
+// one whole-module frontend job for the app's sources against the kit's
+// modules, the ICU data as an object, and a link with the app's exports and
+// the kit's archives of the products the app imports, linked whole. The
+// Swift SDK's files come from wasmSdk.ts: the native toolchain's install or
+// the CLI's own download.
+//
+// Macros expand through plugins built as WebAssembly, which the host runs for
+// the compiler: the shim's (SwiftDataMacros) from the kit, which builds them
+// from the same sources as its modules (kit.ts), and the toolchain's
+// (ObservationMacros, SwiftMacros) from the tools' `plugins` directory.
+// Package dependencies (the copies vendor.ts makes) are compiled module by
+// module first (wasmPackages.ts).
+import { createHash } from 'node:crypto';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { diagnosticsOnly } from './build.js';
+import { KIT_TRIPLE, kitArchive, kitWasmPlugins } from './kit.js';
+import { CliError, dim, info } from './log.js';
+import { planPackages } from './packages.js';
+import { appLinkerFlags, commonDirectory, linkedProducts, remapDiagnostics, testTargetPath } from './stage.js';
+import { testRunnerSource, xctestCases } from './testDiscovery.js';
+import { dumpVendored, generatedModuleMap, packageModules, resourceBundleAccessor } from './wasmPackages.js';
+import { evaluateManifest } from './manifest.js';
+import { VERIFY_NONE, appFrontendFlags, kitTargets } from './wasmFlags.js';
+import { WASI_EMULATION_FLAGS, importsCoreFoundation } from './appSources.js';
+import { hashFiles, hashStats, restoreOutputs, storeOutputs, treeFiles } from './moduleCache.js';
+export { appFrontendFlags, kitTargets } from './wasmFlags.js';
+import { cacheDir } from './toolchain.js';
+export async function load() {
+    const specifier = '@swiftbrowser/wasm-compiler';
+    try {
+        const compiler = (await import(specifier));
+        const node = (await import(`${specifier}/node`));
+        return { compiler, node };
+    }
+    catch (error) {
+        throw new CliError(`the WebAssembly compiler needs @swiftbrowser/wasm-compiler, built (npm run build --workspace packages/wasm-compiler): ${error.message}`);
+    }
+}
+/** SWIFTBROWSER_WASM_TOOLS: a directory of the tools (a build's toolchain/install-tools.sh output) in place of @swiftbrowser/wasm-tools. */
+export function toolsDir(env = process.env) {
+    return env['SWIFTBROWSER_WASM_TOOLS'] || undefined;
+}
+/** What keeps the WebAssembly compiler from running here, or null when it can. */
+export async function wasmToolsProblem(env = process.env) {
+    try {
+        const { node } = await load();
+        const tools = node.findTools(toolsDir(env));
+        const missing = Object.values(tools).filter((file) => !existsSync(file));
+        return missing.length > 0 ? `the WebAssembly tools are missing (${missing.join(', ')})` : null;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message.split('\n')[0] : String(error);
+    }
+}
+/** The plugins the compiler loads: the tools' (the toolchain's macros), then the kit's in place of any the tools also have. */
+async function pluginFiles(kit) {
+    const { node } = await load();
+    return { ...node.findPlugins(toolsDir()), ...kitWasmPlugins(kit) };
+}
+/**
+ * The plugins as the compiler sees them: each directory mounted at
+ * /plugin-<module> (the tools' and the kit's are in different places; a mount
+ * two levels down, /plugins/<module>, is not found, as /plugins itself is not
+ * there), the guest path → host file map the host runs them from, and the
+ * frontend flags that name each with the module whose macros it has.
+ */
+function pluginSetup(plugins) {
+    const mounts = {};
+    const files = {};
+    const flags = [];
+    for (const [name, file] of Object.entries(plugins)) {
+        const guest = `/plugin-${name}/${path.basename(file)}`;
+        mounts[`/plugin-${name}`] = path.dirname(file);
+        files[guest] = file;
+        flags.push('-load-plugin-executable', `${guest}#${name}`);
+    }
+    return { mounts, files, flags };
+}
+/** The SDK's target directory, the root the tools see as /sdk. */
+function sdkMount(sdk) {
+    return sdk.root;
+}
+/**
+ * Type-checks Swift files against the kit with the WebAssembly frontend: what
+ * `check` runs, and how a released kit is checked against the compiler.
+ * `files` are host paths under `dir`; `flags` the frontend flags besides the
+ * kit's module path. Returns the diagnostics with host paths.
+ */
+export async function wasmTypecheck(options) {
+    const { compiler, node } = await load();
+    const plugins = pluginSetup(await pluginFiles(options.kit));
+    const work = path.join(cacheDir(), 'wasm-compiler', 'typecheck');
+    mkdirSync(work, { recursive: true });
+    const host = node.wasiHost({
+        tools: node.findTools(toolsDir()),
+        mounts: { '/sdk': sdkMount(options.sdk), '/kit': options.kit.dir, '/src': options.dir, '/work': work, ...plugins.mounts },
+        sdkRoot: '/sdk',
+        moduleCacheDir: path.join(cacheDir(), 'wasm-compiler', 'module-cache'),
+        plugins: plugins.files,
+    });
+    const sources = options.files.map((file) => `/src/${path.relative(options.dir, file).split(path.sep).join('/')}`);
+    const result = await compiler.compile(host, {
+        moduleName: options.moduleName,
+        sources,
+        objectDir: '/work',
+        wholeModule: true,
+        frontendFlags: ['-I', `/kit/${KIT_TRIPLE}/Modules`, ...(options.flags ?? []), ...plugins.flags],
+    });
+    return {
+        ok: result.ok,
+        output: result.output.split('/src/').join(`${options.dir}${path.sep}`),
+        seconds: result.steps.reduce((sum, step) => sum + step.seconds, 0),
+    };
+}
+function swiftSources(dir, relative = '') {
+    return readdirSync(path.join(dir, relative), { withFileTypes: true }).flatMap((entry) => {
+        const file = path.join(relative, entry.name);
+        if (entry.isDirectory())
+            return swiftSources(dir, file);
+        return entry.isFile() && entry.name.endsWith('.swift') ? [file] : [];
+    }).sort();
+}
+/**
+ * The manifests of the packages the app builds: the copies made for the shim
+ * (read from the copy, whose manifest adds the shim's products) and the plain
+ * packages (from their checkouts), read with the WebAssembly compiler
+ * (manifest.ts). Tools without PackageDescription leave it to SwiftPM, for the
+ * copies, as before it.
+ */
+async function packageDumps(sdk, vendored, packages, toolchain) {
+    const { node } = await load();
+    if (!node.findManifestApi(toolsDir())) {
+        if (!toolchain || packages.some((pkg) => !vendored.has(pkg.identity))) {
+            throw new CliError('the WebAssembly tools have no PackageDescription to read the app\'s packages with; update @swiftbrowser/wasm-tools');
+        }
+        return vendored.size > 0 ? dumpVendored(toolchain, vendored) : new Map();
+    }
+    const dirs = new Map();
+    for (const [identity, copy] of vendored)
+        if (!copy.standIn)
+            dirs.set(identity, copy.dir);
+    for (const pkg of packages)
+        if (!vendored.has(pkg.identity))
+            dirs.set(pkg.identity, pkg.path);
+    const dumps = new Map();
+    for (const [identity, dir] of dirs) {
+        const { dump, dependencies } = await evaluateManifest(dir, sdk);
+        const original = vendored.has(identity) ? packages.find((pkg) => pkg.identity === identity)?.path : undefined;
+        dumps.set(identity, { dir, dump, dependencies, ...(original ? { originalDir: original } : {}) });
+    }
+    return dumps;
+}
+/**
+ * Sets up the WebAssembly tools for a build of the staged app (the kit, the
+ * app and its packages mounted, the macro plugins) and compiles the packages'
+ * modules the app uses, each after those it imports.
+ */
+async function compilePackages(options, kit, work) {
+    const { staged, app } = options;
+    const vendored = options.vendored ?? new Map();
+    const { compiler, node } = await load();
+    mkdirSync(path.join(work, 'modules'), { recursive: true });
+    // Each plugin is named to the compiler by its path, with the module whose
+    // macros it has; the host runs it, and the compiler checks the file is there.
+    const files = await pluginFiles(kit);
+    if (staged.features.swiftData && !files['SwiftDataMacros']) {
+        throw new CliError('the WebAssembly compiler needs the SwiftDataMacros plugin built as WebAssembly for SwiftData');
+    }
+    const plugins = pluginSetup(files);
+    const packages = await packageDumps(options.sdk, vendored, options.packages ?? [], options.toolchain);
+    // The products the app names; a package's own dependencies follow from its targets.
+    const used = new Map();
+    for (const plan of planPackages(app.packages))
+        if (plan.kind === 'dependency')
+            used.set(plan.identity, [...plan.package.products]);
+    const modules = packageModules(packages, new Set(Object.keys(kit.manifest.products)), used);
+    const mounts = { '/sdk': sdkMount(options.sdk), '/kit': kit.dir, '/app': staged.dir, '/work': work };
+    for (const [identity, { dir, originalDir }] of packages) {
+        mounts[`/packages/${identity}`] = dir;
+        mounts[`/originals/${identity}`] = originalDir ?? dir;
+    }
+    Object.assign(mounts, plugins.mounts);
+    const tools = node.findTools(toolsDir());
+    const host = node.wasiHost({
+        tools,
+        mounts,
+        sdkRoot: '/sdk',
+        moduleCacheDir: path.join(cacheDir(), 'wasm-compiler', 'module-cache'),
+        plugins: plugins.files,
+    });
+    const pluginFlags = plugins.flags;
+    const kitModules = `/kit/${KIT_TRIPLE}/Modules`;
+    const hostPaths = (text) => {
+        let out = text.split('/app/').join(`${staged.dir}${path.sep}`);
+        for (const [identity, { dir }] of packages)
+            out = out.split(`/packages/${identity}/`).join(`${dir}${path.sep}`);
+        return out;
+    };
+    const steps = [];
+    const packageObjects = [];
+    // A module's files as the tools see them: the package as the app builds it
+    // (its copy for the shim, if any), or as a plugin does (`/originals`).
+    const guestIn = (root) => (module, file) => `/${root}/${module.identity}/${file.split(path.sep).join('/')}`;
+    const guest = guestIn('packages');
+    const onStep = (step) => options.onOutput?.(`${step.tool} ${step.args.join(' ')}\n`);
+    const fail = (output) => {
+        throw new CliError(hostPaths(diagnosticsOnly(output) || output));
+    };
+    // The host file of a path the tools see under /work, /packages or /originals.
+    const hostOf = (guest) => {
+        const [, root, first, ...rest] = guest.split('/');
+        if (root === 'work')
+            return path.join(work, first, ...rest);
+        const pkg = packages.get(first);
+        if (pkg && root === 'packages')
+            return path.join(pkg.dir, ...rest);
+        if (pkg && root === 'originals')
+            return path.join(pkg.originalDir ?? pkg.dir, ...rest);
+        throw new Error(`no host file for ${guest}`);
+    };
+    // The packages' modules the app links are kept between builds
+    // (moduleCache.ts), keyed by what goes into each: the tools, the kit, the
+    // SDK, its flags and files, and the keys of the modules and plugins it
+    // imports. (Plugins have their own cache, below.)
+    const cachedModules = path.join(cacheDir(), 'wasm-compiler', 'packages');
+    const stamp = createHash('sha256').update(`package modules 1\n${options.sdk.root}\n`);
+    hashStats(stamp, [...Object.values(tools).filter((file) => !!file), ...Object.values(files), ...treeFiles(kit.dir)]);
+    const buildStamp = stamp.digest('hex');
+    const moduleKeys = new Map();
+    const moduleKey = (module, flags, inputs) => {
+        const hash = createHash('sha256').update(`${buildStamp}\n${module.identity}/${module.name}\n${JSON.stringify(flags)}\n`);
+        for (const name of [...module.dependencies, ...module.cModules, ...module.macros])
+            hash.update(`${name} ${moduleKeys.get(name) ?? '-'}\n`);
+        hashFiles(hash, inputs);
+        return hash.digest('hex').slice(0, 24);
+    };
+    const reused = [];
+    // The module's outputs (guest paths) from the cache, else built and stored.
+    const cached = async (module, key, build) => {
+        moduleKeys.set(module.name, key);
+        const entry = path.join(cachedModules, `${module.name}-${key}`);
+        const restored = restoreOutputs(entry, hostOf);
+        if (restored) {
+            reused.push(module.name);
+            return restored;
+        }
+        const outputs = await build();
+        storeOutputs(entry, outputs, hostOf);
+        return outputs;
+    };
+    const byName = new Map(modules.map((module) => [module.name, module]));
+    const closure = (module) => {
+        const found = new Map();
+        const walk = (m) => {
+            for (const name of m.dependencies) {
+                if (found.has(name))
+                    continue;
+                found.set(name, byName.get(name));
+                walk(byName.get(name));
+            }
+        };
+        walk(module);
+        return [...found.values()];
+    };
+    const optimization = options.debug ? ['-Onone'] : ['-O', '-enable-default-cmo'];
+    // Plugins compile unoptimized: swift-syntax takes minutes optimized as
+    // WebAssembly, and a macro expands quickly enough without.
+    const PLUGIN_OPTIMIZATION = ['-Onone'];
+    const loadPlugins = (macros) => macros.flatMap((m) => ['-load-plugin-executable', `/work/plugins/${m}.wasm#${m}`]);
+    const clangFlags = (c) => [...(c.map ? ['-Xcc', `-fmodule-map-file=${c.map}`] : []), '-Xcc', `-I${c.include}`];
+    // A C module compiled as SwiftPM compiles a C target
+    // (ClangModuleBuildDescription.basicArguments), with its module map.
+    const compileClang = async (module, root, out, reached) => {
+        if (!tools.clang)
+            throw new CliError(`the WebAssembly tools have no clang to build ${module.name}, a C target of ${module.identity}; update @swiftbrowser/wasm-tools`);
+        const at = guestIn(root);
+        const clang = module.clang;
+        const include = at(module, clang.includeDir);
+        const sources = module.sources.map((file) => at(module, file));
+        const flags = [
+            ...(options.debug ? ['-O0', '-DDEBUG=1'] : ['-O2']), '-DSWIFT_PACKAGE=1', '-fblocks',
+            '-I', include,
+            ...clang.headerSearchPaths.flatMap((dir) => ['-I', at(module, dir)]),
+            ...reached.flatMap((c) => ['-I', c.include]),
+            ...module.flags,
+        ];
+        const compile = async () => {
+            const built = await compiler.compileC(host, { sources, objectDir: `/work/${out}/${module.name}`, root: `/${root}/${module.identity}`, flags, onStep });
+            steps.push(...built.steps.map((step) => ({ ...step, tool: `${module.name} (${step.tool})` })));
+            if (!built.ok)
+                fail(built.output);
+            return built.objects;
+        };
+        // Its headers are inputs too: the target's directory, its public headers and its search paths.
+        const sourceDir = commonDirectory(module.sources);
+        const headers = [sourceDir, clang.includeDir, ...clang.headerSearchPaths].flatMap((dir) => treeFiles(hostOf(at(module, dir))));
+        const objects = root === 'packages'
+            ? await cached(module, moduleKey(module, flags, [...new Set([...sources.map(hostOf), ...headers])]), compile)
+            : await compile();
+        let map;
+        if (clang.moduleMap && 'custom' in clang.moduleMap)
+            map = at(module, clang.moduleMap.custom);
+        else if (clang.moduleMap) {
+            writeFileSync(path.join(work, out, module.name, 'module.modulemap'), generatedModuleMap(module.name, 'umbrellaHeader' in clang.moduleMap
+                ? { umbrellaHeader: at(module, clang.moduleMap.umbrellaHeader) }
+                : { umbrellaDirectory: at(module, clang.moduleMap.umbrellaDirectory) }));
+            map = `/work/${out}/${module.name}/module.modulemap`;
+        }
+        return { objects, include, ...(map ? { map } : {}) };
+    };
+    // Macro targets become WebAssembly plugins, built as the compiler runs
+    // them: from the packages' own sources (not their copies for the shim),
+    // without the kit, into a module directory of their own. They are cached by
+    // what goes into them, so that swift-syntax compiles once.
+    mkdirSync(path.join(work, 'plugins'), { recursive: true });
+    mkdirSync(path.join(work, 'plugin-modules'), { recursive: true });
+    const cachedPlugins = path.join(cacheDir(), 'wasm-compiler', 'plugins');
+    const pluginKey = (macro) => {
+        const hash = createHash('sha256').update(`plugin 2\n${statSync(tools['swift-frontend']).size}\n`);
+        for (const m of [macro, ...closure(macro)]) {
+            hash.update(`${m.identity}/${m.name} ${m.flags.join(' ')}\n`);
+            const { dir, originalDir } = packages.get(m.identity);
+            for (const file of m.sources)
+                if (existsSync(path.join(originalDir ?? dir, file)))
+                    hash.update(`${file}\n`).update(readFileSync(path.join(originalDir ?? dir, file)));
+        }
+        return hash.digest('hex').slice(0, 24);
+    };
+    // A module's own sources, as its package has them: not the files its copy for the shim adds.
+    const originalSources = (m) => {
+        const { dir, originalDir } = packages.get(m.identity);
+        return m.sources.filter((file) => existsSync(path.join(originalDir ?? dir, file)));
+    };
+    const forPlugins = new Map();
+    const buildForPlugin = async (module) => {
+        if (forPlugins.has(module.name))
+            return;
+        for (const dependency of module.dependencies)
+            await buildForPlugin(byName.get(dependency));
+        mkdirSync(path.join(work, 'plugin-packages', module.name), { recursive: true });
+        const reached = module.cModules.map((name) => forPlugins.get(name));
+        if (module.clang) {
+            forPlugins.set(module.name, await compileClang(module, 'originals', 'plugin-packages', reached));
+            return;
+        }
+        const built = await compiler.compile(host, {
+            moduleName: module.name,
+            sources: originalSources(module).map((file) => guestIn('originals')(module, file)),
+            objectDir: `/work/plugin-packages/${module.name}`,
+            emitModule: `/work/plugin-modules/${module.name}.swiftmodule`,
+            frontendFlags: [
+                '-I', '/work/plugin-modules', ...module.flags, ...reached.flatMap(clangFlags), ...PLUGIN_OPTIMIZATION, ...VERIFY_NONE,
+                '-D', 'SWIFT_PACKAGE', '-package-name', module.identity, ...loadPlugins(module.macros),
+            ],
+            onStep,
+        });
+        steps.push(...built.steps.map((step) => ({ ...step, tool: `${module.name} for plugins (${step.tool})` })));
+        if (!built.ok)
+            fail(built.output);
+        forPlugins.set(module.name, { objects: built.objects });
+    };
+    const buildPlugin = async (macro) => {
+        const plugin = path.join(work, 'plugins', `${macro.name}.wasm`);
+        const key = pluginKey(macro);
+        moduleKeys.set(macro.name, key);
+        const cachedPlugin = path.join(cachedPlugins, `${macro.name}-${key}.wasm`);
+        if (!existsSync(cachedPlugin)) {
+            const deps = closure(macro);
+            for (const dependency of deps)
+                await buildForPlugin(dependency);
+            const sources = originalSources(macro).map((file) => guestIn('originals')(macro, file));
+            mkdirSync(path.join(work, 'plugin-packages', macro.name), { recursive: true });
+            // An executable whose `swift_wasm_macro_v1_pump` the host calls
+            // (swift-syntax's CompilerPlugin, 601 and later).
+            const built = await compiler.compile(host, {
+                moduleName: macro.name,
+                sources,
+                objectDir: `/work/plugin-packages/${macro.name}`,
+                output: `/work/plugins/${macro.name}.wasm`,
+                wholeModule: true,
+                frontendFlags: [
+                    '-I', '/work/plugin-modules', ...macro.flags,
+                    ...macro.cModules.flatMap((name) => clangFlags(forPlugins.get(name))),
+                    ...PLUGIN_OPTIMIZATION, ...VERIFY_NONE, '-D', 'SWIFT_PACKAGE', '-package-name', macro.identity, ...loadPlugins(macro.macros),
+                    ...(sources.some((file) => file.endsWith('/main.swift')) ? [] : ['-parse-as-library']),
+                ],
+                objects: deps.flatMap((m) => forPlugins.get(m.name).objects),
+                linkerFlags: ['--gc-sections'],
+                onStep,
+            });
+            steps.push(...built.steps.map((step) => ({ ...step, tool: `${macro.name} plugin (${step.tool})` })));
+            if (!built.ok)
+                fail(built.output);
+            mkdirSync(cachedPlugins, { recursive: true });
+            copyFileSync(plugin, cachedPlugin);
+        }
+        else {
+            copyFileSync(cachedPlugin, plugin);
+        }
+        host.addPlugin(`/work/plugins/${macro.name}.wasm`, plugin);
+    };
+    // CoreFoundation's headers include wasi-libc's signal.h and sys/mman.h,
+    // which stop without the emulations' defines (the link has their
+    // libraries). Only a module that imports it gets them: other modules keep
+    // the module cache's usual configuration.
+    const usesCoreFoundation = (module) => {
+        const { dir } = packages.get(module.identity);
+        return module.sources.some((file) => file.endsWith('.swift') && importsCoreFoundation(readFileSync(path.join(dir, file), 'utf8')));
+    };
+    const clangModules = new Map();
+    for (const module of modules) {
+        if (module.macro) {
+            await buildPlugin(module);
+            continue;
+        }
+        if (module.pluginOnly)
+            continue;
+        mkdirSync(path.join(work, 'packages', module.name), { recursive: true });
+        const reached = module.cModules.map((name) => clangModules.get(name));
+        if (module.clang) {
+            const { objects, ...c } = await compileClang(module, 'packages', 'packages', reached);
+            packageObjects.push(...objects);
+            clangModules.set(module.name, c);
+            continue;
+        }
+        const sources = module.sources.map((file) => guest(module, file));
+        if (module.resourceBundle) {
+            writeFileSync(path.join(work, 'packages', module.name, 'resource_bundle_accessor.swift'), resourceBundleAccessor(module.resourceBundle));
+            sources.push(`/work/packages/${module.name}/resource_bundle_accessor.swift`);
+        }
+        const emitModule = `/work/modules/${module.name}.swiftmodule`;
+        const frontendFlags = [
+            '-I', kitModules, '-I', '/work/modules', ...module.flags,
+            // The C modules it imports, through their module maps.
+            ...reached.flatMap(clangFlags),
+            ...optimization, ...VERIFY_NONE,
+            '-D', 'SWIFT_PACKAGE', '-package-name', module.identity, ...pluginFlags, ...loadPlugins(module.macros),
+            ...(usesCoreFoundation(module) ? WASI_EMULATION_FLAGS : []),
+        ];
+        const outputs = await cached(module, moduleKey(module, frontendFlags, sources.map(hostOf)), async () => {
+            const built = await compiler.compile(host, { moduleName: module.name, sources, objectDir: `/work/packages/${module.name}`, emitModule, frontendFlags, onStep });
+            steps.push(...built.steps.map((step) => ({ ...step, tool: `${module.name} (${step.tool})` })));
+            if (!built.ok)
+                fail(built.output);
+            return [...built.objects, emitModule];
+        });
+        packageObjects.push(...outputs.filter((file) => file !== emitModule));
+    }
+    // What the app's own compile needs of the C modules its packages reach, and their macros.
+    const linked = modules.filter((module) => !module.macro && !module.pluginOnly);
+    const appMacros = loadPlugins([...new Set(linked.flatMap((module) => module.macros))]);
+    const appClangFlags = [...new Set(linked.flatMap((module) => (module.clang ? [] : module.cModules)))].flatMap((name) => clangFlags(clangModules.get(name)));
+    return { compiler, host, work, kitModules, pluginFlags: [...pluginFlags, ...appClangFlags, ...appMacros], modules, packageObjects, steps, reused, hostPaths };
+}
+/** What each tool took: the numbers Milestone 2 records (docs/in-browser-compiler.md); and the package modules that took none. */
+function describeSteps(steps, reused) {
+    if (reused.length > 0)
+        info(dim(`  ${reused.length === 1 ? '1 package module' : `${reused.length} package modules`} unchanged, from the cache`));
+    info(dim(`  WebAssembly compiler: ${steps.map((step) => `${step.tool} ${step.seconds.toFixed(1)} s${step.memoryBytes ? `, ${Math.round(step.memoryBytes / 1e6)} MB` : ''}`).join('; ')}`));
+}
+/** The kit's archives for the products the app and its packages link, as the tools see them. */
+function kitArchives(kit, staged, modules) {
+    const products = [...new Set([...linkedProducts(staged.features), ...modules.flatMap((module) => module.kitProducts)])];
+    return kitTargets(kit, products).map((target) => kitArchive('/kit', target));
+}
+/** Compiles and links the staged app with the WebAssembly tools; returns the module it wrote. */
+export async function buildWithWasmCompiler(options) {
+    const { staged, app, kit, icu } = options;
+    if (!kit)
+        throw new CliError('the WebAssembly compiler builds against the kit; unset SWIFTBROWSER_KIT=0');
+    if (!icu)
+        throw new CliError('the WebAssembly compiler needs the ICU data the build prepares');
+    const work = path.join(staged.dir, '.build', 'wasm-compiler');
+    const { compiler, host, kitModules, pluginFlags, modules, packageObjects, steps, reused, hostPaths } = await compilePackages(options, kit, work);
+    writeFileSync(path.join(work, 'icudt.o'), compiler.dataObject(icu.symbol, readFileSync(icu.file)));
+    const sources = swiftSources(path.join(staged.dir, 'Sources')).map((file) => `/app/Sources/${file.split(path.sep).join('/')}`);
+    const archives = kitArchives(kit, staged, modules);
+    const result = await compiler.compile(host, {
+        moduleName: app.name,
+        sources,
+        objectDir: '/work',
+        output: `/work/${app.name}.wasm`,
+        wholeModule: true,
+        frontendFlags: [...appFrontendFlags(app, sources, kitModules, { debug: options.debug ?? false }), ...(modules.length > 0 ? ['-I', '/work/modules'] : []), ...pluginFlags],
+        objects: [...packageObjects, '/work/icudt.o'],
+        linkerFlags: [
+            '--gc-sections',
+            ...appLinkerFlags(),
+            ...archives.flatMap((archive) => ['--whole-archive', archive, '--no-whole-archive']),
+        ],
+        onStep: (step) => options.onOutput?.(`${step.tool} ${step.args.join(' ')}\n`),
+    });
+    steps.push(...result.steps);
+    describeSteps(steps, reused);
+    const output = hostPaths(result.output);
+    if (!result.ok)
+        throw new CliError(remapDiagnostics(diagnosticsOnly(output) || output, staged));
+    const built = path.join(work, `${app.name}.wasm`);
+    if (!existsSync(built))
+        throw new CliError(`expected ${built} after the link`);
+    return built;
+}
+/**
+ * `swiftbrowser test` with the WebAssembly tools: what SwiftPM's debug
+ * `--build-tests` does for the staged test package. The app compiles as a
+ * testable module whose entry point is renamed (`<App>_main`), so that a
+ * test runner's is the program's; each test target compiles against it, and
+ * links with a runner (testDiscovery.ts) into `<Target>-test-runner.wasm`.
+ * Returns the runners, as `buildTests` does.
+ */
+export async function buildTestsWithWasmCompiler(options) {
+    const { staged, app, kit } = options;
+    if (!kit)
+        throw new CliError('the WebAssembly compiler builds against the kit; unset SWIFTBROWSER_KIT=0');
+    const work = path.join(staged.dir, '.build', 'wasm-compiler');
+    const context = await compilePackages({ ...options, debug: true }, kit, work);
+    const { compiler, host, kitModules, pluginFlags, modules, packageObjects, steps, reused, hostPaths } = context;
+    const fail = (output) => {
+        const text = hostPaths(output);
+        throw new CliError(remapDiagnostics(diagnosticsOnly(text) || text, staged));
+    };
+    const onStep = (step) => options.onOutput?.(`${step.tool} ${step.args.join(' ')}\n`);
+    // Debug, as SwiftPM builds tests: unoptimized, DEBUG defined, testable.
+    const flags = (sources) => [
+        ...appFrontendFlags(app, sources, kitModules, { debug: true }),
+        '-D', 'DEBUG', '-enable-testing', '-I', '/work/modules', ...pluginFlags,
+    ];
+    const appSources = swiftSources(path.join(staged.dir, 'Sources')).map((file) => `/app/Sources/${file.split(path.sep).join('/')}`);
+    mkdirSync(path.join(work, 'app'), { recursive: true });
+    const appBuilt = await compiler.compile(host, {
+        moduleName: app.name,
+        sources: appSources,
+        objectDir: '/work/app',
+        emitModule: `/work/modules/${app.name}.swiftmodule`,
+        // A main.swift keeps its top-level code (appFrontendFlags decides).
+        parseAsLibrary: false,
+        frontendFlags: [...flags(appSources), '-entry-point-function-name', `${app.name}_main`],
+        onStep,
+    });
+    steps.push(...appBuilt.steps.map((step) => ({ ...step, tool: `${app.name} (${step.tool})` })));
+    if (!appBuilt.ok)
+        fail(appBuilt.output);
+    const archives = kitArchives(kit, staged, modules);
+    const runners = [];
+    for (const target of options.tests) {
+        const dir = path.join(work, 'tests', target.name);
+        rmSync(path.join(dir, 'symbols'), { recursive: true, force: true });
+        mkdirSync(path.join(dir, 'symbols'), { recursive: true });
+        const testDir = testTargetPath(target.name);
+        const sources = swiftSources(path.join(staged.dir, testDir)).map((file) => `/app/${[...testDir.split(path.sep), ...file.split(path.sep)].join('/')}`);
+        const built = await compiler.compile(host, {
+            moduleName: target.name,
+            sources,
+            objectDir: `/work/tests/${target.name}`,
+            emitModule: `/work/modules/${target.name}.swiftmodule`,
+            // The XCTest classes, for the runner to list.
+            frontendFlags: [...flags(sources), '-emit-symbol-graph', '-emit-symbol-graph-dir', `/work/tests/${target.name}/symbols`, '-symbol-graph-minimum-access-level', 'internal'],
+            onStep,
+        });
+        steps.push(...built.steps.map((step) => ({ ...step, tool: `${target.name} (${step.tool})` })));
+        if (!built.ok)
+            fail(built.output);
+        const graph = JSON.parse(readFileSync(path.join(dir, 'symbols', `${target.name}.symbols.json`), 'utf8'));
+        const runnerDir = path.join(work, 'tests', `${target.name}-runner`);
+        mkdirSync(runnerDir, { recursive: true });
+        writeFileSync(path.join(runnerDir, 'runner.swift'), testRunnerSource(target.name, xctestCases(graph)));
+        const runner = `${target.name}-test-runner.wasm`;
+        const linked = await compiler.compile(host, {
+            moduleName: `${target.name}_test_runner`,
+            sources: [`/work/tests/${target.name}-runner/runner.swift`],
+            objectDir: `/work/tests/${target.name}-runner`,
+            output: `/work/${runner}`,
+            wholeModule: true,
+            frontendFlags: flags([]),
+            // The SDK's whole ICU data, as SwiftPM's test builds link it.
+            objects: [...packageObjects, ...appBuilt.objects, ...built.objects],
+            linkerFlags: ['--gc-sections', ...appLinkerFlags(), ...archives.flatMap((archive) => ['--whole-archive', archive, '--no-whole-archive'])],
+            onStep,
+        });
+        steps.push(...linked.steps.map((step) => ({ ...step, tool: `${target.name} runner (${step.tool})` })));
+        if (!linked.ok)
+            fail(linked.output);
+        runners.push(path.join(work, runner));
+    }
+    describeSteps(steps, reused);
+    return runners;
+}
+/**
+ * Whether the WebAssembly compiler reads a released kit's modules: type-checks
+ * a file importing every module of the kit against it, as `probeKit` does
+ * with a native toolchain (kit.ts).
+ */
+export async function probeKitWithWasmCompiler(sdk, kit) {
+    const dir = path.join(cacheDir(), 'wasm-compiler', 'probe');
+    mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, 'Probe.swift');
+    writeFileSync(file, `${Object.keys(kit.manifest.targets).map((module) => `import ${module}`).join('\n')}\n`);
+    const result = await wasmTypecheck({ sdk, kit, dir, files: [file], moduleName: 'Probe', flags: ['-parse-as-library'] });
+    return { ok: result.ok, output: result.output };
+}
+/**
+ * `check` with the WebAssembly compiler: type-checks the staged app against
+ * the kit with the flags its build compiles with. Throws a CliError with the
+ * diagnostics, named for the user's files, when it does not type-check.
+ */
+export async function checkWithWasmCompiler(options) {
+    const { staged, app } = options;
+    const files = swiftSources(path.join(staged.dir, 'Sources')).map((file) => path.join(staged.dir, 'Sources', file));
+    const result = await wasmTypecheck({
+        sdk: options.sdk,
+        kit: options.kit,
+        dir: staged.dir,
+        files,
+        moduleName: app.name,
+        flags: appFrontendFlags(app, files, `/kit/${KIT_TRIPLE}/Modules`),
+    });
+    if (!result.ok)
+        throw new CliError(remapDiagnostics(diagnosticsOnly(result.output) || result.output, staged));
+}
+//# sourceMappingURL=wasmCompiler.js.map