@swiftbrowser/wasm-compiler 0.0.0-stage → 0.8.0

package/dist/driver.d.ts

@@ -0,0 +1,116 @@
+export declare const TRIPLE = "wasm32-unknown-wasip1";
+/** The pieces of the Swift SDK for wasm32-unknown-wasip1 the jobs name. */
+export interface SdkPaths {
+    /** The WASI sysroot: wasi-libc, libc++ and the crt objects. */
+    sysroot: string;
+    /** The static resource directory: the stdlib's modules and archives. */
+    resourceDir: string;
+    /** Clang's resource directory inside it: headers and the builtins archive. */
+    clangResourceDir: string;
+    /** Where the Swift runtime archives and swiftrt.o are. */
+    libDir: string;
+    swiftrt: string;
+    crt1: string;
+    builtins: string;
+    /** The clang flags every static executable links with (a response file). */
+    staticExecutableArgs: string;
+}
+/**
+ * The layout of the Swift SDK's `wasm32-unknown-wasip1` directory (in the
+ * artifact bundle, `<bundle>/<name>/wasm32-unknown-wasip1`).
+ */
+export declare function sdkPaths(root: string): SdkPaths;
+export type ToolName = 'swift-frontend' | 'wasm-ld' | 'clang';
+export interface Job {
+    tool: ToolName;
+    args: string[];
+    /** The files the job writes, for the next job to read. */
+    outputs: string[];
+}
+export interface FrontendOptions {
+    sdk: SdkPaths;
+    moduleName: string;
+    /** The module's source files, in order. */
+    sources: readonly string[];
+    /** `compile` writes one object per source into `objectDir`; `typecheck` writes nothing. */
+    action: 'compile' | 'typecheck';
+    objectDir?: string;
+    /**
+     * The native toolchain's macro plugin server and plugin directories, which
+     * the native driver passes on every job. The WebAssembly frontend has none
+     * yet (docs/in-browser-compiler.md, Milestone 2).
+     */
+    plugins?: {
+        inProcessServer: string;
+        paths: readonly string[];
+    };
+    /**
+     * Where Clang's modules are cached. The native driver leaves this to the
+     * frontend, which derives it from the home directory; under WASI there is
+     * none, so the hosts pass a directory they keep between jobs.
+     */
+    moduleCachePath?: string;
+    /**
+     * One job for the whole module, as SwiftPM's release builds run (`-wmo`):
+     * no primary files, one object named after the module.
+     */
+    wholeModule?: boolean;
+    /**
+     * Flags for every job beyond the driver's own: `-O`, `-swift-version 5`,
+     * `-D NAME`, `-I DIR`, `-parse-as-library` and the like, as a build system
+     * passes them.
+     */
+    flags?: readonly string[];
+}
+/** The object file the job for `source` writes (unique even when two sources share a name). */
+export declare function objectPath(objectDir: string, sources: readonly string[], index: number): string;
+/**
+ * The frontend jobs `swiftc` runs without batch mode at -Onone: one per
+ * source, which is the job's primary file, with the other sources listed so
+ * the module type-checks as a whole. With `wholeModule`, one job for all of
+ * them.
+ */
+export declare function frontendJobs(options: FrontendOptions): Job[];
+export interface ClangOptions {
+    sdk: SdkPaths;
+    /** The C (or C++) source to compile. */
+    source: string;
+    /** The object to write. */
+    output: string;
+    /** The build's own flags: optimization, defines, include paths, a language standard. */
+    flags?: readonly string[];
+    /** Compile as C++ (clang's g++ driver mode, libc++ from the sysroot). */
+    cxx?: boolean;
+}
+/** One `clang -c`, as SwiftPM runs it for a C target's source, against the SDK's sysroot and clang headers. */
+export declare function clangJob(options: ClangOptions): Job;
+/**
+ * What clang passes on to `wasm-ld` for the lines of a clang response file
+ * like static-executable-args.lnk: `-Xlinker` values go through, `-lstdc++`
+ * is libc++ on WASI, and `-static` is what wasm-ld does anyway.
+ */
+export declare function clangLinkerArgs(responseFile: string): string[];
+export interface LinkOptions {
+    sdk: SdkPaths;
+    objects: readonly string[];
+    /** The objects' autolink entries, as `extractAutolink` returns them. */
+    autolink: readonly string[];
+    /** The contents of `sdk.staticExecutableArgs`. */
+    staticExecutableArgs: string;
+    output: string;
+    /** The shadow stack size; the Swift driver's default for WASI is 128 KB. */
+    stackSize?: number;
+    /**
+     * The build's own linker flags (what `-Xlinker` passes): exports,
+     * `--gc-sections`, archives to link whole. They follow the driver's flags,
+     * so a later `-z stack-size` wins.
+     */
+    flags?: readonly string[];
+}
+/**
+ * The `wasm-ld` command clang runs for the Swift driver's link job, in the
+ * same order: crt1 and swiftrt.o, the objects, the autolinked libraries, the
+ * SDK's static-executable flags, the Swift driver's own linker flags, libc
+ * and the compiler builtins last.
+ */
+export declare function linkJob(options: LinkOptions): Job;

