crossbind 2.0.0-beta.62 → 2.0.0-beta.64

package/src/assets/js-runtime/adapters/worker-comlink.js

@@ -5,6 +5,8 @@ import {
     callWithVectorCoercion, wrapWithVectorCoercion, setCoercionModule, unwrapCoercionProxy,
 } from './vector-coercion.js';
 import { patchModuleForExceptionDecode } from './exception-decode.js';
+import urlPath from './path-url.js';
+import { UNBOUND_MESSAGE } from './unboundMessage.js';
 
 const isWorkerScope = typeof WorkerGlobalScope !== 'undefined'
     && typeof self !== 'undefined'
@@ -12,17 +14,87 @@ const isWorkerScope = typeof WorkerGlobalScope !== 'undefined'
 
 // === Embind <-> Comlink Bridge ===
 // Worker-side registry: id -> original embind object
-// Main-thread registry: Comlink proxy -> id
+// Main-thread registry: handle -> id
 const embindRegistry = new Map();
 const embindProxyIds = new WeakMap();
 let nextEmbindId = 1;
 
+// The objects the worker hands out are reached through the module's channel, so writes to them keep their order
+// with the calls after them; messages on different channels keep none.
+const HANDLES = '__crossbindHandles';
+let remoteModule = null;
+
+// How many ids name each object, as a raw pointer handed out twice is one object.
+const holders = new WeakMap();
+
 function registerEmbindObject(obj) {
     const id = nextEmbindId++;
     embindRegistry.set(id, obj);
+    holders.set(obj, (holders.get(obj) ?? 0) + 1);
     return id;
 }
 
+// What JavaScript owns: an object behind a smart pointer, or a copy embind made of a returned value or an object
+// JavaScript constructed, which utils/embindObjectLifetime.js marks. A raw pointer stays its library's.
+const ownsObject = (obj) => {
+    const $$ = obj?.$$;
+    return Boolean($$ && ($$.smartPtr || $$.count?.owned));
+};
+
+const freeIfOwned = (obj) => {
+    if (ownsObject(obj) && !obj.isDeleted()) obj.delete();
+};
+
+// The worker side of a handle the main thread no longer reaches: its id goes, and the object with the last id.
+const RELEASE = '__crossbindRelease';
+
+function releaseEmbindObjects(ids) {
+    for (const id of ids) {
+        const obj = embindRegistry.get(id);
+        if (!embindRegistry.delete(id)) continue;
+        const left = holders.get(obj) - 1;
+        if (left > 0) {
+            holders.set(obj, left);
+        } else {
+            holders.delete(obj);
+            freeIfOwned(obj);
+        }
+    }
+}
+
+// Comlink answers every member with a remote one: JSON.stringify and String() called toJSON and Symbol.toPrimitive
+// on the worker's object, which has neither, and a member below the module is thenable. A handle answers them as a
+// direct-mode object does.
+const LOCAL_MEMBERS = {
+    then: undefined,
+    toJSON: () => ({}),
+    [Symbol.toPrimitive]: (hint) => (hint === 'number' ? NaN : '[object Object]'),
+};
+
+// The main thread side: once a handle is collected, the worker lets go of its object, the ids collected in one task
+// in one message.
+const collected = [];
+
+function releaseLater(id) {
+    collected.push(id);
+    if (collected.length > 1) return;
+    setTimeout(() => {
+        const ids = collected.splice(0);
+        Promise.resolve(remoteModule?.[RELEASE](ids)).catch(() => {});
+    }, 0);
+}
+
+const handleWatcher = typeof FinalizationRegistry === 'function' ? new FinalizationRegistry(releaseLater) : null;
+
+function handleFor(id) {
+    const handle = new Proxy(remoteModule[HANDLES][id], {
+        get: (target, prop) => (Object.hasOwn(LOCAL_MEMBERS, prop) ? LOCAL_MEMBERS[prop] : target[prop]),
+    });
+    embindProxyIds.set(handle, id);
+    handleWatcher?.register(handle, id);
+    return handle;
+}
+
 // Reorder transfer handlers for correct priority
 const _proxyHandler = Comlink.transferHandlers.get('proxy');
 const _throwHandler = Comlink.transferHandlers.get('throw');
