crossbind 2.0.0-beta.62 → 2.0.0-beta.63

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,39 @@ 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;
+
 function registerEmbindObject(obj) {
     const id = nextEmbindId++;
     embindRegistry.set(id, obj);
     return id;
 }
 
+// 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]'),
+};
+
+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);
+    return handle;
+}
+
 // Reorder transfer handlers for correct priority
 const _proxyHandler = Comlink.transferHandlers.get('proxy');
 const _throwHandler = Comlink.transferHandlers.get('throw');
@@ -47,22 +71,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 +120,18 @@ 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];
+        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 +206,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 +240,28 @@ 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,
+    });
+    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 +274,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 +289,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 +332,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,16 @@ 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.
+function replaceOnWriteFile(FS) {
+    const { writeFile } = FS;
+    FS.writeFile = (path, data) => {
+        FS.close(FS.open(path, 'w'));
+        return writeFile(path, data);
+    };
+}
+
 export function createBaseModule(Module, config, adapter) {
     return new Promise((resolve, reject) => {
         const locateFile = buildLocateFile(config, adapter);
@@ -137,6 +147,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.12",
     "registry": "ghcr.io/crossbind",
     "toolchains": {
-        "rust": "1.98.1"
+        "rust": "1.99.0"
     },
     "images": {
         "rust-sysroot": {
-            "index": "sha256:d816d27f1f3b110aed92f7f81cb8eb99f58ba95cafc96a797c46f30536549a45",
+            "index": "sha256:fcaddb9514956c80c28152679d11817599b3c544e2bb56568d79dbd7699af805",
             "platforms": {
-                "linux/arm64": "sha256:217f908b3e1c883bed8cd4db65aae48044481e88126c09c3ce9bf754288d8720",
-                "linux/amd64": "sha256:15719494b51ea8ee6f3a71556b2c04f37828e632bc46d2c3fb7121a1afb37303"
+                "linux/arm64": "sha256:70dca2248666ee712ad5cb11fd013274ca4bb1efdafee732a0ec15492889f622",
+                "linux/amd64": "sha256:a3377c70598ef4e1918a73feeebb0ec1b80b3cde956daac9b2b62f9d742b88dc"
             }
         },
         "base": {
-            "index": "sha256:051aa70184d29e95d5192cc60cc42523b42fab72291efbf13f71006482f063c0",
+            "index": "sha256:86c6559bd51c10f8fc1ff6cbc0cf5386115fd7f0491a59f30f0d26a0203c200d",
             "platforms": {
-                "linux/arm64": "sha256:cdf189ad4ae220698088fda54c4a5005a207542bba8ab2c01fe58fc008586df8",
-                "linux/amd64": "sha256:f501545972e2a253b19f1900946cfe39ce5dea74600d885cae47db3f320b506b"
+                "linux/amd64": "sha256:16056b4bd85ba1792791401003db0325c31d4aa4821ff40f6f2eb1e0fff1d3ce",
+                "linux/arm64": "sha256:8d213f83ddd1ad9101b74b2b071f304ac8924ffbe68d79ece50668076e0172c0"
             }
         },
         "web": {
-            "index": "sha256:89e0ea288d42d9f24671e43b3e59dc6b9913e389b68e51d8f0e314e81d111bf3",
+            "index": "sha256:ffa089b83160e380e0b4447f483bf66cb87324f89b8e80b5776ed9346275a5ca",
             "platforms": {
-                "linux/amd64": "sha256:40fe9f7573ee5a696c68043b12486e4562e0b2a87f74ef21a9b11c08454aff75",
-                "linux/arm64": "sha256:7172f994c262600dcd1334806eee9b44e873ac42fe286bf8b0983491586d1225"
+                "linux/arm64": "sha256:1baf14ee0f1a821c1562d12902fe362d3639f57acb31f969402f2a2d8486647f",
+                "linux/amd64": "sha256:d3bd3aa785447f1679fdcb898921f614579d9eaad2aa9e828675ba7f82dc11ec"
             }
         },
         "android": {
-            "index": "sha256:ef6dc5ed724e7ea977a1f644793967a5ad7ff62b9a6bb6f2971d4a2a9e8f5a4b",
+            "index": "sha256:830286886d8bb259e94e112e4f1bab5f153106365b17859d20c9ef714349e520",
             "platforms": {
-                "linux/amd64": "sha256:d6843be98e4bc56a21e39b2670d081f60d27b45c149c0ee132d2c45bde337ec8"
+                "linux/amd64": "sha256:1004144243fea89a8915417954073e8ffabb20d8a9aed31045ce2a95c1abe1da"
             }
         },
         "linux": {
-            "index": "sha256:e8b6e6afd1af9f3a84eee739bd25ce6abb8416c5af87a175b780cd18d871513d",
+            "index": "sha256:8d4cc55d2ef8ea40845fd13708575e06f6aecdc035e7200deddf8c662d5c910f",
             "platforms": {
-                "linux/amd64": "sha256:39fe90d1cb2fbb411823bc396d463e298020b5a93b9a5244f27644c5c0b87b2a",
-                "linux/arm64": "sha256:9cd9550a39010bf7f00bf08d8505a22f85e31155bf63c8a46597852dc72ef4cc"
+                "linux/arm64": "sha256:0de59cc6ce7b381f213af0d26ccc83e0c41545a91eb0b36c51832c7fb660566c",
+                "linux/amd64": "sha256:3b3bc24d8f5dffe3a2408193265a807764fcf2744243c0a5e07f312f608fc6c0"
             }
         },
         "windows": {
-            "index": "sha256:c90a7c495e8becc6154b20fc6226362813938413bb3af626d0d0982cceaf32c5",
+            "index": "sha256:a31110874a9b6b9e3fec177edc8a8093905902bcc6abc6a85e45eb0927d4f070",
             "platforms": {
-                "linux/amd64": "sha256:1fbc5c59e09253cfe86bb54fa76f0c1c6b1c1e942e4059725658340f64708e59",
-                "linux/arm64": "sha256:229389bbabe838124cbb572b91b42ae0e3fdcd6020462203fdbbcf5864c4a234"
+                "linux/arm64": "sha256:bd9ec6ba60952f929e09777374a3bb05512bbe796325c0e8a0b84e1a12d1b86c",
+                "linux/amd64": "sha256:01f4bd8c4d1044bde68fe758d2632c510f8efb76aa4bad28696f9e9b199c8f4e"
             }
         }
     }

package/src/assets/wasi-runtime/stubs.c

@@ -7,12 +7,32 @@
 
 #include <netinet/in.h>
 #include <sys/socket.h>
+#include <sys/stat.h>
+#include <unistd.h>
 
 /* Compiled by the C++ driver at the command link; keep C linkage. */
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+/* wasi-libc p2/p3 leaves its output stream at the old offset after SEEK_END. SEEK_SET resets
+   that stream, so resolve the end offset through fstat and perform an absolute seek instead. */
+off_t __real_lseek(int fd, off_t offset, int whence);
+off_t __wrap_lseek(int fd, off_t offset, int whence)
+{
+    if (whence == SEEK_END) {
+        struct stat status;
+        if (fstat(fd, &status) != 0) return (off_t)-1;
+        off_t absolute;
+        if (__builtin_add_overflow(status.st_size, offset, &absolute)) {
+            errno = EOVERFLOW;
+            return (off_t)-1;
+        }
+        return __real_lseek(fd, absolute, SEEK_SET);
+    }
+    return __real_lseek(fd, offset, whence);
+}
+
 /* No dynamic loading on WASI; loaders treat NULL as "plugin unavailable". */
 void *dlopen(const char *file, int mode)
 {
@@ -79,6 +99,15 @@ int getpeername(int fd, struct sockaddr *addr, socklen_t *len)
     return crossbind_zeroed_inet(addr, len);
 }
 
+/* The WASI SQLite leaves extension loading out, yet SpatiaLite's stored procedures switch it off; this answers
+   SQLITE_ERROR as such a build does. Weak, so a SQLite that has the function keeps its own. */
+__attribute__((weak)) int sqlite3_enable_load_extension(void *db, int onoff)
+{
+    (void)db;
+    (void)onoff;
+    return 1;
+}
+
 #ifdef __cplusplus
 }
 #endif