@openmbee/opensysml 0.9.2 → 0.10.0

package/dist/core/wasm.js

@@ -0,0 +1,514 @@
+import { fromJson, toJson, } from "@bufbuild/protobuf";
+import { Code, ConnectError, createContextValues, } from "@connectrpc/connect";
+import { getAbortSignalReason, runUnaryCall } from "@connectrpc/connect/protocol";
+import { Connection } from "./connection.js";
+import { ClosedConnectionError, OpenSysMLError } from "./errors.js";
+import { encodingOf, interceptors, timeoutOf } from "./transport.js";
+const goConstructors = new Map();
+let goConstructorLoads = Promise.resolve();
+let inlineStartup = Promise.resolve();
+/**
+ * Adapts the Go host global to the asynchronous host interface.
+ */
+export function wasmHostFromGlobal(surface) {
+    const global = globalThis;
+    const hostSurface = surface ?? global.sysmlWasm;
+    if (hostSurface === undefined ||
+        typeof hostSurface.version !== "string" ||
+        typeof hostSurface.call !== "function") {
+        throw new OpenSysMLError("the Go runtime did not expose globalThis.sysmlWasm");
+    }
+    let closed = false;
+    return {
+        version: hostSurface.version,
+        call(method, params) {
+            if (closed) {
+                return Promise.reject(new ClosedConnectionError());
+            }
+            try {
+                return Promise.resolve(hostSurface.call(method, params));
+            }
+            catch (cause) {
+                return Promise.resolve(errorEnvelope(cause));
+            }
+        },
+        close() {
+            closed = true;
+            return Promise.resolve();
+        },
+    };
+}
+/**
+ * Starts a Go WebAssembly module in this realm and captures its host global.
+ */
+export async function instantiateInline(module, Go) {
+    const starting = inlineStartup.then(() => instantiateInlineNow(module, Go));
+    inlineStartup = starting.then(() => undefined, () => undefined);
+    return await starting;
+}
+async function instantiateInlineNow(module, Go) {
+    const runtime = globalThis;
+    delete runtime.sysmlWasm;
+    const go = new Go();
+    const instance = module instanceof WebAssembly.Module
+        ? await WebAssembly.instantiate(module, go.importObject)
+        : (await WebAssembly.instantiate(module, go.importObject)).instance;
+    let startError;
+    void go.run(instance).catch((error) => {
+        startError = error;
+    });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    const surface = globalWasmSurface();
+    delete runtime.sysmlWasm;
+    if (surface === undefined) {
+        throw new OpenSysMLError("the Go runtime did not expose globalThis.sysmlWasm", startError === undefined ? undefined : { cause: startError });
+    }
+    return wasmHostFromGlobal(surface);
+}
+/**
+ * Creates a Connect transport for the JSON envelope served by sysml-wasm.
+ */
+export function createWasmTransport(host, options) {
+    const callUnary = (method, signal, timeoutMs, header, input, contextValues) => runUnaryCall({
+        req: {
+            stream: false,
+            service: method.parent,
+            method,
+            requestMethod: "POST",
+            url: `wasm://sysml-wasm/${method.parent.typeName}/${method.name}`,
+            header: new Headers(header),
+            contextValues: contextValues ?? createContextValues(),
+            message: input,
+        },
+        ...(signal === undefined ? {} : { signal }),
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        interceptors: interceptors(options),
+        next: async (request) => {
+            if (request.signal.aborted) {
+                throw abortError(request.signal);
+            }
+            const params = JSON.stringify(toJson(method.input, request.message));
+            const answer = host.call(method.name, params, request.signal);
+            const envelope = await withAbort(answer, request.signal);
+            const body = readEnvelope(envelope);
+            return {
+                stream: false,
+                service: method.parent,
+                method,
+                header: new Headers(),
+                message: fromJson(method.output, body, {
+                    ignoreUnknownFields: true,
+                }),
+                trailer: new Headers(),
+            };
+        },
+    });
+    return {
+        unary: callUnary,
+        stream() {
+            return Promise.reject(new ConnectError("streaming methods are not supported by sysml-wasm", Code.Unimplemented));
+        },
+    };
+}
+/**
+ * Opens a Connection over a WASM host, negotiating its version and capabilities.
+ */
+export async function connectWasmHost(host, options = {}) {
+    let timeoutMs;
+    try {
+        if (options.encoding !== undefined && encodingOf(options) !== "json") {
+            throw new OpenSysMLError("sysml-wasm supports JSON encoding only");
+        }
+        timeoutMs = timeoutOf(options);
+    }
+    catch (error) {
+        await host.close().catch(() => undefined);
+        throw error;
+    }
+    const required = options.version === undefined || options.version === "" || options.version === "latest"
+        ? undefined
+        : options.version;
+    const origin = `sysml-wasm ${host.version}`;
+    return Connection.open({
+        transport: createWasmTransport(host, options),
+        backend: {
+            origin,
+            release: () => host.close(),
+            warn: (message) => {
+                console.warn(message);
+            },
+        },
+        encoding: "json",
+        timeoutMs,
+        ...(required === undefined ? {} : { requiredVersion: required }),
+        ...(options.requireCapabilities === undefined
+            ? {}
+            : { requiredCapabilities: options.requireCapabilities }),
+        stale: {
+            address: origin,
+            remedy: required === undefined
+                ? "use a module reporting the expected version, or omit version"
+                : `use a module reporting ${required}, or omit version`,
+        },
+    });
+}
+/** Adapts a platform worker endpoint to the shared WASM host protocol. */
+export class WorkerWasmHost {
+    endpoint;
+    version = "";
+    pending = new Map();
+    ready;
+    resolveReady;
+    rejectReady;
+    nextId = 1;
+    failure;
+    closed = false;
+    constructor(endpoint) {
+        this.endpoint = endpoint;
+        this.ready = new Promise((resolve, reject) => {
+            this.resolveReady = resolve;
+            this.rejectReady = reject;
+        });
+        endpoint.onMessage((message) => {
+            this.receive(message);
+        });
+        endpoint.onFailure((reason) => {
+            this.fail(reason);
+        });
+    }
+    async start(request, transfer) {
+        this.endpoint.post(request, transfer);
+        await this.ready;
+        return this;
+    }
+    async call(method, params, signal) {
+        if (signal?.aborted) {
+            throw abortError(signal);
+        }
+        this.throwIfFailed();
+        if (this.closed) {
+            throw new ConnectError("the sysml-wasm worker is closed", Code.Unavailable);
+        }
+        if (signal === undefined) {
+            await this.ready;
+        }
+        else {
+            await withAbort(this.ready, signal);
+        }
+        if (signal?.aborted) {
+            throw abortError(signal);
+        }
+        this.throwIfFailed();
+        this.throwIfClosed();
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            if (signal === undefined) {
+                this.pending.set(id, { resolve, reject });
+            }
+            else {
+                const onAbort = () => {
+                    this.removePending(id)?.reject(abortError(signal));
+                };
+                this.pending.set(id, { resolve, reject, signal, onAbort });
+                signal.addEventListener("abort", onAbort, { once: true });
+                if (signal.aborted) {
+                    onAbort();
+                    return;
+                }
+            }
+            try {
+                this.endpoint.post({ type: "call", id, method, params }, []);
+            }
+            catch (error) {
+                this.removePending(id)?.reject(ConnectError.from(error, Code.Unavailable));
+            }
+        });
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        try {
+            this.endpoint.post({ type: "close" }, []);
+        }
+        catch {
+            // A worker that has already failed has no message loop to close.
+        }
+        const closed = new ConnectError("the sysml-wasm worker was closed", Code.Unavailable);
+        for (const id of this.pending.keys()) {
+            this.removePending(id)?.reject(closed);
+        }
+        await this.endpoint.terminate();
+    }
+    receive(message) {
+        if (message.type === "ready") {
+            this.version = message.version;
+            this.resolveReady();
+            return;
+        }
+        if (message.type === "failed") {
+            this.fail(new Error(message.message));
+            return;
+        }
+        const pending = this.removePending(message.id);
+        if (pending !== undefined) {
+            pending.resolve(message.envelope);
+        }
+    }
+    fail(reason) {
+        if (this.failure !== undefined || this.closed) {
+            return;
+        }
+        this.failure = ConnectError.from(reason, Code.Unavailable);
+        this.rejectReady(this.failure);
+        for (const id of this.pending.keys()) {
+            this.removePending(id)?.reject(this.failure);
+        }
+    }
+    removePending(id) {
+        const pending = this.pending.get(id);
+        if (pending !== undefined) {
+            this.pending.delete(id);
+            if (pending.signal !== undefined && pending.onAbort !== undefined) {
+                pending.signal.removeEventListener("abort", pending.onAbort);
+            }
+        }
+        return pending;
+    }
+    throwIfFailed() {
+        const failure = this.failure;
+        if (failure !== undefined) {
+            throw failure;
+        }
+    }
+    throwIfClosed() {
+        if (this.closed) {
+            throw new ConnectError("the sysml-wasm worker is closed", Code.Unavailable);
+        }
+    }
+}
+/**
+ * Serves the shared init/call protocol on a Node or browser worker port.
+ */
+export function serveWasmPort(port, loaders = {}) {
+    let host;
+    let initializing = false;
+    let closed = false;
+    let calls = Promise.resolve();
+    const onMessage = (event) => {
+        const request = event.data;
+        if (request.type === "init") {
+            if (initializing || host !== undefined || closed) {
+                port.postMessage({ type: "failed", message: "the WASM worker is already initialized" });
+                return;
+            }
+            initializing = true;
+            void initialize(request.wasm, request.wasmExec);
+            return;
+        }
+        if (request.type === "close") {
+            closed = true;
+            void host?.close();
+            return;
+        }
+        calls = calls.then(async () => {
+            if (closed || host === undefined) {
+                port.postMessage({
+                    type: "answer",
+                    id: request.id,
+                    envelope: errorEnvelope(new ConnectError("the WASM worker is unavailable", Code.Unavailable)),
+                });
+                return;
+            }
+            try {
+                port.postMessage({
+                    type: "answer",
+                    id: request.id,
+                    envelope: await host.call(request.method, request.params),
+                });
+            }
+            catch (cause) {
+                port.postMessage({ type: "answer", id: request.id, envelope: errorEnvelope(cause) });
+            }
+        });
+    };
+    const initialize = async (source, wasmExec) => {
+        try {
+            const module = loaders.loadWasm
+                ? await loaders.loadWasm(source)
+                : await loadWasmSource(source);
+            const Go = loaders.loadGo
+                ? await loaders.loadGo(wasmExec)
+                : await loadGoConstructor(wasmExec);
+            host = await instantiateInline(module, Go);
+            port.postMessage({ type: "ready", version: host.version });
+        }
+        catch (cause) {
+            port.postMessage({ type: "failed", message: errorMessage(cause) });
+        }
+    };
+    port.addEventListener("message", onMessage);
+    port.start?.();
+}
+/** Loads and caches the Go constructor installed by wasm_exec.js. */
+export function loadGoConstructor(wasmExec) {
+    if (wasmExec === undefined) {
+        return goConstructorLoads.then(() => {
+            const Go = globalGoConstructor();
+            if (Go === undefined) {
+                throw new OpenSysMLError("Go is unavailable; supply the matching wasm_exec.js");
+            }
+            return Go;
+        });
+    }
+    const cached = goConstructors.get(wasmExec);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const loading = goConstructorLoads.then(() => loadGoConstructorFromScript(wasmExec));
+    goConstructors.set(wasmExec, loading);
+    goConstructorLoads = loading.then(() => undefined, () => undefined);
+    void loading.catch(() => {
+        if (goConstructors.get(wasmExec) === loading) {
+            goConstructors.delete(wasmExec);
+        }
+    });
+    return loading;
+}
+async function loadGoConstructorFromScript(wasmExec) {
+    const runtime = globalThis;
+    const previous = runtime.Go;
+    let loaded;
+    try {
+        try {
+            await import(wasmExec);
+        }
+        catch (cause) {
+            const importScripts = globalThis.importScripts;
+            if (importScripts === undefined) {
+                throw new OpenSysMLError(`could not load wasm_exec.js from ${wasmExec}`, { cause });
+            }
+            importScripts(wasmExec);
+        }
+        // Accept only a fresh constructor installed by this evaluation.
+        const current = runtime.Go;
+        if (current === undefined) {
+            if (previous !== undefined) {
+                throw new OpenSysMLError(`wasm_exec.js at ${wasmExec} did not install Go here; it may already have run in this realm. Omit wasmExec to use the installed Go, or load the runtime in a worker`);
+            }
+            throw new OpenSysMLError("Go is unavailable; supply the matching wasm_exec.js");
+        }
+        if (current === previous) {
+            throw new OpenSysMLError(`wasm_exec.js at ${wasmExec} did not install Go here; it may already have run in this realm. Omit wasmExec to use the installed Go, or load the runtime in a worker`);
+        }
+        loaded = current;
+        return current;
+    }
+    finally {
+        if (previous !== undefined) {
+            runtime.Go = previous;
+        }
+        else if (loaded === undefined) {
+            delete runtime.Go;
+        }
+    }
+}
+function globalGoConstructor() {
+    return globalThis.Go;
+}
+function readEnvelope(envelope) {
+    let parsed;
+    try {
+        parsed = JSON.parse(envelope);
+    }
+    catch (cause) {
+        throw ConnectError.from(cause, Code.Internal);
+    }
+    if (parsed === null || typeof parsed !== "object") {
+        throw new ConnectError("sysml-wasm returned an invalid JSON envelope", Code.Internal);
+    }
+    const response = parsed;
+    if (response.error !== undefined && response.error !== null) {
+        const status = typeof response.error.code === "number" &&
+            Object.values(Code).includes(response.error.code)
+            ? response.error.code
+            : Code.Unknown;
+        throw new ConnectError(typeof response.error.message === "string"
+            ? response.error.message
+            : "sysml-wasm returned an error", status);
+    }
+    if (!Object.hasOwn(response, "result")) {
+        throw new ConnectError("sysml-wasm returned an envelope without a result", Code.Internal);
+    }
+    return response.result;
+}
+function withAbort(answer, signal) {
+    if (signal.aborted) {
+        return Promise.reject(abortError(signal));
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => {
+            signal.removeEventListener("abort", onAbort);
+        };
+        const finish = (callback, value) => {
+            if (!settled) {
+                settled = true;
+                cleanup();
+                callback(value);
+            }
+        };
+        const fail = (error) => {
+            if (!settled) {
+                settled = true;
+                cleanup();
+                reject(ConnectError.from(error, Code.Internal));
+            }
+        };
+        const onAbort = () => {
+            fail(abortError(signal));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        answer.then((value) => {
+            finish(resolve, value);
+        }, fail);
+    });
+}
+function abortError(signal) {
+    return ConnectError.from(getAbortSignalReason(signal), Code.Canceled);
+}
+function errorEnvelope(error) {
+    const connectError = ConnectError.from(error, Code.Internal);
+    return JSON.stringify({
+        jsonrpc: "2.0",
+        id: null,
+        error: { code: connectError.code, message: connectError.rawMessage },
+    });
+}
+export async function loadWasmSource(source) {
+    if (source instanceof WebAssembly.Module ||
+        source instanceof ArrayBuffer ||
+        ArrayBuffer.isView(source)) {
+        return source;
+    }
+    const response = source instanceof Response ? source : await fetch(source);
+    if (!response.ok) {
+        throw new OpenSysMLError(`could not fetch the WebAssembly module: ${response.status}`);
+    }
+    if (typeof WebAssembly.compileStreaming === "function") {
+        try {
+            return await WebAssembly.compileStreaming(response.clone());
+        }
+        catch {
+            // Some servers omit the application/wasm content type required by streaming.
+        }
+    }
+    return response.arrayBuffer();
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function globalWasmSurface() {
+    return globalThis.sysmlWasm;
+}