package/dist/driver.js

@@ -0,0 +1,165 @@
+// The Swift driver's job planning for wasm32-unknown-wasip1, in TypeScript.
+//
+// `swiftc` (swift-driver) only turns a command line into tool invocations:
+// one `swift-frontend` job per primary file, `swift-autolink-extract`, and a
+// clang link job that runs `wasm-ld`. Porting it would bring Foundation,
+// Dispatch and process spawning along, so this file reproduces the jobs
+// instead. test/fixtures/*-jobs.json hold what the native 6.4 driver and
+// clang run (toolchain/record-invocations.mjs); test/driver.test.ts checks
+// these functions against them, argument for argument.
+//
+// Every path here is a path as the tools see it: a real path for native
+// tools, a path inside the WASI file system for the WebAssembly ones.
+export const TRIPLE = 'wasm32-unknown-wasip1';
+/**
+ * The layout of the Swift SDK's `wasm32-unknown-wasip1` directory (in the
+ * artifact bundle, `<bundle>/<name>/wasm32-unknown-wasip1`).
+ */
+export function sdkPaths(root) {
+    const sysroot = `${root}/WASI.sdk`;
+    const resourceDir = `${root}/swift.xctoolchain/usr/lib/swift_static`;
+    const clangResourceDir = `${resourceDir}/clang`;
+    const libDir = `${resourceDir}/wasi`;
+    return {
+        sysroot,
+        resourceDir,
+        clangResourceDir,
+        libDir,
+        swiftrt: `${libDir}/wasm32/swiftrt.o`,
+        crt1: `${sysroot}/lib/wasm32-wasip1/crt1-command.o`,
+        builtins: `${clangResourceDir}/lib/wasip1/libclang_rt.builtins-wasm32.a`,
+        staticExecutableArgs: `${libDir}/static-executable-args.lnk`,
+    };
+}
+function basenameWithoutExtension(file) {
+    const base = file.slice(file.lastIndexOf('/') + 1);
+    const dot = base.lastIndexOf('.');
+    return dot > 0 ? base.slice(0, dot) : base;
+}
+/** The object file the job for `source` writes (unique even when two sources share a name). */
+export function objectPath(objectDir, sources, index) {
+    const name = basenameWithoutExtension(sources[index]);
+    const clash = sources.some((other, i) => i !== index && basenameWithoutExtension(other) === name);
+    return `${objectDir}/${clash ? `${name}-${index}` : name}.o`;
+}
+/**
+ * The frontend jobs `swiftc` runs without batch mode at -Onone: one per
+ * source, which is the job's primary file, with the other sources listed so
+ * the module type-checks as a whole. With `wholeModule`, one job for all of
+ * them.
+ */
+export function frontendJobs(options) {
+    const { sources } = options;
+    if (sources.length === 0)
+        throw new Error('no Swift sources');
+    if (options.action === 'compile' && !options.objectDir)
+        throw new Error('compile needs an objectDir');
+    if (options.wholeModule) {
+        const output = options.action === 'compile' ? `${options.objectDir}/${options.moduleName}.o` : null;
+        return [frontendJob(options, sources, output)];
+    }
+    return sources.map((primary, index) => {
+        const inputs = sources.flatMap((source) => (source === primary ? ['-primary-file', source] : [source]));
+        return frontendJob(options, inputs, options.action === 'compile' ? objectPath(options.objectDir, sources, index) : null);
+    });
+}
+function frontendJob(options, inputs, output) {
+    const { sdk } = options;
+    const args = [
+        '-frontend',
+        options.action === 'compile' ? '-c' : '-typecheck',
+        ...inputs,
+        '-target', TRIPLE,
+        '-disable-objc-interop',
+        '-sdk', sdk.sysroot,
+        '-sysroot', sdk.sysroot,
+        '-no-color-diagnostics',
+        '-Xcc', '-fno-color-diagnostics',
+        '-empty-abi-descriptor',
+        '-resource-dir', sdk.resourceDir,
+        '-use-static-resource-dir',
+        '-Xcc', '-resource-dir', '-Xcc', sdk.clangResourceDir,
+        '-no-auto-bridging-header-chaining',
+        '-module-name', options.moduleName,
+        ...(options.flags ?? []),
+        ...(options.plugins
+            ? ['-in-process-plugin-server-path', options.plugins.inProcessServer, ...options.plugins.paths.flatMap((p) => ['-plugin-path', p])]
+            : []),
+        ...(options.moduleCachePath ? ['-module-cache-path', options.moduleCachePath] : []),
+        ...(output ? ['-o', output] : []),
+    ];
+    return { tool: 'swift-frontend', args, outputs: output ? [output] : [] };
+}
+/** One `clang -c`, as SwiftPM runs it for a C target's source, against the SDK's sysroot and clang headers. */
+export function clangJob(options) {
+    const { sdk } = options;
+    const args = [
+        ...(options.cxx ? ['--driver-mode=g++'] : []),
+        `--target=${TRIPLE}`,
+        `--sysroot=${sdk.sysroot}`,
+        '-resource-dir', sdk.clangResourceDir,
+        '-fno-color-diagnostics',
+        ...(options.flags ?? []),
+        '-c', options.source,
+        '-o', options.output,
+    ];
+    return { tool: 'clang', args, outputs: [options.output] };
+}
+/**
+ * What clang passes on to `wasm-ld` for the lines of a clang response file
+ * like static-executable-args.lnk: `-Xlinker` values go through, `-lstdc++`
+ * is libc++ on WASI, and `-static` is what wasm-ld does anyway.
+ */
+export function clangLinkerArgs(responseFile) {
+    const words = responseFile.split(/\s+/).filter((word) => word.length > 0);
+    const out = [];
+    for (let i = 0; i < words.length; i++) {
+        const word = words[i];
+        if (word === '-Xlinker') {
+            const value = words[++i];
+            if (value === undefined)
+                throw new Error('-Xlinker without a value');
+            out.push(value);
+        }
+        else if (word === '-static') {
+            continue;
+        }
+        else if (word === '-lstdc++') {
+            out.push('-lc++', '-lc++abi');
+        }
+        else if (word.startsWith('-l') || word.startsWith('-L')) {
+            out.push(word);
+        }
+        else {
+            throw new Error(`unexpected flag in a linker response file: ${word}`);
+        }
+    }
+    return out;
+}
+/**
+ * The `wasm-ld` command clang runs for the Swift driver's link job, in the
+ * same order: crt1 and swiftrt.o, the objects, the autolinked libraries, the
+ * SDK's static-executable flags, the Swift driver's own linker flags, libc
+ * and the compiler builtins last.
+ */
+export function linkJob(options) {
+    const { sdk } = options;
+    const args = [
+        '-m', 'wasm32',
+        `-L${sdk.libDir}`,
+        `-L${sdk.sysroot}/lib/wasm32-wasip1`,
+        sdk.crt1,
+        sdk.swiftrt,
+        ...options.objects,
+        ...options.autolink,
+        ...clangLinkerArgs(options.staticExecutableArgs),
+        '--global-base=4096',
+        '--table-base=4096',
+        '-z', `stack-size=${options.stackSize ?? 128 * 1024}`,
+        ...(options.flags ?? []),
+        '-lc',
+        sdk.builtins,
+        '-o', options.output,
+    ];
+    return { tool: 'wasm-ld', args, outputs: [options.output] };
+}

