@swiftbrowser/wasm-compiler 0.7.0 → 0.8.0

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;

package/dist/node/plugin-executable.js

@@ -0,0 +1,97 @@
+// A macro plugin built as WebAssembly, run as the executable plugin a native
+// compiler spawns (`-load-plugin-executable`): `node plugin-executable.js
+// <plugin.wasm>`. The compiler's messages arrive on stdin and the replies go
+// to stdout, framed alike (an 8-byte little-endian length, then JSON), and
+// each message is handed to the module's `swift_wasm_macro_v1_pump`, as the
+// WebAssembly compiler's host does (../plugins.ts). The kit's macros reach a
+// native toolchain this way (the CLI's kit.ts), the same file on every host.
+import { readFileSync, readSync, realpathSync, writeSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import { brotliDecompressSync } from 'node:zlib';
+import { ConsoleStdout, WASI, wasi } from '@bjorn3/browser_wasi_shim';
+const HEADER = 8;
+/** Stdin the executable fills with one message before each pump. */
+class MessageInput extends ConsoleStdout {
+    queue = new Uint8Array();
+    constructor() {
+        super(() => { });
+    }
+    set(bytes) {
+        this.queue = bytes;
+    }
+    fd_read(size) {
+        const data = this.queue.slice(0, size);
+        this.queue = this.queue.slice(data.length);
+        return { ret: wasi.ERRNO_SUCCESS, data };
+    }
+}
+/** Stdin, stdout and stderr, read and written synchronously: the compiler waits on each reply. */
+export const processStreams = {
+    read: (buffer, offset, length) => readSync(0, buffer, offset, length, null),
+    write: (bytes) => {
+        for (let written = 0; written < bytes.length;)
+            written += writeSync(1, bytes, written);
+    },
+    error: (bytes) => {
+        for (let written = 0; written < bytes.length;)
+            written += writeSync(2, bytes, written);
+    },
+};
+/** The plugin's module: a `.wasm` file, or a brotli-compressed `.wasm.br`. */
+export function pluginModule(file) {
+    const bytes = readFileSync(file);
+    return new WebAssembly.Module(file.endsWith('.br') ? brotliDecompressSync(bytes) : bytes);
+}
+/**
+ * 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 function servePlugin(module, name, streams = processStreams) {
+    const stdin = new MessageInput();
+    const shim = new WASI([name], [], [stdin, new ConsoleStdout(streams.write), new ConsoleStdout(streams.error)], { debug: false });
+    const instance = new WebAssembly.Instance(module, { wasi_snapshot_preview1: shim.wasiImport });
+    // `main` installs the message handler and returns.
+    const code = shim.start(instance);
+    if (code !== 0)
+        return code;
+    const pump = instance.exports['swift_wasm_macro_v1_pump'];
+    if (!pump) {
+        streams.error(new TextEncoder().encode(`${name}: not a macro plugin built as WebAssembly (no swift_wasm_macro_v1_pump)\n`));
+        return 1;
+    }
+    const readExactly = (size) => {
+        const buffer = new Uint8Array(size);
+        for (let offset = 0; offset < size;) {
+            const count = streams.read(buffer, offset, size - offset);
+            if (count === 0)
+                return null;
+            offset += count;
+        }
+        return buffer;
+    };
+    for (;;) {
+        const header = readExactly(HEADER);
+        if (!header)
+            return 0;
+        const size = Number(new DataView(header.buffer).getBigUint64(0, true));
+        if (size === 0)
+            return 0;
+        const body = readExactly(size);
+        if (!body)
+            return 0;
+        const message = new Uint8Array(HEADER + size);
+        message.set(header);
+        message.set(body, HEADER);
+        stdin.set(message);
+        pump();
+    }
+}
+// Run as a script (through a link, too: npm links workspaces).
+if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) {
+    const file = process.argv[2];
+    if (!file) {
+        process.stderr.write('usage: plugin-executable <plugin.wasm>\n');
+        process.exit(2);
+    }
+    process.exit(servePlugin(pluginModule(file), file));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swiftbrowser/wasm-compiler",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Compiles Swift with the Swift compiler built as WebAssembly: a driver, WASI hosts and a CLI. See docs/in-browser-compiler.md.",
   "repository": {
     "type": "git",
@@ -18,6 +18,10 @@
     "./node": {
       "types": "./dist/node/index.d.ts",
       "default": "./dist/node/index.js"
+    },
+    "./plugin-executable": {
+      "types": "./dist/node/plugin-executable.d.ts",
+      "default": "./dist/node/plugin-executable.js"
     }
   },
   "bin": {
@@ -35,7 +39,7 @@
   },
   "dependencies": {
     "@bjorn3/browser_wasi_shim": "^0.4.2",
-    "@swiftbrowser/wasm-tools": "0.7.0"
+    "@swiftbrowser/wasm-tools": "0.8.0"
   },
   "devDependencies": {
     "@types/node": "^26.6.4",