@@ -47,22 +119,16 @@ Comlink.transferHandlers.set('proxy', {
     canHandle: _proxyHandler.canHandle,
     serialize(obj) {
         if (typeof obj.delete === 'function' && typeof obj.isDeleted === 'function') {
-            // CONSTRUCT results (Comlink marks them with proxy()) are exposed through
-            // the same coercion wrapper as method-returned objects (embindObject
-            // handler), and the registry keeps the RAW object so arguments resolve
-            // back to real embind identities.
-            const raw = unwrapCoercionProxy(obj);
-            const [port, transferables] = _proxyHandler.serialize(wrapWithVectorCoercion(raw));
-            const id = registerEmbindObject(raw);
-            return [{ __embindId: id, __port: port }, transferables];
+            // CONSTRUCT results (Comlink marks them with proxy()) are handed out as
+            // method-returned objects are (embindObject handler), and the registry keeps
+            // the RAW object so arguments resolve back to real embind identities.
+            return [{ __embindId: registerEmbindObject(unwrapCoercionProxy(obj)) }, []];
         }
         return _proxyHandler.serialize(obj);
     },
     deserialize(data) {
         if (data != null && typeof data === 'object' && '__embindId' in data) {
-            const proxy = _proxyHandler.deserialize(data.__port);
-            embindProxyIds.set(proxy, data.__embindId);
-            return proxy;
+            return handleFor(data.__embindId);
         }
         return _proxyHandler.deserialize(data);
     },
@@ -102,40 +168,20 @@ Comlink.transferHandlers.set('embindVector', {
     serialize(obj) {
         const len = obj.size();
         const elements = new Array(len);
-        let hasObjects = false;
         for (let i = 0; i < len; i++) {
             const elem = obj.get(i);
-            elements[i] = elem;
-            if (!hasObjects && elem !== null && typeof elem === 'object') {
-                hasObjects = true;
-            }
-        }
-        if (!hasObjects) {
-            return [elements, []];
-        }
-        const transferables = [];
-        for (let i = 0; i < len; i++) {
-            const elem = elements[i];
-            if (elem !== null && typeof elem === 'object') {
-                const id = registerEmbindObject(elem);
-                const { port1, port2 } = new MessageChannel();
-                Comlink.expose(wrapWithVectorCoercion(elem), port1);
-                transferables.push(port2);
-                elements[i] = { __comlinkProxy: true, __embindId: id, port: port2 };
-            }
+            elements[i] = elem !== null && typeof elem === 'object'
+                ? { __comlinkProxy: true, __embindId: registerEmbindObject(elem) }
+                : elem;
         }
-        return [elements, transferables];
+        // The main thread gets the array alone, so nothing can reach a vector the call handed over any more.
+        freeIfOwned(unwrapCoercionProxy(obj));
+        return [elements, []];
     },
     deserialize(elements) {
-        return elements.map((elem) => {
-            if (elem && typeof elem === 'object' && elem.__comlinkProxy) {
-                elem.port.start();
-                const proxy = Comlink.wrap(elem.port);
-                embindProxyIds.set(proxy, elem.__embindId);
-                return proxy;
-            }
-            return elem;
-        });
+        return elements.map((elem) => (elem && typeof elem === 'object' && elem.__comlinkProxy
+            ? handleFor(elem.__embindId)
+            : elem));
     },
 });
 
@@ -210,20 +256,13 @@ Comlink.transferHandlers.set('embindObject', {
             && typeof obj.isDeleted === 'function';
     },
     serialize(obj) {
-        // An object a property returns comes wrapped by its owner's coercion proxy. Registering and exposing
-        // the raw object, as the proxy handler does, keeps objects read from it one wrapper deep, which an
-        // argument's unwrapping undoes.
-        const raw = unwrapCoercionProxy(obj);
-        const id = registerEmbindObject(raw);
-        const { port1, port2 } = new MessageChannel();
-        Comlink.expose(wrapWithVectorCoercion(raw), port1);
-        return [{ __embindId: id, port: port2 }, [port2]];
+        // An object a property returns comes wrapped by its owner's coercion proxy. Registering the raw object,
+        // as the proxy handler does, keeps objects read from it one wrapper deep, which an argument's unwrapping
+        // undoes.
+        return [{ __embindId: registerEmbindObject(unwrapCoercionProxy(obj)) }, []];
     },
     deserialize(data) {
-        data.port.start();
-        const proxy = Comlink.wrap(data.port);
-        embindProxyIds.set(proxy, data.__embindId);
-        return proxy;
+        return handleFor(data.__embindId);
     },
 });
 
@@ -251,16 +290,29 @@ Comlink.transferHandlers.set('embindProxyArray', {
 
 let _worker = null;
 
+// Configurable, so the coercion wrapper wraps the objects read through it as it does every other member.
+export function moduleRoot(m) {
+    Object.defineProperty(m, HANDLES, {
+        value: new Proxy({}, { get: (_, id) => embindRegistry.get(Number(id)) }),
+        configurable: true,
+    });
+    Object.defineProperty(m, RELEASE, { value: releaseEmbindObjects, configurable: true });
+    return wrapWithVectorCoercion(m);
+}
+
+export function adoptModule(remote) {
+    remoteModule = remote;
+    return remote;
+}
+
 function resolveScriptUrl(config) {
     const fileName = config.paths.js || config.paths.worker;
-    let prefix = '';
+    let prefix = urlPath.getDefaultPathPrefix();
     if (config.path) {
         prefix = config.path;
         if (prefix.slice(-1) !== '/') prefix += '/';
     }
-    let output = prefix + fileName;
-    if (output.substring(0, 4) !== 'http' && output[0] !== '/') output = `/${output}`;
-    return output;
+    return urlPath.finalizePath(prefix + fileName);
 }
 
 function exposeWorker(systemConfig, createModule) {
@@ -273,7 +325,7 @@ function exposeWorker(systemConfig, createModule) {
             // comlink throw handler, a raw WebAssembly.Exception does not.
             patchModuleForExceptionDecode(m);
             registerModuleEnums(m);
-            return Comlink.proxy(wrapWithVectorCoercion(m));
+            return Comlink.proxy(moduleRoot(m));
         },
     };
     Comlink.expose(workerApi);
@@ -288,10 +340,35 @@ async function initWithWorker(config, userConfig) {
         logHandler, errorHandler, onRuntimeInitialized, getWasmFunction, useWorker, workerUrl,
         ...serializableConfig
     } = userConfig;
-    const module = await workerApi.init(serializableConfig);
+    // The worker resolves a relative URL against its own script, so it gets the path resolved against the page.
+    const workerConfig = config.path ? { ...serializableConfig, path: urlPath.finalizePath(config.path) } : serializableConfig;
+    return moduleOnMainThread(adoptModule(await workerApi.init(workerConfig)));
+}
+
+// A call the worker cannot make, because the module lacks the function, fails there with a TypeError from inside comlink
+// that names nothing: the failed call asks for the member, and names it when the module has none.
+function namedCall(member, name, module) {
+    return new Proxy(member, {
+        // A member still needs Comlink's then to read its value (including an absent export).
+        get(target, prop) {
+            // Console formatters inspect function names and constructors synchronously.
+            if (prop === 'name') return name;
+            if (prop === 'constructor') return Function;
+            return prop !== 'then' && Object.hasOwn(LOCAL_MEMBERS, prop) ? LOCAL_MEMBERS[prop] : target[prop];
+        },
+        apply: (call, thisArg, args) => Reflect.apply(call, thisArg, args).catch(async (error) => {
+            const isBound = await Promise.resolve(module[name]).then((value) => value !== undefined, () => true);
+            if (isBound) throw error;
+            throw new Error(`crossbind: ${name} ${UNBOUND_MESSAGE}`);
+        }),
+    });
+}
 
+export function moduleOnMainThread(module) {
     return new Proxy(module, {
         get(target, prop) {
+            if (Object.hasOwn(LOCAL_MEMBERS, prop)) return LOCAL_MEMBERS[prop];
+            if (prop === 'constructor') return Object;
             if (prop === 'toArray') {
                 return function toArray(vector) {
                     if (Array.isArray(vector)) return vector;
@@ -306,7 +383,8 @@ async function initWithWorker(config, userConfig) {
                     return target.toVector(classOrName, array);
                 };
             }
-            return target[prop];
+            const member = target[prop];
+            return typeof prop === 'string' && typeof member === 'function' ? namedCall(member, prop, target) : member;
         },
     });
 }

package/src/assets/js-runtime/core.js

@@ -73,6 +73,17 @@ function buildLocateFile(config, adapter) {
     };
 }
 
+// WASMFS's FS.writeFile writes at the end of a file that exists (emsdk 6.0.9 js_api.cpp), where the classic FS
+// replaces it; opening the file for writing empties it first, unless the flags ask to append.
+function replaceOnWriteFile(FS) {
+    const { writeFile } = FS;
+    FS.writeFile = (path, data, opts) => {
+        const appends = typeof opts?.flags === 'string' && opts.flags.startsWith('a');
+        if (!appends) FS.close(FS.open(path, 'w', opts?.mode));
+        return writeFile(path, data, opts);
+    };
+}
+
 export function createBaseModule(Module, config, adapter) {
     return new Promise((resolve, reject) => {
         const locateFile = buildLocateFile(config, adapter);
@@ -137,6 +148,7 @@ export function createBaseModule(Module, config, adapter) {
         // fs-browser), which emscripten's onRuntimeInitialized callback cannot, so
         // both hooks run after the factory settles - adapter first, then the user's.
         Module(m).then(async (mod) => {
+            if (mod.FS) replaceOnWriteFile(mod.FS);
             if (adapter.onModuleReady) await adapter.onModuleReady(mod, config);
             if (config.onRuntimeInitialized) config.onRuntimeInitialized(mod);
             return mod;

package/src/assets/node-import-hooks.mjs

@@ -0,0 +1,61 @@
+// Node's module hooks for the native imports one crossbind build bound, so a Node app imports a header, a
+// conan: header or a package's header the way a bundler plugin lets it. Each resolves to a module that
+// re-exports its names from the runtime entry, which initNative() fills. Copied into dist by the build.
+import { registerHooks } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const SCHEME = /^(cargo|conan):/;
+const isBare = (specifier) => !/^(\.{1,2}\/|\/|[A-Za-z]:[\\/]|file:)/.test(specifier);
+
+function notBound(what, parentURL, cause) {
+    const from = parentURL ? `, imported from ${parentURL},` : '';
+    return new Error(`crossbind: ${what}${from} is not bound by the last crossbind build. Build again after adding a native import, or start Node with --import crossbind/node/dev to build whenever one is added; an import specifier computed at run time is not found by the build.`, { cause });
+}
+
+const exportOf = (name) => (typeof name === 'string' ? name : `${name.wire} as ${name.local}`);
+const proxyOf = (entry, names) => `export { ${['initNative', 'AllSymbols', ...names.map(exportOf)].join(', ')} } from ${JSON.stringify(entry)};\n`;
+
+// Another hook may still serve it; Node's own resolver hands an unknown scheme on unresolved.
+function resolveUnbound(specifier, context, nextResolve) {
+    let resolved;
+    try {
+        resolved = nextResolve(specifier, context);
+    } catch (error) {
+        throw notBound(specifier, context.parentURL, error);
+    }
+    if (SCHEME.test(resolved.url)) throw notBound(specifier, context.parentURL);
+    return resolved;
+}
+
+// `natives` lists each bound file, relative to the entry, with the bare specifiers that name it and the names it
+// exports, a name the entry exports under another as { local, wire }.
+export default function registerNativeImports(entry, { extensions, natives }) {
+    const entryUrl = new URL(entry).href;
+    const dir = path.dirname(fileURLToPath(entryUrl));
+    const isNative = new RegExp(`\\.(${extensions.join('|')})$`);
+    const byFile = new Map();
+    const bySpecifier = new Map();
+    natives.forEach(({ file, specifiers, names }) => {
+        const absolute = path.resolve(dir, file);
+        byFile.set(absolute, names);
+        specifiers.forEach((specifier) => bySpecifier.set(specifier, pathToFileURL(absolute).href));
+    });
+
+    registerHooks({
+        resolve(specifier, context, nextResolve) {
+            const url = bySpecifier.get(specifier);
+            if (url) return { url, format: 'module', shortCircuit: true };
+            if (isBare(specifier) && (SCHEME.test(specifier) || isNative.test(specifier))) return resolveUnbound(specifier, context, nextResolve);
+            return nextResolve(specifier, context);
+        },
+        load(url, context, nextLoad) {
+            if (!url.startsWith('file:')) return nextLoad(url, context);
+            const file = fileURLToPath(url);
+            const names = byFile.get(file);
+            if (names) return { format: 'module', source: proxyOf(entryUrl, names), shortCircuit: true };
+            if (isNative.test(file)) throw notBound(file);
+            return nextLoad(url, context);
+        },
+    });
+}

package/src/assets/toolchain-digests.json

@@ -1,49 +1,49 @@
 {
-    "version": "1.0.8",
+    "version": "1.0.13",
     "registry": "ghcr.io/crossbind",
     "toolchains": {
-        "rust": "1.98.1"
+        "rust": "1.99.1"
     },
     "images": {
         "rust-sysroot": {
-            "index": "sha256:d816d27f1f3b110aed92f7f81cb8eb99f58ba95cafc96a797c46f30536549a45",
+            "index": "sha256:c545ea396bd8919f7a671617dbbdf184bd0d6eb904d3170dd120d6671db3e0a9",
             "platforms": {
-                "linux/arm64": "sha256:217f908b3e1c883bed8cd4db65aae48044481e88126c09c3ce9bf754288d8720",
-                "linux/amd64": "sha256:15719494b51ea8ee6f3a71556b2c04f37828e632bc46d2c3fb7121a1afb37303"
+                "linux/arm64": "sha256:c53ee0a31c52fdc6eba175e479218ddbff0c071654b5e93a08ae768cdbbfe35a",
+                "linux/amd64": "sha256:1427255e619c3f5dcd3fa7fd284d15afbe00eef1a0798e08a9b50ebbb86c5234"
             }
         },
         "base": {
-            "index": "sha256:051aa70184d29e95d5192cc60cc42523b42fab72291efbf13f71006482f063c0",
+            "index": "sha256:5f5d133504cb2c81ee67a93ca5795698423277522caac742478510d6158ed559",
             "platforms": {
-                "linux/arm64": "sha256:cdf189ad4ae220698088fda54c4a5005a207542bba8ab2c01fe58fc008586df8",
-                "linux/amd64": "sha256:f501545972e2a253b19f1900946cfe39ce5dea74600d885cae47db3f320b506b"
+                "linux/arm64": "sha256:df1c82f4b7e00a4ab33e2423f6d5bbaa66dd67bc45b96e5498e3391ec5f55fae",
+                "linux/amd64": "sha256:ffc0a178bc821e56975d9348b7e44d8081b9c6fb9351bc168b38d5063d9864ea"
             }
         },
         "web": {
-            "index": "sha256:89e0ea288d42d9f24671e43b3e59dc6b9913e389b68e51d8f0e314e81d111bf3",
+            "index": "sha256:b5ee271886c316404cae103c5412bc02d811ad48fd36a919fdf3a82af14fe688",
             "platforms": {
-                "linux/amd64": "sha256:40fe9f7573ee5a696c68043b12486e4562e0b2a87f74ef21a9b11c08454aff75",
-                "linux/arm64": "sha256:7172f994c262600dcd1334806eee9b44e873ac42fe286bf8b0983491586d1225"
+                "linux/arm64": "sha256:91d35c9eac65f479f5139ba476b3daa3b517aab6f21f5206070af610cec5b62c",
+                "linux/amd64": "sha256:f308cb1702f308d69d9f21eb99aa109cdbf62e655549b483580476d8f01fb07b"
             }
         },
         "android": {
-            "index": "sha256:ef6dc5ed724e7ea977a1f644793967a5ad7ff62b9a6bb6f2971d4a2a9e8f5a4b",
+            "index": "sha256:a01ddeaed550091f45e720d09bd559978d4c46e396c4553b3fc4544b90033fd1",
             "platforms": {
-                "linux/amd64": "sha256:d6843be98e4bc56a21e39b2670d081f60d27b45c149c0ee132d2c45bde337ec8"
+                "linux/amd64": "sha256:3bafd0a3f80bf7370a19522a3b75cb58a977d1b1b28940ed02b87db1058a8fd6"
             }
         },
         "linux": {
-            "index": "sha256:e8b6e6afd1af9f3a84eee739bd25ce6abb8416c5af87a175b780cd18d871513d",
+            "index": "sha256:c1d7f9672edb6eeea86172d8ba8cc8ba824f6c53134587ea247ea5dc126d6c43",
             "platforms": {
-                "linux/amd64": "sha256:39fe90d1cb2fbb411823bc396d463e298020b5a93b9a5244f27644c5c0b87b2a",
-                "linux/arm64": "sha256:9cd9550a39010bf7f00bf08d8505a22f85e31155bf63c8a46597852dc72ef4cc"
+                "linux/amd64": "sha256:0ff9ee1d5c139eb97934919f7b9535af0eb2c3bebd9c1974fa95cfb143e3ccf7",
+                "linux/arm64": "sha256:f476e4a95635c04aca741937c2174a1915731c52c9d182b247e17d4ca4163b33"
             }
         },
         "windows": {
-            "index": "sha256:c90a7c495e8becc6154b20fc6226362813938413bb3af626d0d0982cceaf32c5",
+            "index": "sha256:53b08c8918a84023ea90c6420fff783564aced0ec711fa0e7b71a09578643a32",
             "platforms": {
-                "linux/amd64": "sha256:1fbc5c59e09253cfe86bb54fa76f0c1c6b1c1e942e4059725658340f64708e59",
-                "linux/arm64": "sha256:229389bbabe838124cbb572b91b42ae0e3fdcd6020462203fdbbcf5864c4a234"
+                "linux/arm64": "sha256:402f115c8eed9e6418cf9e47a6bcad2d456d15d032c9b2baaa54a5005f00c8ba",
+                "linux/amd64": "sha256:50f359882015ca93c8b356a01bf03ce4cb098307f72c30122c7b6ad123eae339"
             }
         }
     }

package/src/assets/wasi-runtime/http/README.md

@@ -0,0 +1,17 @@
+# HTTP component runtime
+
+What an http build (`crossbind build -p wasi -e http`) links besides the app: `handler.cpp`, the
+`wasi:http/handler` export that calls the app's `crossbind::http::handle` (`include/crossbind/http.h`),
+and `bindings/`, which `wit-bindgen c` generated from `wit/`.
+
+`wit/deps/` holds the `http` package of the WASI 0.3.0 release, unchanged: `wasi-wit-0.3.0.tar.gz` from
+https://github.com/WebAssembly/WASI/releases/tag/v0.3.0 (sha256
+`596182ecd79311c8d010389b78b0253d54bee596254002df504ea5cf0124b894`), licensed as `wit/deps/LICENSE.md` says.
+
+After changing `wit/`, regenerate the bindings with wit-bindgen 0.62.0; with `--check` it confirms instead
+that the committed ones, the `.o` included, are what it generates:
+
+```bash
+wit-bindgen c wit --world crossbind-http --out-dir bindings
+wit-bindgen c wit --world crossbind-http --out-dir bindings --check
+```