package/dist/host.d.ts

@@ -0,0 +1,27 @@
+import type { SdkPaths, ToolName } from './driver.js';
+export interface RunResult {
+    exitCode: number;
+    /** stdout and stderr, interleaved as written. */
+    output: string;
+    /**
+     * The size of the tool's linear memory when it exited, for a WebAssembly
+     * tool: its peak, since a memory only grows.
+     */
+    memoryBytes?: number;
+}
+export interface Host {
+    /** One line for logs: which tools, from where. */
+    readonly description: string;
+    /** The Swift SDK as the tools see it. */
+    readonly sdk: SdkPaths;
+    /** The native driver's plugin flags, when the tools have plugins. */
+    readonly plugins?: {
+        inProcessServer: string;
+        paths: readonly string[];
+    };
+    /** Where the frontend caches Clang's modules, as the tools see it, when the host chooses. */
+    readonly moduleCachePath?: string;
+    run(tool: ToolName, args: readonly string[]): Promise<RunResult>;
+    /** Reads a file by the path the tools use. */
+    readFile(path: string): Promise<Uint8Array>;
+}

package/dist/host.js

@@ -0,0 +1,7 @@
+// Where the tools run. The driver plans jobs; a host runs them and reads
+// what they wrote. Two kinds exist (src/node): the native toolchain, which
+// pins the driver against the real thing, and the WebAssembly tools under
+// WASI. The browser gets a third one over an in-memory file system
+// (docs/in-browser-compiler.md, Milestone 3); nothing above this interface
+// knows which it has.
+export {};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { TRIPLE, clangJob, clangLinkerArgs, frontendJobs, linkJob, objectPath, sdkPaths } from './driver.js';
+export type { ClangOptions, FrontendOptions, Job, LinkOptions, SdkPaths, ToolName } from './driver.js';
+export { compile, compileC } from './compile.js';
+export { dataObject } from './object.js';
+export { pluginHost } from './plugins.js';
+export type { PluginHost, PluginHostOptions } from './plugins.js';
+export type { CompileCRequest, CompileRequest, CompileResult, CompileStep } from './compile.js';
+export type { Host, RunResult } from './host.js';
+export { AUTOLINK_SECTION, SWIFT_RUNTIME_LIBRARIES_ORDERED, autolinkEntries, customSections, extractAutolink } from './wasm.js';
+export { directoryFiles, memoryDirectory, memoryHost, runMemoryCommand } from './memory-host.js';
+export type { MemoryCommand, MemoryHost, MemoryHostOptions } from './memory-host.js';

