crossbind 2.0.0-beta.60 → 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,16 +206,13 @@ Comlink.transferHandlers.set('embindObject', {
             && typeof obj.isDeleted === 'function';
     },
     serialize(obj) {
-        const id = registerEmbindObject(obj);
-        const { port1, port2 } = new MessageChannel();
-        Comlink.expose(wrapWithVectorCoercion(obj), 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);
     },
 });
 
@@ -247,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) {
@@ -269,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);
@@ -284,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;
@@ -302,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,35 +1,49 @@
 {
-    "version": "1.0.6",
+    "version": "1.0.12",
     "registry": "ghcr.io/crossbind",
     "toolchains": {
-        "rust": "1.98.1"
+        "rust": "1.99.0"
     },
     "images": {
         "rust-sysroot": {
-            "index": "sha256:b82285c6c74f0f2f21bd4f3d07af8a005b16b9e8faaecbe672f6e9b139616eb7",
+            "index": "sha256:fcaddb9514956c80c28152679d11817599b3c544e2bb56568d79dbd7699af805",
             "platforms": {
-                "linux/arm64": "sha256:50f2bc41d084157bb2d63caa8a91486ea15d3aff248e0d84013a20c7b8cf0c57",
-                "linux/amd64": "sha256:65c63d0b3df31406c514a6ed9dbb5ba0940b27c94e2e89b3ceafedaee339bca8"
+                "linux/arm64": "sha256:70dca2248666ee712ad5cb11fd013274ca4bb1efdafee732a0ec15492889f622",
+                "linux/amd64": "sha256:a3377c70598ef4e1918a73feeebb0ec1b80b3cde956daac9b2b62f9d742b88dc"
             }
         },
         "base": {
-            "index": "sha256:3a742a779a68e0180ca43232b9e28047e469462c575f1cdef8a3af3ba984263b",
+            "index": "sha256:86c6559bd51c10f8fc1ff6cbc0cf5386115fd7f0491a59f30f0d26a0203c200d",
             "platforms": {
-                "linux/amd64": "sha256:ff2a42fe5cdff75a9ce89fde340dbde5655f639de2e1288baeb61f2e82d1d095",
-                "linux/arm64": "sha256:2571179e6597369544a887da197e280ad9d15075719c04113cc2fd243358f56d"
+                "linux/amd64": "sha256:16056b4bd85ba1792791401003db0325c31d4aa4821ff40f6f2eb1e0fff1d3ce",
+                "linux/arm64": "sha256:8d213f83ddd1ad9101b74b2b071f304ac8924ffbe68d79ece50668076e0172c0"
             }
         },
         "web": {
-            "index": "sha256:cd9065909b8e4aea584fbe6f6e0215773feaed97ab46e5ce265a487171f87757",
+            "index": "sha256:ffa089b83160e380e0b4447f483bf66cb87324f89b8e80b5776ed9346275a5ca",
             "platforms": {
-                "linux/arm64": "sha256:224665ea653e6ff6e483fc24b226fa68bf45173a2598439665d827780cbe5534",
-                "linux/amd64": "sha256:862b197c13dbdf163d480d35e8b17f96b23b447701cb8e79f0252773d7a48a42"
+                "linux/arm64": "sha256:1baf14ee0f1a821c1562d12902fe362d3639f57acb31f969402f2a2d8486647f",
+                "linux/amd64": "sha256:d3bd3aa785447f1679fdcb898921f614579d9eaad2aa9e828675ba7f82dc11ec"
             }
         },
         "android": {
-            "index": "sha256:0d0b56a76cff5b16f52eba3a4d2b17bc888fb2ca502bfd0ae029bf837c6c354d",
+            "index": "sha256:830286886d8bb259e94e112e4f1bab5f153106365b17859d20c9ef714349e520",
             "platforms": {
-                "linux/amd64": "sha256:77fb9007369c5c8003024aade231642afb798664f82aada1a8ac26b931a15fbf"
+                "linux/amd64": "sha256:1004144243fea89a8915417954073e8ffabb20d8a9aed31045ce2a95c1abe1da"
+            }
+        },
+        "linux": {
+            "index": "sha256:8d4cc55d2ef8ea40845fd13708575e06f6aecdc035e7200deddf8c662d5c910f",
+            "platforms": {
+                "linux/arm64": "sha256:0de59cc6ce7b381f213af0d26ccc83e0c41545a91eb0b36c51832c7fb660566c",
+                "linux/amd64": "sha256:3b3bc24d8f5dffe3a2408193265a807764fcf2744243c0a5e07f312f608fc6c0"
+            }
+        },
+        "windows": {
+            "index": "sha256:a31110874a9b6b9e3fec177edc8a8093905902bcc6abc6a85e45eb0927d4f070",
+            "platforms": {
+                "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