crossbind 2.0.0-beta.56 → 2.0.0-beta.60

package/README.md

@@ -21,7 +21,7 @@
     <a href="#start-with-a-coding-agent">Coding agents</a>
     · <a href="https://crossbind.dev/guide/">Guide</a>
     · <a href="https://crossbind.dev/guide/quick-start/">Quick start</a>
-    · <a href="https://crossbind.dev/guide/packages/">Libraries</a>
+    · <a href="https://crossbind.dev/guide/libraries/">Libraries</a>
     · <a href="https://github.com/crossbind/crossbind/tree/main/examples">Examples</a>
     · <a href="https://github.com/crossbind/crossbind/blob/main/CONTRIBUTING.md">Contributing</a>
   </p>
@@ -275,7 +275,7 @@ export default {
 
 The variant declares its transitive native dependency graph, so link order is
 derived automatically. Install and register every platform variant your
-project actually builds. See the [package guide](https://crossbind.dev/guide/packages/)
+project actually builds. See the [library guide](https://crossbind.dev/guide/libraries/)
 and [`ports/README.md`](https://github.com/crossbind/crossbind/blob/main/ports/README.md)
 for the package and license contracts.
 
@@ -345,4 +345,4 @@ pull-request process.
 crossbind is available under the
 [MIT License](https://github.com/crossbind/crossbind/blob/main/LICENSE).
 
-Copyright © 2026 Buğra Sarı
+Copyright © 2026 Buğra Sarı and crossbind contributors

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "crossbind",
-    "version": "2.0.0-beta.56",
+    "version": "2.0.0-beta.60",
     "license": "MIT",
     "homepage": "https://crossbind.dev",
     "repository": "https://github.com/crossbind/crossbind.git",
@@ -19,8 +19,8 @@
         "test:coverage": "vitest run --coverage"
     },
     "devDependencies": {
-        "@vitest/coverage-v8": "^4.1.10",
-        "vitest": "^4.1.10"
+        "@vitest/coverage-v8": "^5.0.1",
+        "vitest": "^5.0.1"
     },
     "dependencies": {
         "@rollup/plugin-commonjs": "^29.0.3",
@@ -33,7 +33,7 @@
         "log-update": "^8.0.0",
         "picocolors": "^1.1.1",
         "replace": "^1.2.2",
-        "rollup": "^4.62.4",
+        "rollup": "^4.63.4",
         "spdx-expression-parse": "^5.0.0",
         "upath": "^3.0.8"
     },

package/src/actions/buildWasm.js

@@ -13,6 +13,24 @@ import { getContentHash, getFilesFingerprint } from '../utils/hash.js';
 import { buildLinkLibArgs } from '../utils/linkLayout.js';
 import buildAppRustCrates from '../utils/appRustCrates.js';
 
+// embind's bigint converter turns any Number into a BigInt, so 2^53+1 silently becomes 2^53.
+// A 64-bit parameter takes a BigInt or a Number that is a safe integer instead; the jsi adapter
+// enforces the same rule natively. Each runtimeEnv links its own glue, so each one calls this.
+function guardBigIntArguments(target) {
+    const gluePath = `${state.config.paths.build}/${target.rawJsName}`;
+    replace({
+        regex: 'if\\s*\\(\\s*typeof value\\s*==\\s*"number"\\s*\\)\\s*\\{\\s*value\\s*=\\s*BigInt\\(value\\)\\s*;?\\s*\\}',
+        replacement: 'if(typeof value=="number"){if(!Number.isSafeInteger(value))throw new TypeError("a 64-bit integer parameter takes a BigInt or a safe integer Number, got "+value);value=BigInt(value)}',
+        paths: [gluePath],
+        recursive: false,
+        silent: true,
+    });
+    const glue = fs.readFileSync(gluePath, 'utf8');
+    if (glue.includes('__embind_register_bigint') && !glue.includes('Number.isSafeInteger(value)')) {
+        logger.error('bigint safe-integer rewrite missed (emscripten glue format changed?): 64-bit Number arguments round silently');
+    }
+}
+
 export default async function buildWasm(target, options = {}) {
     const isProd = target.buildType === 'release';
     const buildType = isProd ? 'Release' : 'Debug';
@@ -226,6 +244,7 @@ export default async function buildWasm(target, options = {}) {
             recursive: false,
             silent: true,
         }); */
+        guardBigIntArguments(target);
         await buildJs(target);
         // fs.rmSync(`${state.config.paths.build}/${state.config.general.name}.js`);
         // fs.copyFileSync(`${state.config.paths.build}/${state.config.general.name}.browser.js`, `${state.config.paths.build}/${state.config.general.name}.js`);
@@ -263,6 +282,7 @@ export default async function buildWasm(target, options = {}) {
         const t1 = performance.now();
         logger.doneStep(target, 'wasm');
         logger.startStep(target, 'js');
+        guardBigIntArguments(target);
         await buildJs(target);
         logger.doneStep(target, 'js');
     }
@@ -294,6 +314,7 @@ export default async function buildWasm(target, options = {}) {
         ], null, target);
         logger.doneStep(target, 'wasm');
         logger.startStep(target, 'js');
+        guardBigIntArguments(target);
         await buildJs(target);
         if (emccFlags.includes('FETCH')) {
             fs.appendFileSync(`${state.config.paths.build}/${target.jsName}`, 'var XMLHttpRequest = require(\'xhr2\');\n');

package/src/actions/createInterface.js

@@ -6,10 +6,19 @@ import { getFileHash } from '../utils/hash.js';
 import guardAsyncBindings from '../utils/bridgeAsyncGuard.js';
 import { writeHeaderDts, parseCppSurface } from '../utils/cppDts.js';
 import { injectFieldBindings } from '../utils/cppFieldBindings.js';
+import {
+    buildInterfaceContent, completingIncludes, findHeaderPrelude, findIgnoredDeclarations, indexTypeDefinitions, interfaceIncludes,
+    interfaceToRetryWithoutMacros, parseMacroDump, referencedTypeHeaders, selectSwigMacros,
+} from '../utils/swigInterface.js';
 import writeIfChanged from '../utils/writeIfChanged.js';
-import run from './run.js';
+import run, { cxxPreprocessorFor } from './run.js';
 
-export default function createBridgeFile(headerOrModuleFilePath, target = state.targets.find((t) => t.platform === 'wasm')) {
+// Part of every interface hash, so interfaces cached by an older generator are rebuilt.
+const INTERFACE_FORMAT = 'swig-macros-1';
+const predefinedMacros = new Map();
+const typeDefinitions = new Map();
+
+export default function createBridgeFile(headerOrModuleFilePath, target = state.targets.find((t) => t.platform === 'wasm'), { withDependencies = true } = {}) {
     const interfaceFilePath = upath.resolve(headerOrModuleFilePath);
     if (!fs.existsSync(`${state.config.paths.build}/interface`)) {
         fs.mkdirSync(`${state.config.paths.build}/interface`, { recursive: true });
@@ -17,10 +26,11 @@ export default function createBridgeFile(headerOrModuleFilePath, target = state.
     if (!fs.existsSync(`${state.config.paths.build}/bridge`)) {
         fs.mkdirSync(`${state.config.paths.build}/bridge`, { recursive: true });
     }
-    const interfaceFile = createInterfaceFile(interfaceFilePath, target);
     // The header may live outside paths.native (e.g. a package-subpath import like
     // '@scope/pkg/native/x.h'), so its own directory must reach swig's include list.
-    const bridgeFile = createBridgeFileFromInterfaceFile(interfaceFile, target, upath.dirname(interfaceFilePath));
+    const sourceDir = upath.dirname(interfaceFilePath);
+    const interfaceFile = createInterfaceFile(interfaceFilePath, target, sourceDir);
+    const bridgeFile = createBridgeFileFromInterfaceFile(interfaceFile, target, sourceDir, getFileHash(interfaceFilePath));
     const moduleRegex = new RegExp(`.(${state.config.ext.module.join('|')})$`);
     if (bridgeFile && !moduleRegex.test(interfaceFilePath)) {
         // SWIG's -embind backend emits no member variables; inject .property lines for the
@@ -41,21 +51,43 @@ export default function createBridgeFile(headerOrModuleFilePath, target = state.
             dtsMode: state.config.dts,
         });
     }
+    if (bridgeFile && withDependencies && !moduleRegex.test(interfaceFilePath)) {
+        // A header's own bindings need the types its declarations use registered, which only their headers' bridges do.
+        const dependencyBridges = dependencyHeadersOf(interfaceFilePath, target).map((header) => {
+            try {
+                return createBridgeFile(header, target, { withDependencies: false });
+            } catch (e) {
+                console.warn(`crossbind: ${upath.basename(interfaceFilePath)} uses types from ${upath.basename(header)}, whose bindings failed (${e.message})`);
+                return null;
+            }
+        }).filter(Boolean);
+        writeIfChanged(`${bridgeFile}.deps`, dependencyBridges.map((dependency) => `${dependency}\n`).join(''));
+    }
     return bridgeFile;
 }
 
-function createInterfaceFile(headerOrModuleFilePath, target) {
+function createInterfaceFile(headerOrModuleFilePath, target, sourceDir) {
     if (!headerOrModuleFilePath) {
         return null;
     }
-    const fileHash = getFileHash(headerOrModuleFilePath);
+    const moduleRegex = new RegExp(`.(${state.config.ext.module.join('|')})$`);
+    const isModule = moduleRegex.test(headerOrModuleFilePath);
+    const { includeRoot, headerPath } = isModule ? {} : includeLocation(headerOrModuleFilePath, target);
+    const packages = [state.config, ...state.config.allDependencies];
+    const prelude = isModule ? [] : findHeaderPrelude(headerOrModuleFilePath, packages, headerPath);
+    const ignored = isModule ? [] : findIgnoredDeclarations(headerOrModuleFilePath, packages, headerPath);
+    const completing = includeRoot ? findCompletingIncludes(headerOrModuleFilePath, includeRoot, headerPath) : [];
+    // A prelude or ignored-declaration change in the owning package, or a completed class moving to another header, must
+    // regenerate the interface as well.
+    const fileHash = [
+        INTERFACE_FORMAT, getFileHash(headerOrModuleFilePath), ...prelude,
+        ...(ignored.length ? [`ignored:${ignored.join(',')}`] : []), ...(completing.length ? [`completing:${completing.join(',')}`] : []),
+    ].join('\n');
     const cachedInterface = state.cache.interfaces[headerOrModuleFilePath];
     if (state.cache.hashes[headerOrModuleFilePath] === fileHash && cachedInterface && fs.existsSync(cachedInterface)) {
         return cachedInterface;
     }
 
-    const moduleRegex = new RegExp(`.(${state.config.ext.module.join('|')})$`);
-    const isModule = moduleRegex.test(headerOrModuleFilePath);
     if (isModule) {
         const newPath = `${state.config.paths.build}/interface/${headerOrModuleFilePath.split('/').pop()}`;
         fs.copyFileSync(headerOrModuleFilePath, newPath);
@@ -65,13 +97,6 @@ function createInterfaceFile(headerOrModuleFilePath, target) {
         return newPath;
     }
 
-    const headerPaths = (state.config.dependencyParameters?.getCmakeDependsPathAndName(target).pathsOfCmakeDepends || [])
-        .filter((d) => d.startsWith(state.config.paths.base));
-
-    const temp2 = headerPaths
-        .map((p) => headerOrModuleFilePath.match(new RegExp(`^${p}/.*?/include/(.*?)$`, 'i')))
-        .filter((p) => p && p.length === 2);
-
     const temp = headerOrModuleFilePath.match(/^(.*)\..+?$/);
     if (!temp || temp.length < 2) return null;
 
@@ -89,27 +114,14 @@ function createInterfaceFile(headerOrModuleFilePath, target) {
 
     const fileName = filePathWithoutExt.split('/').at(-1);
 
-    let headerPath = state.config.paths.header.find((path) => headerOrModuleFilePath.startsWith(path));
-    if (headerPath) headerPath = headerOrModuleFilePath.substr(headerPath.length + 1);
-    else if (temp2 && temp2.length > 0) headerPath = temp2[0][1];
-    else headerPath = headerOrModuleFilePath.split('/').at(-1);
-
-    const content = `#ifndef _${fileName.toUpperCase()}_I
-#define _${fileName.toUpperCase()}_I
-
-%module ${fileName.toUpperCase()}
-
-%{
-#include "${headerPath}"
-%}
-
-%feature("shared_ptr");
-%feature("polymorphic_shared_ptr");
-
-%include "${headerPath}"
-
-#endif
-`;
+    const content = buildInterfaceContent({
+        moduleName: fileName.toUpperCase(),
+        headerPath,
+        prelude,
+        completing,
+        swigMacros: collectSwigMacros(headerOrModuleFilePath, interfaceIncludes(headerPath, prelude), fileName, target, sourceDir),
+        ignored,
+    });
     const outputFilePath = `${state.config.paths.build}/interface/${fileName}.i`;
     fs.writeFileSync(outputFilePath, content);
 
@@ -120,6 +132,83 @@ function createInterfaceFile(headerOrModuleFilePath, target) {
     return outputFilePath;
 }
 
+// A header is included by its path under a project header directory or a dependency's include directory; one found only
+// through its own directory has no include root to search.
+function includeLocation(headerFile, target) {
+    const projectRoot = state.config.paths.header.find((path) => headerFile.startsWith(path));
+    if (projectRoot) return { includeRoot: projectRoot, headerPath: headerFile.substr(projectRoot.length + 1) };
+    const dependencyRoots = (state.config.dependencyParameters?.getCmakeDependsPathAndName(target).pathsOfCmakeDepends || [])
+        .filter((d) => d.startsWith(state.config.paths.base));
+    const match = dependencyRoots.map((p) => headerFile.match(new RegExp(`^(${p}/.*?/include)/(.*?)$`, 'i'))).find(Boolean);
+    return match ? { includeRoot: match[1], headerPath: match[2] } : { includeRoot: null, headerPath: headerFile.split('/').at(-1) };
+}
+
+// The headers under an include root are indexed once per build.
+function definitionsUnder(includeRoot) {
+    if (!typeDefinitions.has(includeRoot)) {
+        const extensions = new RegExp(`\\.(${state.config.ext.header.join('|')})$`, 'i');
+        const files = fs.readdirSync(includeRoot, { recursive: true, withFileTypes: true })
+            .filter((entry) => entry.isFile() && extensions.test(entry.name))
+            .map((entry) => upath.relative(includeRoot, upath.join(entry.parentPath, entry.name)))
+            .sort()
+            .map((path) => ({ path, text: fs.readFileSync(upath.join(includeRoot, path), 'utf8') }));
+        typeDefinitions.set(includeRoot, indexTypeDefinitions(files));
+    }
+    return typeDefinitions.get(includeRoot);
+}
+
+function findCompletingIncludes(headerFile, includeRoot, headerPath) {
+    const headerText = fs.readFileSync(headerFile, 'utf8');
+    if (!headerText.includes('unique_ptr')) return [];
+    return completingIncludes({ headerText, headerPath, definitions: definitionsUnder(includeRoot) });
+}
+
+function dependencyHeadersOf(headerFile, target) {
+    const { includeRoot, headerPath } = includeLocation(headerFile, target);
+    if (!includeRoot) return [];
+    const headerText = fs.readFileSync(headerFile, 'utf8');
+    return referencedTypeHeaders({ headerText, headerPath, definitions: definitionsUnder(includeRoot) })
+        .map((header) => upath.join(includeRoot, header));
+}
+
+// A header that does not preprocess on its own, or a host without the image's compiler, keeps the plain interface.
+function collectSwigMacros(headerFile, includes, name, target, sourceDir) {
+    const interfaceDir = `${state.config.paths.build}/interface`;
+    try {
+        if (!predefinedMacros.has(target.path)) {
+            predefinedMacros.set(target.path, dumpMacros(`${interfaceDir}/predefined-${target.path}.macros.h`, [], [], target));
+        }
+        const macros = dumpMacros(`${interfaceDir}/${name}.macros.h`, includes, swigIncludePath(target, sourceDir), target);
+        return selectSwigMacros({ headerText: fs.readFileSync(headerFile, 'utf8'), macros, predefined: predefinedMacros.get(target.path) });
+    } catch (e) {
+        console.warn(`crossbind: SWIG reads ${upath.basename(headerFile)} without the macros of its includes (${e.message})`);
+        return [];
+    }
+}
+
+function dumpMacros(outputFile, includes, includePath, target) {
+    run(cxxPreprocessorFor(target), [
+        '-x', 'c++', '-std=c++17', '-dM', '-E',
+        ...includePath,
+        ...includes.flatMap((header) => ['-include', header]),
+        '-o', outputFile,
+        '/dev/null',
+    ], null, target);
+    return parseMacroDump(fs.readFileSync(outputFile, 'utf8'));
+}
+
+function swigIncludePath(target, sourceDir) {
+    const allHeaders = state.config.dependencyParameters.headerPathWithDepends.split(';');
+    const includePath = [
+        ...state.config.allDependencies.map((d) => `${d.paths.output}/prebuilt/${target.path}/include`),
+        ...state.config.allDependencies.map((d) => `${d.paths.output}/prebuilt/${target.path}/swig`),
+        ...state.config.paths.header,
+        ...allHeaders,
+        ...(sourceDir ? [sourceDir] : []),
+    ].filter((path) => !!path.toString()).map((path) => `-I${path}`);
+    return [...new Set(includePath)];
+}
+
 // Idempotent: wraps every emscripten::async() registration in the generated
 // bridge behind #ifdef CROSSBIND_JSPI (see utils/bridgeAsyncGuard.js). Applied on
 // the cached path too, so bridges generated by older versions get guarded the
@@ -132,40 +221,52 @@ function applyAsyncGuard(bridgeFilePath) {
     }
 }
 
-function createBridgeFileFromInterfaceFile(interfaceFilePath, target, sourceDir = null) {
+// The interface text only names the header, so its hash alone kept a bridge across header edits: the
+// header's own hash is part of the key.
+function createBridgeFileFromInterfaceFile(interfaceFilePath, target, sourceDir = null, sourceHash = '') {
     if (!interfaceFilePath) {
         return null;
     }
 
-    const fileHash = getFileHash(interfaceFilePath);
+    const bridgeHash = () => `${getFileHash(interfaceFilePath)}\n${sourceHash}`;
+    const fileHash = bridgeHash();
     const cachedBridge = state.cache.bridges[interfaceFilePath];
     if (state.cache.hashes[interfaceFilePath] === fileHash && cachedBridge && fs.existsSync(cachedBridge)) {
         applyAsyncGuard(cachedBridge);
         return cachedBridge;
     }
 
-    const allHeaders = state.config.dependencyParameters.headerPathWithDepends.split(';');
-
-    let includePath = [
-        ...state.config.allDependencies.map((d) => `${d.paths.output}/prebuilt/${target.path}/include`),
-        ...state.config.allDependencies.map((d) => `${d.paths.output}/prebuilt/${target.path}/swig`),
-        ...state.config.paths.header,
-        ...allHeaders,
-        ...(sourceDir ? [sourceDir] : []),
-    ].filter((path) => !!path.toString()).map((path) => `-I${path}`);
-    includePath = [...new Set(includePath)];
-
-    run('swig', [
+    const bridgeFilePath = `${state.config.paths.build}/bridge/${interfaceFilePath.split('/').at(-1)}.cpp`;
+    // #error lines guard branches SWIG evaluates without the compiler's predefined macros, so they only warn.
+    const swig = () => run('swig', [
         '-c++',
         '-embind',
-        '-o', `${state.config.paths.build}/bridge/${interfaceFilePath.split('/').at(-1)}.cpp`,
-        ...includePath,
+        '-cpperraswarn',
+        '-o', bridgeFilePath,
+        ...swigIncludePath(target, sourceDir),
         interfaceFilePath,
     ], null, target);
-    applyAsyncGuard(`${state.config.paths.build}/bridge/${interfaceFilePath.split('/').at(-1)}.cpp`);
+    try {
+        swig();
+    } catch (e) {
+        // Known macros can expose declarations SWIG cannot parse and used to skip; without them it parses as before.
+        const content = fs.readFileSync(interfaceFilePath, 'utf8');
+        const plain = interfaceToRetryWithoutMacros(content, e);
+        if (!plain) throw e;
+        console.warn(`crossbind: SWIG cannot parse ${upath.basename(interfaceFilePath)} with the macros of its includes; generating it without them`);
+        fs.writeFileSync(interfaceFilePath, plain);
+        try {
+            swig();
+        } catch (retryError) {
+            // The cached interface keeps its macros, so the next build tries them again.
+            fs.writeFileSync(interfaceFilePath, content);
+            throw retryError;
+        }
+    }
+    applyAsyncGuard(bridgeFilePath);
 
-    state.cache.bridges[interfaceFilePath] = `${state.config.paths.build}/bridge/${interfaceFilePath.split('/').at(-1)}.cpp`;
-    state.cache.hashes[interfaceFilePath] = fileHash;
+    state.cache.bridges[interfaceFilePath] = bridgeFilePath;
+    state.cache.hashes[interfaceFilePath] = bridgeHash();
     saveCache();
 
     return state.cache.bridges[interfaceFilePath];

package/src/actions/createLib.js

@@ -11,6 +11,7 @@ import state from '../state/index.js';
 import logger from '../utils/logger.js';
 import { WASI_EMULATION_LIBS, WASI_LINK_LIBS, wasiCFlags, wasiCxxFlags } from '../utils/wasiToolchain.js';
 import { getFilesFingerprint, getContentHash } from '../utils/hash.js';
+import { withDependencyBridges } from '../utils/dependencyBridges.js';
 
 const cpuCount = Math.max(1, os.cpus().length - 1);
 const sharedPlatforms = ['android'];
@@ -31,9 +32,10 @@ export default function createLib(target, fileType, options = {}) {
     // wasi configure tool links need the runtime stubs; compiled below, referenced from LIBS.
     const wasiStubObj = `${buildPath}/crossbind-wasi-stubs.o`;
 
+    const nativeGlob = options.nativeGlob ? withDependencyBridges(options.nativeGlob) : undefined;
     // The lib dir is reused while the bridge list grows, so an early smaller nativeGlob build must not satisfy later sets: fingerprint the glob and miss on mismatch.
     const fingerprintFile = `${libdir}/crossbind-nativeglob.fingerprint`;
-    const fingerprint = options.nativeGlob ? getFilesFingerprint(options.nativeGlob) : null;
+    const fingerprint = nativeGlob ? getFilesFingerprint(nativeGlob) : null;
     const fingerprintChanged = fingerprint !== null
         && (!fs.existsSync(fingerprintFile) || fs.readFileSync(fingerprintFile, { encoding: 'utf8' }) !== fingerprint);
 
@@ -70,7 +72,7 @@ export default function createLib(target, fileType, options = {}) {
     // Bridges guard _JSPI registrations behind CROSSBIND_JSPI (bridgeAsyncGuard); define it only when this target links with -sJSPI.
     const isJspiTarget = target.platform === 'wasm' && configEmccFlags.includes('-sJSPI');
     if (fileType === 'Bridge' && target.platform === 'wasm' && !isJspiTarget
-        && options.nativeGlob?.some((f) => fs.existsSync(f) && fs.readFileSync(f, { encoding: 'utf8' }).includes('emscripten::async()'))) {
+        && nativeGlob?.some((f) => fs.existsSync(f) && fs.readFileSync(f, { encoding: 'utf8' }).includes('emscripten::async()'))) {
         logger.info(`[${target.path}] _JSPI bindings skipped: this target links without -sJSPI (add it to binary.emccFlags to enable them)`);
     }
 
@@ -138,7 +140,7 @@ export default function createLib(target, fileType, options = {}) {
             buildEnv.params.push('-e', e);
         });
     } else {
-        buildParams = getCmakeParameters(target, options);
+        buildParams = getCmakeParameters(target, { ...options, nativeGlob });
 
         triggerExtensions('createLib', 'setFlagWithoutBuildConfig', [buildEnv]);
 

package/src/actions/getAllBridges.js

@@ -13,7 +13,7 @@ export default function getAllBridges(log = console.log) {
         if (!fs.existsSync(sidecar)) return true;
         const source = fs.readFileSync(sidecar, 'utf8').trim();
         if (!source || fs.existsSync(source)) return true;
-        [bridge, `${bridge}.exports.json`, sidecar].forEach((f) => fs.rmSync(f, { force: true }));
+        [bridge, `${bridge}.exports.json`, `${bridge}.deps`, sidecar].forEach((f) => fs.rmSync(f, { force: true }));
         log(`crossbind: pruned stale bridge '${path.basename(bridge)}' - its header is gone`);
         return false;
     });

package/src/actions/run.js

@@ -11,7 +11,7 @@ import { wasiCFlags, wasiCxxFlags, resolveWasiSdkPath, WASI_TARGET_TRIPLE } from
 const EXEC_MAX_BUFFER = 512 * 1024 * 1024;
 const CROSSCOMPILER_ARM64 = 'aarch64-linux-android33';
 const CROSSCOMPILER_x86_64 = 'x86_64-linux-android33';
-const ANDROID_NDK = '/opt/android-sdk/ndk/27.3.13750724';
+const ANDROID_NDK = '/opt/android-sdk/ndk/current';
 const t = `${ANDROID_NDK}/toolchains/llvm/prebuilt/linux-x86_64/bin`;
 const t2 = `${ANDROID_NDK}/toolchains/llvm/prebuilt/linux-x86_64`;
 
@@ -62,6 +62,8 @@ const androidParamsX86_64 = [
     `CFLAGS=--sysroot=${t2}/sysroot`,
 ];
 
+// Xcode 27 refuses deployment targets below 15.0; React Native's own floor is 15.1.
+const IOS_DEPLOYMENT_TARGET = '15.1';
 const IOS_HOST_FLAGS = `-arch arm64 -isysroot ${iosSdkPath} -fembed-bitcode`;
 const IOS_SIM_HOST_FLAGS = `-arch arm64 -isysroot ${iosSimSdkPath} -fembed-bitcode`;
 const IOS_IPHONE_PARAMS = ['-e', `CFLAGS="${IOS_HOST_FLAGS}"`, '-e', `CXXFLAGS="${IOS_HOST_FLAGS}"`, '-e', `LDFLAGS="${IOS_HOST_FLAGS}"`];
@@ -102,6 +104,12 @@ const iosParams = [
     '-e', `LDFLAGS="${IOS_HOST_FLAGS}"`,
 ]; */
 
+// The C++ compiler of the image that runs SWIG for the target, so its -dM macro table matches that parse.
+export function cxxPreprocessorFor(target) {
+    if (imageRoleFor(target) !== 'android') return 'em++';
+    return `${t}/${target.arch === 'x86_64' ? CROSSCOMPILER_x86_64 : CROSSCOMPILER_ARM64}-clang++`;
+}
+
 export default function run(program, params = [], platformPrefix = null, target = null, dockerOptions = {}) {
     const buildPath = platformPrefix ? `${state.config.paths.build}/${platformPrefix}/${target.path}` : state.config.paths.build;
     if (!fs.existsSync(buildPath)) {
@@ -188,7 +196,7 @@ export default function run(program, params = [], platformPrefix = null, target
                             'Xcode',
                             '-DBUILD_SHARED_LIBS=OFF',
                             '-DFRAMEWORK=TRUE',
-                            '-DCMAKE_OSX_DEPLOYMENT_TARGET=13.0',
+                            `-DCMAKE_OSX_DEPLOYMENT_TARGET=${IOS_DEPLOYMENT_TARGET}`,
                             '-DCMAKE_SYSTEM_NAME=iOS',
                             `-DMACOSX_FRAMEWORK_IDENTIFIER=dev.crossbind.${state.config.general.name}`,
                             `-DCMAKE_XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER=dev.crossbind.${state.config.general.name}`,
@@ -209,11 +217,12 @@ export default function run(program, params = [], platformPrefix = null, target
                             ...dParams,
                             `-DCMAKE_TOOLCHAIN_FILE='${state.config.paths.cli}/assets/cmake/ios.toolchain.cmake'`,
                             `-DPLATFORM=${target.arch === 'iphoneos' ? 'OS64' : 'SIMULATORARM64'}`,
+                            `-DDEPLOYMENT_TARGET=${IOS_DEPLOYMENT_TARGET}`,
                             '-DARCHS=arm64',
                             '-DENABLE_BITCODE=TRUE',
                             '-DBUILD_SHARED_LIBS=OFF',
                             '-DFRAMEWORK=TRUE',
-                            '-DCMAKE_OSX_DEPLOYMENT_TARGET=13.0',
+                            `-DCMAKE_OSX_DEPLOYMENT_TARGET=${IOS_DEPLOYMENT_TARGET}`,
                             '-DCMAKE_SYSTEM_NAME=iOS',
                             `-DMACOSX_FRAMEWORK_IDENTIFIER=dev.crossbind.${state.config.general.name}`,
                             `-DCMAKE_XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER=dev.crossbind.${state.config.general.name}`,

package/src/assets/cmake/CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.28)
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 project("${PROJECT_NAME}")
 
 option(BUILD_BRIDGE "Build Bridge" OFF)

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

@@ -68,8 +68,27 @@ Comlink.transferHandlers.set('proxy', {
     },
 });
 
-// 3. throw (restored)
-Comlink.transferHandlers.set('throw', _throwHandler);
+// 3. throw (extended): comlink's own handler ships only message/name/stack, which drops the
+// properties a binding attaches to an error - `code` above all (Rust's error code, the napi
+// contract). Own enumerable primitives ride along; deserialize assigns them back onto the Error.
+Comlink.transferHandlers.set('throw', {
+    canHandle: _throwHandler.canHandle,
+    serialize(payload) {
+        const [serialized, transferables] = _throwHandler.serialize(payload);
+        const error = payload && payload.value;
+        if (serialized && serialized.isError && error instanceof Error) {
+            for (const key of Object.keys(error)) {
+                const value = error[key];
+                const kind = typeof value;
+                if (value === null || kind === 'string' || kind === 'number' || kind === 'boolean') {
+                    serialized.value[key] = value;
+                }
+            }
+        }
+        return [serialized, transferables];
+    },
+    deserialize: _throwHandler.deserialize,
+});
 
 // 4. embindVector: convert embind vectors to arrays across worker boundary
 Comlink.transferHandlers.set('embindVector', {

package/src/assets/toolchain-digests.json

@@ -1,35 +1,35 @@
 {
-    "version": "1.0.3",
+    "version": "1.0.6",
     "registry": "ghcr.io/crossbind",
     "toolchains": {
         "rust": "1.98.1"
     },
     "images": {
         "rust-sysroot": {
-            "index": "sha256:6a5db2ecf54398d837fdbbd8c1f2cdaafd14fd486ac3af4206d21bc9fe66e923",
+            "index": "sha256:b82285c6c74f0f2f21bd4f3d07af8a005b16b9e8faaecbe672f6e9b139616eb7",
             "platforms": {
-                "linux/arm64": "sha256:b5dbd8b4f233f5d6c0cfe7554b95b412e0e3396d4d4847facf116c155251b0b7",
-                "linux/amd64": "sha256:1989d0ab32d2372a2086efe50e33dbb861fa903e451b891f30004e0f172a1a9a"
+                "linux/arm64": "sha256:50f2bc41d084157bb2d63caa8a91486ea15d3aff248e0d84013a20c7b8cf0c57",
+                "linux/amd64": "sha256:65c63d0b3df31406c514a6ed9dbb5ba0940b27c94e2e89b3ceafedaee339bca8"
             }
         },
         "base": {
-            "index": "sha256:c9b501dca53bc2e51dddd1af64ede75220792e66a47ed488ad6172b58bee1b37",
+            "index": "sha256:3a742a779a68e0180ca43232b9e28047e469462c575f1cdef8a3af3ba984263b",
             "platforms": {
-                "linux/arm64": "sha256:edf01f0c4d7fc551e18775e76b2a6c2b9b54075b59f21f7635ccecaebcc6c282",
-                "linux/amd64": "sha256:debea6ee164eeba49155ad59365313a9dd291491b3339491a780b46d1b5b96f4"
+                "linux/amd64": "sha256:ff2a42fe5cdff75a9ce89fde340dbde5655f639de2e1288baeb61f2e82d1d095",
+                "linux/arm64": "sha256:2571179e6597369544a887da197e280ad9d15075719c04113cc2fd243358f56d"
             }
         },
         "web": {
-            "index": "sha256:633da840658f12f291c17c3305adf265c7d52307b3b61b84156d5f85f3121779",
+            "index": "sha256:cd9065909b8e4aea584fbe6f6e0215773feaed97ab46e5ce265a487171f87757",
             "platforms": {
-                "linux/arm64": "sha256:a5fe9f3693d789f04490963afbe80fa71a8ff0d0cc6e442b76ca37492fbf3221",
-                "linux/amd64": "sha256:65abff12143740d4557e9cbfd923b6fd6c5d01f25e96a1d27bbad5e083bb9f74"
+                "linux/arm64": "sha256:224665ea653e6ff6e483fc24b226fa68bf45173a2598439665d827780cbe5534",
+                "linux/amd64": "sha256:862b197c13dbdf163d480d35e8b17f96b23b447701cb8e79f0252773d7a48a42"
             }
         },
         "android": {
-            "index": "sha256:1f415db57ccb57c8850ad4498d9fead35f5104099fd355c067208b2e53c25b23",
+            "index": "sha256:0d0b56a76cff5b16f52eba3a4d2b17bc888fb2ca502bfd0ae029bf837c6c354d",
             "platforms": {
-                "linux/amd64": "sha256:38d7a10c233cfab13adb110383e386e2a649364a8285d6b3ad0696e1e343b58a"
+                "linux/amd64": "sha256:77fb9007369c5c8003024aade231642afb798664f82aada1a8ac26b931a15fbf"
             }
         }
     }

package/src/integration/getCrossbindScript.js

@@ -29,18 +29,21 @@ export function getRustJsScript(target, rsFile) {
     const cargoDeps = state.config.cargoDependencies ?? {};
     if (Object.hasOwn(cargoDeps, crateName)
         && path.dirname(rsReal) === fs.realpathSync(path.join(state.config.paths.cache, 'rust-crates'))) {
-        const { model } = createCrateImportBridge({
+        const { model, namePrefix } = createCrateImportBridge({
             crateName,
             spec: cargoDeps[crateName],
             cacheDir: state.config.paths.cache,
             dtsMode: state.config.dts,
             log: () => {},
         });
+        // A crate import registers its public names prefixed (two crates may export the same
+        // name), so the proxy exports the clean name and reads the prefixed one off the module.
         return buildScript(target, [
             ...model.classes.map((c) => c.name),
             ...model.enums.map((e) => e.name),
             ...model.freeFns.map((f) => f.jsName),
-        ]);
+            ...(model.consts ?? []).map((c) => c.name),
+        ].map((name) => ({ local: name, wire: `${namePrefix}${name}` })));
     }
 
     const pkg = state.config.allDependencies.find((d) => d.export?.type === 'cargo'
@@ -64,6 +67,8 @@ export function getRustJsScript(target, rsFile) {
         ...model.classes.map((c) => c.name),
         ...model.enums.map((e) => e.name),
         ...(model.freeFns ?? []).map((f) => f.jsName),
+        // `pub const`/`pub static` register as module constants, so the proxy exports them too.
+        ...(model.consts ?? []).map((c) => c.name),
         ...vectors.map((v) => v.name),
     ];
     return buildScript(target, symbols);
@@ -79,8 +84,11 @@ function buildScript(target, symbols) {
     let symbolExportDefineString = '';
     let symbolExportAssignString = '';
     if (symbols && Array.isArray(symbols)) {
-        symbolExportDefineString = symbols.map((s) => `export let ${s} = null;`).join('\n');
-        symbolExportAssignString = symbols.map((s) => `${s} = m.${s};`).join('\n');
+        // A symbol is either a plain name or { local, wire }: the second form exports `local`
+        // while reading the differently registered `wire` name off the module.
+        const pairs = symbols.map((s) => (typeof s === 'string' ? { local: s, wire: s } : s));
+        symbolExportDefineString = pairs.map((s) => `export let ${s.local} = null;`).join('\n');
+        symbolExportAssignString = pairs.map((s) => `${s.local} = m.${s.wire};`).join('\n');
     }
 
     return `
@@ -132,10 +140,10 @@ function buildScript(target, symbols) {
 
 function getReactNativeScript(env) {
     return `
-        import { NativeModules } from 'react-native';
+        import { TurboModuleRegistry } from 'react-native';
         import Module from '@crossbind/core-embind-jsi';
 
-        const { RNJsiLib } = NativeModules;
+        const RNJsiLib = TurboModuleRegistry.get('RNJsiLib');
 
         function setEnv() {
             const env = JSON.parse('${env}');