package/dist/index.js

@@ -0,0 +1,9 @@
+// The parts that run anywhere, the browser included: the driver's job
+// planning, the autolink reader and the compile sequence over a Host. The
+// Node hosts are the package's `./node` entry point (src/node/index.ts).
+export { TRIPLE, clangJob, clangLinkerArgs, frontendJobs, linkJob, objectPath, sdkPaths } from './driver.js';
+export { compile, compileC } from './compile.js';
+export { dataObject } from './object.js';
+export { pluginHost } from './plugins.js';
+export { AUTOLINK_SECTION, SWIFT_RUNTIME_LIBRARIES_ORDERED, autolinkEntries, customSections, extractAutolink } from './wasm.js';
+export { directoryFiles, memoryDirectory, memoryHost, runMemoryCommand } from './memory-host.js';

package/dist/memory-host.d.ts

@@ -0,0 +1,50 @@
+import { Directory, OpenFile } from '@bjorn3/browser_wasi_shim';
+import { type ToolName } from './driver.js';
+import type { Host, RunResult } from './host.js';
+/** A Directory holding `files`, keyed by `/`-separated paths relative to it. */
+export declare function memoryDirectory(files: Iterable<readonly [string, Uint8Array]>): Directory;
+/** The files under `dir`, as `memoryDirectory` takes them: the inverse of it. */
+export declare function directoryFiles(dir: Directory, prefix?: string): [string, Uint8Array][];
+/** Writes `data` at `offset` of an open file, growing its buffer by doubling. Exported for the tests. */
+export declare function writeAt(open: OpenFile, offset: number, data: Uint8Array): void;
+export interface MemoryCommand {
+    module: WebAssembly.Module;
+    /** argv, the program name first. */
+    args: readonly string[];
+    /** Guest directory → its contents. */
+    mounts: Record<string, Directory>;
+    env?: Record<string, string>;
+    /** Every path the command opens, as a guest path. */
+    onOpen?: (path: string) => void;
+    /** Macro plugins by the guest path the compiler names (plugins.ts). */
+    plugins?: Record<string, WebAssembly.Module>;
+}
+/** Runs a WASI command over in-memory directories on the calling thread. */
+export declare function runMemoryCommand(command: MemoryCommand): Promise<RunResult>;
+export interface MemoryHostOptions {
+    /** The compiled tool modules. */
+    tools: Partial<Record<ToolName, WebAssembly.Module>>;
+    /**
+     * Guest directory → its contents. An empty / (the frontend's working
+     * directory) and /tmp (temporary files and the module cache, kept between
+     * jobs) are added when missing.
+     */
+    mounts: Record<string, Directory>;
+    /** The Swift SDK's `wasm32-unknown-wasip1` directory, as a guest path. */
+    sdkRoot: string;
+    onOpen?: (path: string) => void;
+    /** Macro plugins by the guest path the compiler names; the file must exist under a mount too. */
+    plugins?: Record<string, WebAssembly.Module>;
+    /**
+     * Clang's module cache to start from, as `moduleCacheFiles` returned it
+     * (docs/in-browser-compiler.md, Milestone 2's cached PCMs). Every file
+     * here has the same timestamp, so a cache built for the same files and
+     * flags is valid in any session and nothing is rebuilt.
+     */
+    moduleCache?: Iterable<readonly [string, Uint8Array]>;
+}
+export interface MemoryHost extends Host {
+    /** Clang's module cache as it is now, for a later host's `moduleCache`. */
+    moduleCacheFiles(): [string, Uint8Array][];
+}
+export declare function memoryHost(options: MemoryHostOptions): MemoryHost;

