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

package/README.md

@@ -255,7 +255,7 @@ OpenSSL · PROJ · SpatiaLite · SQLite · libTIFF · WebP · zlib · Zstandard*
 
 Each family has target-specific packages. For example, a browser or Node.js
 project uses `@crossbind/port-gdal-wasm`, while mobile, native Node.js addon and
-WASI builds use the matching `-android`, `-ios`, `-darwin`, `-linux`, `-win32`,
+WASI builds use the matching `-android`, `-ios`, `-darwin`, `-linux`, `-linuxmusl`, `-win32`,
 or `-wasi` variant. Import the variant's `crossbind.config.js` into the
 application's dependency list:
 
@@ -285,7 +285,7 @@ Some upstream command-line tools are also published as WASI-powered npm
 commands. They require `wasmtime` on `PATH`, but no compiler:
 
 ```bash
-npm install --global @crossbind/port-gdal-bin-wasi@beta
+npm install --global @crossbind/port-gdal-standalone-wasi@beta
 gdalinfo-wasi --version
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "crossbind",
-    "version": "2.0.0-beta.62",
+    "version": "2.0.0-beta.63",
     "license": "MIT",
     "homepage": "https://crossbind.dev",
     "repository": "https://github.com/crossbind/crossbind.git",
@@ -13,6 +13,11 @@
         "crossbind": "./src/bin.js"
     },
     "main": "src/index.js",
+    "exports": {
+        ".": "./src/index.js",
+        "./node/dev": "./src/node/dev.mjs",
+        "./*": "./*"
+    },
     "scripts": {
         "test": "vitest run",
         "test:watch": "vitest",

package/src/actions/buildDependencies.js

@@ -14,6 +14,7 @@ import {
 } from '../utils/dependencyRebuild.js';
 import withDirLock from '../utils/dirLock.js';
 import { prepareRustSysroot } from '../utils/rustSysroot.js';
+import prepareConanDependencies from './prepareConanDependencies.js';
 import getAbsolutePath from '../utils/getAbsolutePath.js';
 import getCMakeListsFilePath from '../utils/getCMakeListsFilePath.js';
 import getParentPath from '../utils/getParentPath.js';
@@ -25,6 +26,7 @@ export default async function buildDependencies({ targetParams, rebuildOption })
     // sync cargo work downstream reads what it resolves. A project with nothing to rebuild still
     // needs its sysroot.
     await prepareRustSysroot(getBuildTargets(targetParams));
+    await prepareConanDependencies(getBuildTargets(targetParams));
     await buildMissingCargoDependencies(getBuildTargets(targetParams), targetParams);
 
     const rebuildDeps = getRebuildDeps(state.config.allDependencies, rebuildOption);
@@ -59,6 +61,11 @@ export default async function buildDependencies({ targetParams, rebuildOption })
     }
 }
 
+const isWasm = (target) => target.platform === 'wasm';
+const paramsOf = (target) => ({
+    platform: [target.platform], arch: [target.arch], runtime: [target.runtime], buildType: [target.buildType], runtimeEnv: [target.runtimeEnv],
+});
+
 // A cargo dependency carries every target in ONE package, so unlike a platform-split port there
 // is no "this sibling isn't for this target" case: a missing prebuilt means it was never built.
 // Nothing else builds these packages - buildDependencies only rebuilds deps that carry a source
@@ -66,11 +73,16 @@ export default async function buildDependencies({ targetParams, rebuildOption })
 // pre-build step nobody had written down. Worse, only the cmake link asserts the dependency is
 // there: on wasm a missing one silently drops out and the module builds clean, then dies at init.
 // Build it here instead, in the dependency's own package, where its prebuilt belongs.
-async function buildMissingCargoDependencies(targets, targetParams) {
-    if (targets.length === 0) return;
+async function buildMissingCargoDependencies(buildTargets, targetParams) {
+    if (buildTargets.length === 0) return;
     const appConfig = state.config;
     const cargoDependencies = (appConfig.allDependencies ?? []).filter((dep) => dep !== appConfig && dep.export?.type === 'cargo');
     if (cargoDependencies.length === 0) return;
+    // Bridges read every header for the first wasm target (see prepareConanDependencies), which an app configured for
+    // another wasm runtime does not build: there a dependency built for the app's runtime alone counts as half built.
+    const bridgeTarget = buildTargets.some(isWasm) ? state.targets.find(isWasm) : undefined;
+    const extraTarget = bridgeTarget && !buildTargets.some((target) => target.path === bridgeTarget.path) ? bridgeTarget : undefined;
+    const targets = extraTarget ? [...buildTargets, extraTarget] : buildTargets;
     // A prebuilt from another embind-rs counts as missing: linked, it carries stale glue or clashes with the others.
     const fingerprint = getEmbindRsFingerprint();
     const prebuiltOf = (dep, target) => [target.path, target.releasePath]
@@ -91,6 +103,7 @@ async function buildMissingCargoDependencies(targets, targetParams) {
             state.config = scoped;
             try {
                 buildLib(targetParams);
+                if (extraTarget) buildLib(paramsOf(extraTarget));
             } finally {
                 state.config = prev;
             }

package/src/actions/buildExternal.js

@@ -1,10 +1,12 @@
 import fs from 'node:fs';
 import replace from 'replace';
 import downloadAndExtractFile from '../utils/downloadAndExtractFile.js';
+import copyToDistSource from '../utils/copyToDistSource.js';
 import { getBuildTargets } from './target.js';
 import state from '../state/index.js';
 import buildLib from './buildLib.js';
 import buildBinTools from './buildBinTools.js';
+import { copyBundledLicenses } from '../utils/bundledLicenses.js';
 
 export default async function buildExternal(targetParams, options = {}) {
     const version = state.config.package.nativeVersion;
@@ -31,6 +33,12 @@ export default async function buildExternal(targetParams, options = {}) {
 
     buildLib(targetParams, options);
 
+    const { bundled } = state.config.build;
+    if (bundled) {
+        new Set(getBuildTargets(targetParams).map((target) => target.platform))
+            .forEach((platform) => copyBundledLicenses(bundled[platform], sourcePath, state.config.paths.output));
+    }
+
     if (state.config.build.bin) {
         await buildBinTools(targetParams);
     }
@@ -48,7 +56,7 @@ export default async function buildExternal(targetParams, options = {}) {
                 targets.forEach(target => {
                     const assetPath = `${state.config.paths.output}/prebuilt/${target.path}/${v}`;
                     if (!fs.existsSync(assetPath)) {
-                        fs.copyFileSync(`${state.config.paths.project}/${key}`, assetPath);
+                        fs.copyFileSync(copyToDistSource(state.config.paths.project, key), assetPath);
                     }
                 });
             });

package/src/actions/buildLib.js

@@ -8,6 +8,9 @@ import logger from '../utils/logger.js';
 import findFiles from '../utils/findFiles.js';
 import { getSourceFingerprint, isSourceFingerprintStale, staleTargetDirectories, writeSourceFingerprint } from '../utils/sourceFingerprint.js';
 import { getEmbindRsFingerprint, writeEmbindRsFingerprint } from '../utils/embindRsFingerprint.js';
+import relocatePrebuilt from '../utils/relocatePrebuilt.js';
+import replaceBasePathForDocker, { DOCKER_BASE } from '../utils/replaceBasePathForDocker.js';
+import { writeNativeSourceStamp } from '../utils/nativeSourceStamp.js';
 
 export default function buildLib(targetParams, options = {}) {
     let isChanged = false;
@@ -22,9 +25,10 @@ export default function buildLib(targetParams, options = {}) {
         // existence-only skip below would keep serving a stale staged staticlib after source edits.
         const isCargo = state.config.export?.type === 'cargo';
         const libdir = `${state.config.paths.output}/prebuilt/${target.path}`;
-        const sourceFingerprint = getSourceFingerprint(state.config);
+        const sourceFingerprint = getSourceFingerprint(state.config, target);
         const sourceChanged = isSourceFingerprintStale(libdir, sourceFingerprint);
-        if (isCargo || sourceChanged || !fs.existsSync(`${libdir}/lib`)) {
+        const nativeChanged = isNativeSourceNewerThan(`${libdir}/lib`);
+        if (isCargo || sourceChanged || nativeChanged || !fs.existsSync(`${libdir}/lib`)) {
             if (sourceChanged) {
                 for (const stale of staleTargetDirectories({
                     buildPath: state.config.paths.build,
@@ -33,8 +37,9 @@ export default function buildLib(targetParams, options = {}) {
                 })) fs.rmSync(stale, { recursive: true, force: true });
             }
             // createLib caches on existence too, so re-entering is not enough: a stale stamp means
-            // the lib on disk came from a different upstream release and has to be rebuilt.
-            createLib(target, 'Source', { buildSource: true, force: sourceChanged });
+            // the lib on disk came from a different upstream release, and a newer native source means
+            // it predates an edit; either way it has to be rebuilt.
+            createLib(target, 'Source', { buildSource: true, force: sourceChanged || nativeChanged });
 
             const modules = [];
             state.config.paths.module.forEach((modulePath) => {
@@ -52,10 +57,6 @@ export default function buildLib(targetParams, options = {}) {
             if (isCargo) writeEmbindRsFingerprint(libdir, getEmbindRsFingerprint());
             isChanged = true;
         } else {
-            // The skip is existence-only; without this warning a source edit is served stale silently.
-            if (isNativeSourceNewerThan(`${state.config.paths.output}/prebuilt/${target.path}/lib`)) {
-                logger.info(`[${target.path}] lib cached but native sources are newer - delete the prebuilt output (rm -rf dist .crossbind) and rebuild to pick them up`);
-            }
             logger.cachedStep(target, 'lib');
         }
     });
@@ -66,6 +67,11 @@ export default function buildLib(targetParams, options = {}) {
     if (isChanged && fs.existsSync(`${state.config.paths.build}/Source-Debug/prebuilt`)) {
         fs.cpSync(`${state.config.paths.build}/Source-Debug/prebuilt`, `${state.config.paths.output}/prebuilt`, { recursive: true, dereference: true });
     }
+    if (isChanged) targets.forEach((target) => {
+        writeNativeSourceStamp(`${state.config.paths.output}/prebuilt/${target.path}/lib`, state.config.paths.native);
+    });
+    // Cached trees too, so a rebuild fixes a prebuilt made before relocation existed.
+    targets.forEach(relocateTargetPrebuilt);
 
     if (!options.skipXcframework) {
         createXCFramework();
@@ -129,3 +135,14 @@ export default function buildLib(targetParams, options = {}) {
         fs.writeFileSync(`${state.config.paths.output}/prebuilt/CMakeLists.txt`, distCmakeContent);
     }
 }
+
+function relocateTargetPrebuilt(target) {
+    const { base, build, output } = state.config.paths;
+    const prefixDir = `${output}/prebuilt/${target.path}`;
+    if (!fs.existsSync(prefixDir)) return;
+    const installPrefix = `${build}/Source-${target.buildType === 'release' ? 'Release' : 'Debug'}/prebuilt/${target.path}`;
+    relocatePrebuilt(prefixDir, {
+        installPrefixes: [installPrefix, replaceBasePathForDocker(installPrefix, base)],
+        buildBases: [base, DOCKER_BASE],
+    });
+}

package/src/actions/buildNativeCommand.js

@@ -0,0 +1,84 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import run from './run.js';
+import getLinkInputs from './getLinkInputs.js';
+import getData from './getData.js';
+import state from '../state/index.js';
+import logger from '../utils/logger.js';
+import { getContentHash, getFilesFingerprint } from '../utils/hash.js';
+import { buildLinkLibArgs } from '../utils/linkLayout.js';
+
+const cpuCount = Math.max(1, os.cpus().length - 1);
+const PROJECT_SOURCE = fileURLToPath(new URL('../assets/cmake/command', import.meta.url));
+const PROJECT_FILES = ['CMakeLists.txt', 'command.cpp'];
+
+const statOf = (lib) => {
+    const stat = fs.existsSync(lib) ? fs.statSync(lib) : null;
+    return { lib, size: stat ? stat.size : null, mtimeMs: stat ? stat.mtimeMs : null };
+};
+
+// The CLI may sit outside the docker mount, so the project is copied next to the build.
+function stageProject(build) {
+    const projectDir = `${build}/crossbind-command`;
+    fs.mkdirSync(projectDir, { recursive: true });
+    PROJECT_FILES.forEach((file) => fs.copyFileSync(`${PROJECT_SOURCE}/${file}`, `${projectDir}/${file}`));
+    return projectDir;
+}
+
+function linkInputs(target) {
+    const { libs, wholeArchiveAll, wholeArchiveNames } = getLinkInputs(target, { keepFlag: () => '', withBridge: false });
+    const linkArgs = [
+        ...buildLinkLibArgs(libs, { wholeArchiveAll, wholeArchiveNames, forceLoad: target.platform === 'darwin' }),
+        // The system libraries the archives need, declared by the packages that bring them in.
+        ...(getData('binary', target)?.addonFlags ?? []),
+    ];
+    return { libs, linkArgs };
+}
+
+// Links the project's main() and the archives it reaches into one executable.
+export default async function buildNativeCommand(target, options = {}) {
+    if (target.platform === 'darwin' && process.platform !== 'darwin') {
+        logger.info(`[${target.path}] native command skipped (macOS executables link on a macOS host)`);
+        return false;
+    }
+    if (state.config.export.type === 'cargo') {
+        logger.info(`[${target.path}] native command skipped (cargo package - staticlib only)`);
+        return false;
+    }
+
+    const buildType = target.buildType === 'release' ? 'Release' : 'Debug';
+    const { build } = state.config.paths;
+    const { libs, linkArgs } = linkInputs(target);
+    const isStatic = target.platform === 'linuxmusl';
+
+    const fingerprintFile = `${build}/${target.commandName}.fingerprint`;
+    const fingerprint = getContentHash(JSON.stringify({
+        builder: getFilesFingerprint([fileURLToPath(import.meta.url), ...PROJECT_FILES.map((file) => `${PROJECT_SOURCE}/${file}`)]),
+        linkArgs,
+        isStatic,
+        libs: libs.map(statOf),
+    }));
+    const isLinkChanged = !fs.existsSync(fingerprintFile) || fs.readFileSync(fingerprintFile, 'utf8') !== fingerprint;
+    if (!options.force && !isLinkChanged && fs.existsSync(`${build}/${target.commandName}`)) {
+        logger.cachedStep(target, 'native command');
+        return false;
+    }
+
+    const platformPrefix = `Native-${buildType}`;
+    logger.startStep(target, 'native command');
+    run(null, [
+        'cmake', stageProject(build),
+        `-DCMAKE_BUILD_TYPE=${buildType}`,
+        `-DCROSSBIND_COMMAND_FILE=${target.commandName}`,
+        `-DCROSSBIND_LINK_ARGS=${linkArgs.join(';')}`,
+        `-DCROSSBIND_LINK_DEPENDS=${libs.join(';')}`,
+        `-DCROSSBIND_STATIC=${isStatic ? 'ON' : 'OFF'}`,
+    ], platformPrefix, target);
+    run(null, ['cmake', '--build', '.', '-j', String(cpuCount)], platformPrefix, target, { exclusive: true });
+    fs.copyFileSync(`${build}/${platformPrefix}/${target.path}/${target.commandName}`, `${build}/${target.commandName}`);
+    logger.doneStep(target, 'native command');
+
+    fs.writeFileSync(fingerprintFile, fingerprint);
+    return true;
+}

package/src/actions/buildNode.js

@@ -14,9 +14,13 @@ import logger from '../utils/logger.js';
 import { getContentHash, getFilesFingerprint } from '../utils/hash.js';
 import { buildLinkLibArgs } from '../utils/linkLayout.js';
 import resolveEmbindNapiRoot, { resolveEmbindJsiRoot } from '../utils/resolveEmbindNapi.js';
+import scopedEmbind from '../utils/scopedEmbind.js';
 import resolveEmbindRustRoot from '../utils/resolveEmbindRust.js';
+import { rustStdLibsFor } from '../utils/cargoTarget.js';
+import toolchainNoticesDir from '../utils/toolchainNotices.js';
 
 const cpuCount = Math.max(1, os.cpus().length - 1);
+const WINDOWS_IMAGE_NOTICES = '/opt/licenses/llvm-mingw';
 
 function filesUnder(dirs) {
     return dirs.flatMap((dir) => (fs.existsSync(dir)
@@ -28,16 +32,20 @@ function filesUnder(dirs) {
 
 function linkInputs(target) {
     const {
-        libs, wholeArchiveAll, wholeArchiveNames, rustKeepFlags, hasRust,
+        libs, appRustLibs, wholeArchiveAll, wholeArchiveNames, rustKeepFlags, hasRust,
     } = getLinkInputs(target, {
         // The linker loads the archive member that defines a -u symbol; Mach-O prefixes C names with _.
         keepFlag: (name) => `-Wl,-u,${target.platform === 'darwin' ? '_' : ''}crossbind_keep_${name}`,
     });
+    // The app's Rust goes first: what a package's kept member needs from std and rustc's allocator shims is then
+    // already the app's, and the package's own copies stay in its archive instead of defining them twice.
+    const ordered = [...appRustLibs, ...libs.filter((lib) => !appRustLibs.includes(lib))];
     const linkArgs = [
-        ...buildLinkLibArgs(libs, { wholeArchiveAll, wholeArchiveNames, forceLoad: target.platform === 'darwin' }),
+        ...buildLinkLibArgs(ordered, { wholeArchiveAll, wholeArchiveNames, forceLoad: target.platform === 'darwin' }),
         ...rustKeepFlags,
         // The system libraries the archives need, declared by the packages that bring them in.
         ...(getData('binary', target)?.addonFlags ?? []),
+        ...(hasRust ? rustStdLibsFor(target) : []),
     ];
     // The addon runs embind-jsi, so Rust packages bind through the adapter React Native links.
     const extraSources = hasRust ? [`${resolveEmbindRustRoot()}/adapters/jsi.cpp`] : [];
@@ -49,14 +57,34 @@ function envOf(target) {
         .map(([key, value]) => [key, typeof value === 'function' ? value(state, target) : value]));
 }
 
+// A package publishes its addons in <package>-<platform>-<arch> by listing them as optional
+// dependencies, which is also how npm learns to install only the one for its machine.
+function listsAddonPackage(target) {
+    const { name, optionalDependencies = {} } = state.config.package ?? {};
+    return Boolean(name) && Object.hasOwn(optionalDependencies, `${name}-${target.platform}-${target.arch}`);
+}
+
+function addonPackagePattern(served) {
+    return served.some(listsAddonPackage) ? `${state.config.package.name}-{platform}-{arch}` : null;
+}
+
+// Each of those packages links its own addon, so a package that lists any links none. The ones it lists are
+// the platforms it publishes for.
+export function addonsInPackages() {
+    return state.targets.some(listsAddonPackage);
+}
+
 // One loader serves every addon of a build type, so each addon's env is keyed the way the loader
-// looks it up at runtime rather than taken from whichever arch happened to build last.
+// looks it up at runtime rather than taken from whichever arch happened to build last. With its addons in
+// packages, it knows the addons the package publishes.
 export function nodeLoaderConfig(target) {
     const served = state.targets.filter((t) => t.addonPattern && t.jsName === target.jsName);
+    const addonPackage = addonPackagePattern(served);
+    const loaded = addonPackage ? served.filter(listsAddonPackage) : served;
     return {
-        env: Object.fromEntries(served.map((t) => [`${t.platform}-${t.arch}`, envOf(t)])),
+        env: Object.fromEntries(loaded.map((t) => [`${t.platform}-${t.arch}`, envOf(t)])),
         general: { name: state.config.general.name },
-        paths: { addon: target.addonPattern },
+        paths: { addon: target.addonPattern, ...(addonPackage ? { addonPackage } : {}) },
     };
 }
 
@@ -77,13 +105,20 @@ async function bundleLoader(target, napiRoot, loaderConfig) {
     const systemConfig = `export default ${JSON.stringify(loaderConfig)};`;
     const bundle = await rollup({
         input: `${napiRoot}/js/loader.js`,
-        plugins: [virtual({ 'crossbind/systemConfig': systemConfig }), nodeResolve(), commonjs()],
+        plugins: [
+            virtual({ 'crossbind/systemConfig': systemConfig }), scopedEmbind(`${resolveEmbindJsiRoot()}/js/embind.js`), nodeResolve(), commonjs(),
+        ],
         onwarn: suppressNodeBuiltinWarnings,
     });
     await bundle.write({ file: `${state.config.paths.build}/${target.jsName}`, format: 'cjs', exports: 'default' });
     await bundle.close();
 }
 
+// The loader alone, for a package whose platform packages link its addons.
+export function bundleNodeLoader(target) {
+    return bundleLoader(target, resolveEmbindNapiRoot(), nodeLoaderConfig(target));
+}
+
 // Links one Node-API addon from the project's archives and bundles the loader that picks the
 // addon matching the running process.
 export default async function buildNode(target, options = {}) {
@@ -136,7 +171,13 @@ export default async function buildNode(target, options = {}) {
         `-DCROSSBIND_LINK_ARGS=${linkArgs.join(';')}`,
         `-DCROSSBIND_LINK_DEPENDS=${libs.join(';')}`,
     ], platformPrefix, target);
-    run(null, ['cmake', '--build', '.', '-j', String(cpuCount)], platformPrefix, target);
+    run(null, ['cmake', '--build', '.', '-j', String(cpuCount)], platformPrefix, target, { exclusive: true });
+    if (target.platform === 'win32') {
+        // The mingw-w64 runtime and winpthreads in the addon ask for their notices in binary
+        // distributions. The windows image carries them; a host toolchain may not.
+        const notices = toolchainNoticesDir('win32');
+        run(null, ['sh', '-c', `if [ -d ${WINDOWS_IMAGE_NOTICES} ]; then mkdir -p ${notices} && cp ${WINDOWS_IMAGE_NOTICES}/* ${notices}/; fi`], null, target);
+    }
     fs.copyFileSync(`${build}/${platformPrefix}/${target.path}/${target.addonName}`, `${build}/${target.addonName}`);
     logger.doneStep(target, 'addon');
 

package/src/actions/buildTypes.js

@@ -9,7 +9,13 @@ import logger from '../utils/logger.js';
 // Package type publishing (opt-in: config `types: true`): one combined .d.ts over every
 // public header, written to <output>/types/index.d.ts, and package.json wired the way
 // hand-maintained typings already are - `types` plus a greedy `typesVersions` "*.h" map -
-// so a consumer's `import ... from '<pkg>/<any>.h'` resolves to the generated file.
+// so a consumer's `import ... from '<pkg>/<any>.h'` resolves to the generated file. The other
+// paths a package maps, such as its node/napi entry, stay.
+export function withPackageTypes(manifest, relative) {
+    const versions = manifest.typesVersions ?? {};
+    return { ...manifest, types: relative, typesVersions: { ...versions, '*': { ...versions['*'], '*.h': [relative] } } };
+}
+
 export default function buildTypes() {
     if (state.config.types !== true) return;
     const exts = state.config.ext.header.join(',');
@@ -25,7 +31,7 @@ export default function buildTypes() {
     const manifestFile = `${state.config.paths.project}/package.json`;
     const manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
     const relative = `./${path.relative(state.config.paths.project, dtsFile)}`;
-    const next = { ...manifest, types: relative, typesVersions: { '*': { '*.h': [relative] } } };
+    const next = withPackageTypes(manifest, relative);
     if (JSON.stringify({ t: next.types, v: next.typesVersions }) !== JSON.stringify({ t: manifest.types, v: manifest.typesVersions })) {
         fs.writeFileSync(manifestFile, `${JSON.stringify(next, null, 4)}\n`);
     }

package/src/actions/buildWasiCommand.js

@@ -13,10 +13,6 @@ export default async function buildWasiCommand(target, options = {}) {
     const isProd = target.buildType === 'release';
     const buildType = isProd ? 'Release' : 'Debug';
 
-    if (state.config.export.bundle === false) {
-        logger.info(`[${target.path}] wasi command skipped (export.bundle = false)`);
-        return false;
-    }
     if (state.config.export?.type === 'cargo') {
         logger.info(`[${target.path}] wasi command skipped (cargo packages have no cargo wasi triple)`);
         return false;

package/src/actions/buildWasm.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
+import { writeNativeSourceStamp } from '../utils/nativeSourceStamp.js';
 import { fileURLToPath } from 'node:url';
-import replace from 'replace';
 import run from './run.js';
 import getLinkInputs from './getLinkInputs.js';
 import getData from './getData.js';
@@ -12,6 +12,12 @@ import logger from '../utils/logger.js';
 import { getContentHash, getFilesFingerprint } from '../utils/hash.js';
 import { buildLinkLibArgs } from '../utils/linkLayout.js';
 import { guardBigIntArguments, guardEmbindArguments } from '../utils/embindArgumentGuards.js';
+import { separateCallArguments } from '../utils/embindCallArguments.js';
+import { queueJspiCalls } from '../utils/embindJspiQueue.js';
+import { spawnPthreadsFromMainScript } from '../utils/pthreadMainScript.js';
+
+const GLUE_REWRITES = ['../utils/embindArgumentGuards.js', '../utils/embindCallArguments.js', '../utils/embindJspiQueue.js', '../utils/pthreadMainScript.js']
+    .map((file) => fileURLToPath(new URL(file, import.meta.url)));
 
 // 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
@@ -36,15 +42,41 @@ function guardArgumentConversions(target) {
     }
 }
 
+// Overlapping calls of one embind function free each other's arguments (utils/embindCallArguments.js);
+// each runtimeEnv links its own glue, so each one calls this after its link.
+function separateEmbindCalls(target) {
+    const gluePath = `${state.config.paths.build}/${target.rawJsName}`;
+    const { text, missed } = separateCallArguments(fs.readFileSync(gluePath, 'utf8'));
+    fs.writeFileSync(gluePath, text);
+    if (missed) {
+        logger.error('embind per-call argument rewrite missed (emscripten glue format changed?): overlapping calls of one function free each other\'s arguments');
+    }
+}
+
+// Suspended _JSPI calls that resume out of order overwrite each other's C stack (utils/embindJspiQueue.js);
+// each runtimeEnv links its own glue, so each one calls this after its link.
+function queueJspiEmbindCalls(target) {
+    const gluePath = `${state.config.paths.build}/${target.rawJsName}`;
+    const { text, missed } = queueJspiCalls(fs.readFileSync(gluePath, 'utf8'));
+    fs.writeFileSync(gluePath, text);
+    if (missed) {
+        logger.error('embind _JSPI queue rewrite missed (emscripten glue format changed?): suspended _JSPI calls can overwrite each other\'s C stack');
+    }
+}
+
+// A direct-mode mt init in a browser spawns its pthreads from "/undefined" (utils/pthreadMainScript.js).
+function pointPthreadSpawn(target) {
+    const gluePath = `${state.config.paths.build}/${target.rawJsName}`;
+    const { text, missed } = spawnPthreadsFromMainScript(fs.readFileSync(gluePath, 'utf8'));
+    fs.writeFileSync(gluePath, text);
+    if (missed) {
+        logger.error('pthread spawn rewrite missed (emscripten glue format changed?): mt builds may fetch /undefined workers');
+    }
+}
+
 export default async function buildWasm(target, options = {}) {
     const isProd = target.buildType === 'release';
 
-    // Caller can opt out of the final emcc link entirely (e.g. when the
-    // package is consumed only as a static library by downstream builds).
-    if (state.config.export.bundle === false) {
-        logger.info(`[${target.path}] wasm+js skipped (export.bundle = false)`);
-        return false;
-    }
     // Cargo packages only stage their staticlib; the consuming app links and bundles it.
     if (state.config.export.type === 'cargo') {
         logger.info(`[${target.path}] wasm+js skipped (cargo package - staticlib only)`);
@@ -131,7 +163,8 @@ export default async function buildWasm(target, options = {}) {
         // The emcc arg tail is hardcoded per environment in this file, invisible to the
         // emccFlags entry below - hashing the builder itself makes any inline-arg edit
         // (a new -s flag, an EXPORTED_RUNTIME_METHODS change) a guaranteed cache miss.
-        builder: getFilesFingerprint([fileURLToPath(import.meta.url)]),
+        // The glue rewrites applied after the link count as the builder too.
+        builder: getFilesFingerprint([fileURLToPath(import.meta.url), ...GLUE_REWRITES]),
         wholeArchiveAll,
         wholeArchiveNames: [...wholeArchiveNames].sort(),
         emccFlags,
@@ -188,27 +221,7 @@ export default async function buildWasm(target, options = {}) {
         const t1 = performance.now();
         logger.doneStep(target, 'wasm');
         logger.startStep(target, 'js');
-        // The pthread bootstrap spawns workers from _scriptName, captured from
-        // document.currentScript at LOAD time - undefined when the bridge is
-        // loaded as a module script, so workers would fetch "/undefined" and
-        // direct-mode mt init hangs. Inject Module.crossbindMainScript (set by the
-        // browser adapter from paths.worker/paths.js; a crossbind-specific key, as
-        // emscripten's own mainScriptUrlOrBlob trips emsdk 6 debug assertions
-        // on st targets) at SPAWN time instead. The previous spaced
-        // 'var _scriptName = ' rewrite no longer matched the minified glue and
-        // silently no-opped; the guard below turns any future format drift
-        // into a visible error instead.
-        replace({
-            regex: 'pthreadMainJs=_scriptName',
-            replacement: 'pthreadMainJs=Module["crossbindMainScript"]||_scriptName',
-            paths: [`${state.config.paths.build}/${target.rawJsName}`],
-            recursive: false,
-            silent: true,
-        });
-        const glue = fs.readFileSync(`${state.config.paths.build}/${target.rawJsName}`, 'utf8');
-        if (glue.includes('pthreadMainJs') && !glue.includes('Module["crossbindMainScript"]||_scriptName')) {
-            logger.error('pthread spawn rewrite missed (emscripten glue format changed?): mt builds may fetch /undefined workers');
-        }
+        pointPthreadSpawn(target);
         /* replace({
             regex: 'val === 10',
             replacement: 'false',
@@ -218,6 +231,8 @@ export default async function buildWasm(target, options = {}) {
         }); */
         guardBigIntConversions(target);
         guardArgumentConversions(target);
+        separateEmbindCalls(target);
+        queueJspiEmbindCalls(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`);
@@ -258,6 +273,8 @@ export default async function buildWasm(target, options = {}) {
         logger.startStep(target, 'js');
         guardBigIntConversions(target);
         guardArgumentConversions(target);
+        separateEmbindCalls(target);
+        queueJspiEmbindCalls(target);
         await buildJs(target);
         logger.doneStep(target, 'js');
     }
@@ -292,6 +309,8 @@ export default async function buildWasm(target, options = {}) {
         logger.startStep(target, 'js');
         guardBigIntConversions(target);
         guardArgumentConversions(target);
+        separateEmbindCalls(target);
+        queueJspiEmbindCalls(target);
         await buildJs(target);
         if (emccFlags.includes('FETCH')) {
             fs.appendFileSync(`${state.config.paths.build}/${target.jsName}`, 'var XMLHttpRequest = require(\'xhr2\');\n');
@@ -315,5 +334,6 @@ export default async function buildWasm(target, options = {}) {
     }
 
     fs.writeFileSync(linkFingerprintFile, linkFingerprint);
+    writeNativeSourceStamp(`${state.config.paths.build}/${target.jsName}`, state.config.paths.native);
     return true;
 }