package/dist/memory-host.js

@@ -0,0 +1,195 @@
+// The WebAssembly tools over an in-memory file system: the host the browser
+// will use (docs/in-browser-compiler.md, Milestone 3), with
+// @bjorn3/browser_wasi_shim, the WASI implementation the renderer already
+// runs apps with. It runs on the calling thread; in a page, call it from a
+// worker so the tools' deep recursion has a worker's stack. No Node APIs.
+//
+// Each mount is a top-level guest directory (/sdk, /work, ...) backed by a
+// Directory; files a tool writes stay in it, so the next tool (and
+// readFile) sees them. `onOpen` reports every path a tool opens, which is
+// how the SDK files a compile needs are found.
+import { ConsoleStdout, Directory, File, Inode, OpenFile, PreopenDirectory, WASI, wasi as wasiDefs } from '@bjorn3/browser_wasi_shim';
+import { sdkPaths } from './driver.js';
+import { pluginHost } from './plugins.js';
+/** A Directory holding `files`, keyed by `/`-separated paths relative to it. */
+export function memoryDirectory(files) {
+    const root = new Directory(new Map());
+    for (const [file, data] of files) {
+        const parts = file.split('/').filter((part) => part.length > 0);
+        let dir = root;
+        for (const part of parts.slice(0, -1)) {
+            let next = dir.contents.get(part);
+            if (!next) {
+                next = new Directory(new Map());
+                dir.contents.set(part, next);
+            }
+            if (!(next instanceof Directory))
+                throw new Error(`${file}: ${part} is a file`);
+            dir = next;
+        }
+        dir.contents.set(parts[parts.length - 1], new File(data));
+    }
+    return root;
+}
+/** The files under `dir`, as `memoryDirectory` takes them: the inverse of it. */
+export function directoryFiles(dir, prefix = '') {
+    return [...dir.contents.entries()].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)).flatMap(([name, node]) => {
+        const file = prefix ? `${prefix}/${name}` : name;
+        if (node instanceof Directory)
+            return directoryFiles(node, file);
+        return node instanceof File ? [[file, node.data]] : [];
+    });
+}
+/** Writes `data` at `offset` of an open file, growing its buffer by doubling. Exported for the tests. */
+export function writeAt(open, offset, data) {
+    const file = open.file;
+    const end = offset + data.length;
+    if (end > file.data.byteLength) {
+        const buffer = file.data.buffer;
+        if (end > buffer.byteLength - file.data.byteOffset || file.data.byteOffset !== 0) {
+            const grown = new Uint8Array(new ArrayBuffer(Math.max(end, 2 * buffer.byteLength, 4096)));
+            grown.set(file.data);
+            file.data = grown.subarray(0, end);
+        }
+        else {
+            file.data = new Uint8Array(buffer, 0, end);
+        }
+    }
+    file.data.set(data, offset);
+}
+function lookup(mounts, guest) {
+    const mount = Object.keys(mounts)
+        .filter((dir) => guest === dir || guest.startsWith(`${dir}/`))
+        .sort((a, b) => b.length - a.length)[0];
+    if (mount === undefined)
+        return undefined;
+    let node = mounts[mount];
+    for (const part of guest.slice(mount.length).split('/').filter((p) => p.length > 0)) {
+        if (!(node instanceof Directory))
+            return undefined;
+        node = node.contents.get(part);
+    }
+    return node;
+}
+/** Runs a WASI command over in-memory directories on the calling thread. */
+export async function runMemoryCommand(command) {
+    const decoder = new TextDecoder();
+    let output = '';
+    const collect = (bytes) => {
+        output += decoder.decode(bytes, { stream: true });
+    };
+    const names = Object.keys(command.mounts);
+    const fds = [
+        new OpenFile(new File(new Uint8Array())),
+        new ConsoleStdout(collect),
+        new ConsoleStdout(collect),
+        ...names.map((name) => new PreopenDirectory(name, command.mounts[name].contents)),
+    ];
+    const env = Object.entries(command.env ?? {}).map(([key, value]) => `${key}=${value}`);
+    const wasi = new WASI([...command.args], env, fds, { debug: false });
+    const imports = { ...wasi.wasiImport };
+    // The in-memory file system has no symbolic links, and says readlink is
+    // not supported; a real one says a path is not a link (EINVAL), which is
+    // what resolving a path (the compiler's plugins, for one) expects.
+    const pathReadlink = imports['path_readlink'];
+    imports['path_readlink'] = ((...args) => {
+        const result = pathReadlink(...args);
+        return result === wasiDefs.ERRNO_NOTSUP ? wasiDefs.ERRNO_INVAL : result;
+    });
+    // Its files grow to exactly the size of each write, copying the whole file
+    // every time: writing a 10 MB module in small writes is quadratic. Writes
+    // to an open file go into a buffer that doubles instead, with the file's
+    // data a view of the part written.
+    const fdWrite = imports['fd_write'];
+    imports['fd_write'] = ((fd, iovs, count, written) => {
+        const open = wasi.fds[fd];
+        if (!(open instanceof OpenFile) || open.file.readonly)
+            return fdWrite(fd, iovs, count, written);
+        const memory = instance.exports['memory'].buffer;
+        const view = new DataView(memory);
+        let total = 0;
+        for (let i = 0; i < count; i++) {
+            const pointer = view.getUint32(iovs + i * 8, true);
+            const length = view.getUint32(iovs + i * 8 + 4, true);
+            writeAt(open, Number(open.file_pos), new Uint8Array(memory, pointer, length));
+            open.file_pos += BigInt(length);
+            total += length;
+        }
+        view.setUint32(written, total, true);
+        return wasiDefs.ERRNO_SUCCESS;
+    });
+    // It also grants no rights, and wasi-libc's access() checks a path against
+    // its directory's: report every right, as a preopened directory under a
+    // real WASI host has (the compiler checks that a plugin is readable).
+    const fdstatGet = imports['fd_fdstat_get'];
+    imports['fd_fdstat_get'] = ((fd, pointer) => {
+        const result = fdstatGet(fd, pointer);
+        if (result === wasiDefs.ERRNO_SUCCESS) {
+            const view = new DataView(instance.exports['memory'].buffer);
+            // fdstat: filetype u8, flags u16, rights_base u64 at 8, rights_inheriting u64 at 16.
+            view.setBigUint64(pointer + 8, 0xffffffffffffffffn, true);
+            view.setBigUint64(pointer + 16, 0xffffffffffffffffn, true);
+        }
+        return result;
+    });
+    if (command.onOpen) {
+        const pathOpen = imports['path_open'];
+        const onOpen = command.onOpen;
+        // path_open(dirfd, dirflags, path, path_len, ...): the preopens are fds 3 and up.
+        imports['path_open'] = ((...args) => {
+            const [dirfd, , pathPtr, pathLength] = args;
+            const memory = instance.exports['memory'].buffer;
+            const relative = decoder.decode(new Uint8Array(memory, pathPtr, pathLength));
+            const base = names[dirfd - 3];
+            onOpen(base === undefined ? relative : `${base}/${relative}`);
+            return pathOpen(...args);
+        });
+    }
+    const plugins = WebAssembly.Module.imports(command.module).some((entry) => entry.module === 'swiftbrowser')
+        ? pluginHost({ module: (path) => command.plugins?.[path] ?? null, onStderr: (text) => (output += text) })
+        : null;
+    const instance = await WebAssembly.instantiate(command.module, { wasi_snapshot_preview1: imports, ...(plugins?.imports ?? {}) });
+    plugins?.bind(instance);
+    let exitCode;
+    try {
+        exitCode = wasi.start(instance);
+    }
+    catch (error) {
+        output += decoder.decode();
+        return { exitCode: 1, output: `${output}${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n` };
+    }
+    return { exitCode, output: output + decoder.decode() };
+}
+/** The module cache's directory under the host's /tmp. */
+const MODULE_CACHE = 'module-cache';
+export function memoryHost(options) {
+    const tmp = new Directory(new Map());
+    if (options.moduleCache)
+        tmp.contents.set(MODULE_CACHE, memoryDirectory(options.moduleCache));
+    const mounts = { '/': new Directory(new Map()), '/tmp': tmp, ...options.mounts };
+    return {
+        moduleCacheFiles() {
+            const cache = mounts['/tmp'].contents.get(MODULE_CACHE);
+            return cache instanceof Directory ? directoryFiles(cache) : [];
+        },
+        description: 'WebAssembly tools over an in-memory file system',
+        sdk: sdkPaths(options.sdkRoot),
+        moduleCachePath: `/tmp/${MODULE_CACHE}`,
+        async readFile(file) {
+            const node = lookup(mounts, file);
+            if (!(node instanceof File))
+                throw new Error(`${file}: no such file`);
+            return node.data;
+        },
+        run(tool, args) {
+            const module = options.tools[tool];
+            if (!module)
+                throw new Error(`no WebAssembly module for ${tool}`);
+            return runMemoryCommand({
+                module, args: [tool, ...args], mounts, env: { TMPDIR: '/tmp' },
+                ...(options.onOpen ? { onOpen: options.onOpen } : {}),
+                ...(options.plugins ? { plugins: options.plugins } : {}),
+            });
+        },
+    };
+}

package/dist/node/index.d.ts

@@ -0,0 +1,5 @@
+export { nativeHost } from './native-host.js';
+export type { NativeHostOptions } from './native-host.js';
+export { findManifestApi, findPlugins, findTools, packagedToolsDir, toolFile } from './tools.js';
+export { runWasiCommand, wasiHost } from './wasi-host.js';
+export type { WasiCommand, WasiHost, WasiHostOptions } from './wasi-host.js';

package/dist/node/index.js

@@ -0,0 +1,4 @@
+// The Node hosts: the native toolchain and the WebAssembly tools under WASI.
+export { nativeHost } from './native-host.js';
+export { findManifestApi, findPlugins, findTools, packagedToolsDir, toolFile } from './tools.js';
+export { runWasiCommand, wasiHost } from './wasi-host.js';

package/dist/node/native-host.d.ts

@@ -0,0 +1,8 @@
+import type { Host } from '../host.js';
+export interface NativeHostOptions {
+    /** The toolchain directory, the one holding `usr/bin/swift-frontend`. */
+    toolchain: string;
+    /** The Swift SDK's `wasm32-unknown-wasip1` directory. */
+    sdkRoot: string;
+}
+export declare function nativeHost(options: NativeHostOptions): Host;

package/dist/node/native-host.js

@@ -0,0 +1,31 @@
+// The native Swift toolchain as a host: the same jobs the WebAssembly tools
+// run, run by the real `swift-frontend` and `wasm-ld`. It checks the driver
+// end to end on a machine with Swift, and is the baseline the WebAssembly
+// tools are compared with.
+import { spawn } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { sdkPaths } from '../driver.js';
+export function nativeHost(options) {
+    const bin = path.join(options.toolchain, 'usr/bin');
+    return {
+        description: `native tools in ${bin}`,
+        sdk: sdkPaths(options.sdkRoot),
+        plugins: {
+            inProcessServer: path.join(options.toolchain, 'usr/lib/swift/host/libSwiftInProcPluginServer.so'),
+            paths: [path.join(options.toolchain, 'usr/lib/swift/host/plugins'), path.join(options.toolchain, 'usr/local/lib/swift/host/plugins')],
+        },
+        run: (tool, args) => runProcess(path.join(bin, tool), args),
+        readFile: (file) => readFile(file),
+    };
+}
+function runProcess(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        let output = '';
+        child.stdout.on('data', (chunk) => (output += chunk.toString('utf8')));
+        child.stderr.on('data', (chunk) => (output += chunk.toString('utf8')));
+        child.on('error', reject);
+        child.on('close', (code, signal) => resolve({ exitCode: code ?? 1, output: signal ? `${output}${command} ended with ${signal}\n` : output }));
+    });
+}

package/dist/node/plugin-executable.d.ts

@@ -0,0 +1,15 @@
+export interface PluginStreams {
+    /** Fills `buffer` from `offset` with at most `length` bytes; 0 at the end. */
+    read(buffer: Uint8Array, offset: number, length: number): number;
+    write(bytes: Uint8Array): void;
+    error(bytes: Uint8Array): void;
+}
+/** Stdin, stdout and stderr, read and written synchronously: the compiler waits on each reply. */
+export declare const processStreams: PluginStreams;
+/** The plugin's module: a `.wasm` file, or a brotli-compressed `.wasm.br`. */
+export declare function pluginModule(file: string): WebAssembly.Module;
+/**
+ * Serves the compiler's messages until it closes the pipe or sends the empty
+ * message that asks a plugin to finish; returns the exit code.
+ */
+export declare function servePlugin(module: WebAssembly.Module, name: string, streams?: PluginStreams): number;