crossbind 2.0.0-beta.60 → 2.0.0-beta.63

package/README.md

@@ -68,8 +68,9 @@ target-specific artifacts, transitive dependencies, build recipes, and runtime
 adapters.
 
 - **Target-aware distribution.** A package family can carry WebAssembly, iOS,
-  Android, and WASI variants; each build consumes only the artifact valid for
-  its platform, architecture, runtime, environment, and build type.
+  Android, macOS, Linux, Windows, and WASI variants; each build consumes only the
+  artifact valid for its platform, architecture, runtime, environment, and build
+  type.
 - **Native dependency resolution.** Package manifests and crossbind configs
   carry the transitive native graph, so prerequisites are built and linked in
   the correct order.
@@ -253,9 +254,10 @@ The repository contains 16 port families:
 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 and WASI builds use the
-matching `-android`, `-ios`, or `-wasi` variant. Import the variant's
-`crossbind.config.js` into the application's dependency list:
+project uses `@crossbind/port-gdal-wasm`, while mobile, native Node.js addon and
+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:
 
 ```bash
 npm install @crossbind/port-gdal-wasm@beta
@@ -283,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.60",
+    "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,12 +14,19 @@ 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';
+import calculateDependencyParameters from '../state/calculateDependencyParameters.js';
+import { getEmbindRsFingerprint, isEmbindRsFingerprintStale } from '../utils/embindRsFingerprint.js';
 
 export default async function buildDependencies({ targetParams, rebuildOption }) {
     // Before the early returns below: this is the one async step every build path awaits, and the
     // 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);
@@ -54,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
@@ -61,40 +73,56 @@ 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 missing = (appConfig.allDependencies ?? []).filter((dep) => dep !== appConfig
-        && dep.export?.type === 'cargo'
-        && targets.some((target) => !dep.functions.isEnabled(target)));
+    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]
+        .map((targetPath) => `${dep.paths.output}/prebuilt/${targetPath}`)
+        .find((dir) => fs.existsSync(dir)) ?? `${dep.paths.output}/prebuilt/${target.path}`;
+    const isBuilt = (dep, target) => dep.functions.isEnabled(target) && !isEmbindRsFingerprintStale(prebuiltOf(dep, target), fingerprint);
+    const missing = cargoDependencies.filter((dep) => targets.some((target) => !isBuilt(dep, target)));
 
     for (const dep of missing) {
         const name = dep.general.name;
         // isEnabled reads the filesystem on every call, so a build that lands while this one waits
         // for the lock is picked up without any state to refresh.
         await withDirLock(`${dep.paths.output}.autobuild.lock`, async () => {
-            if (targets.every((target) => dep.functions.isEnabled(target))) return;
-            logger.info(`crossbind: building cargo dependency "${name}" - it has no prebuilt for this target yet…`);
+            if (targets.every((target) => isBuilt(dep, target))) return;
+            logger.info(`crossbind: building cargo dependency "${name}" - it has no prebuilt from this embind-rs for this target yet…`);
             const scoped = await loadConfig(dep.paths.project);
             const prev = state.config;
             state.config = scoped;
             try {
                 buildLib(targetParams);
+                if (extraTarget) buildLib(paramsOf(extraTarget));
             } finally {
                 state.config = prev;
             }
         });
+        // loadConfig resolved a never-built package's CMakeLists to the CLI's own, and isEnabled and the link read it.
+        dep.paths.cmake = getAbsolutePath(dep.paths.project, getCMakeListsFilePath(dep.paths.output));
+        dep.paths.cmakeDir = getParentPath(dep.paths.cmake);
     }
+    if (missing.length > 0) appConfig.dependencyParameters = calculateDependencyParameters(appConfig);
 
     // The build above is the fix; this is the guard behind it. assertDependsBuilt only runs while
     // the cmake link is being configured, so a cached native build skips the check and a missing
     // cargo dependency reaches the app anyway - measured on wasm as a clean BUILD=0 whose module
     // then failed 22 of 43 conformance features at init. Here the answer is known either way.
-    const unresolved = missing.filter((dep) => targets.some((target) => !dep.functions.isEnabled(target)));
+    const unresolved = missing.filter((dep) => targets.some((target) => !isBuilt(dep, target)));
     if (unresolved.length > 0) {
         const names = unresolved.map((dep) => `"${dep.general.name}"`).join(', ');
         throw new Error(`crossbind: cargo ${unresolved.length > 1 ? 'dependencies' : 'dependency'} ${names} still `
-            + `${unresolved.length > 1 ? 'have' : 'has'} no prebuilt for ${targets.map((t) => t.path).join(', ')} `
+            + `${unresolved.length > 1 ? 'have' : 'has'} no prebuilt built from the current embind-rs for ${targets.map((t) => t.path).join(', ')} `
             + 'after building. Linking without it produces a module that builds clean and dies at init.');
     }
 }

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/buildJs.js

@@ -13,7 +13,7 @@ const SUPPRESSED_WARN_CODES = new Set([
     'MIXED_EXPORTS',
 ]);
 
-function suppressNodeBuiltinWarnings(warning, defaultHandler) {
+export function suppressNodeBuiltinWarnings(warning, defaultHandler) {
     if (SUPPRESSED_WARN_CODES.has(warning.code)) return;
     if (warning.code === 'UNRESOLVED_IMPORT' && /^node:/.test(warning.exporter || warning.source || warning.id || '')) return;
     defaultHandler(warning);

package/src/actions/buildLib.js

@@ -7,6 +7,10 @@ import state from '../state/index.js';
 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;
@@ -21,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,
@@ -32,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) => {
@@ -48,12 +54,9 @@ export default function buildLib(targetParams, options = {}) {
                 fs.copyFileSync(modulePath, `${state.config.paths.output}/prebuilt/${target.path}/swig/${fileName}`);
             });
             writeSourceFingerprint(libdir, sourceFingerprint);
+            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');
         }
     });
@@ -64,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();
@@ -127,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

@@ -0,0 +1,190 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { rollup } from 'rollup';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import virtual from '@rollup/plugin-virtual';
+import run from './run.js';
+import getLinkInputs from './getLinkInputs.js';
+import getData from './getData.js';
+import { suppressNodeBuiltinWarnings } from './buildJs.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';
+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)
+        ? fs.readdirSync(dir, { recursive: true })
+            .map((file) => `${dir}/${file}`)
+            .filter((file) => fs.statSync(file).isFile())
+        : []));
+}
+
+function linkInputs(target) {
+    const {
+        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(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`] : [];
+    return { libs, linkArgs, extraSources };
+}
+
+function envOf(target) {
+    return Object.fromEntries(Object.entries(getData('env', 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. 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(loaded.map((t) => [`${t.platform}-${t.arch}`, envOf(t)])),
+        general: { name: state.config.general.name },
+        paths: { addon: target.addonPattern, ...(addonPackage ? { addonPackage } : {}) },
+    };
+}
+
+// The loader hands the addon dist/data by default, as the wasm build does. A relinked addon may come
+// from updated dependencies, so its data is copied again rather than kept.
+export function publishNodeData(target, { refresh }) {
+    Object.entries(getData('data', target)).forEach(([source, name]) => {
+        const published = `${state.config.paths.output}/data/${name}`;
+        if (!fs.existsSync(source) || (!refresh && fs.existsSync(published))) {
+            return;
+        }
+        fs.rmSync(published, { recursive: true, force: true });
+        fs.cpSync(source, published, { recursive: true });
+    });
+}
+
+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 }), 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 = {}) {
+    if (target.platform === 'darwin' && process.platform !== 'darwin') {
+        logger.info(`[${target.path}] addon skipped (macOS addons build on a macOS host)`);
+        return false;
+    }
+    if (state.config.export.type === 'cargo') {
+        logger.info(`[${target.path}] addon skipped (cargo package - staticlib only)`);
+        return false;
+    }
+
+    const buildType = target.buildType === 'release' ? 'Release' : 'Debug';
+    const { build } = state.config.paths;
+    const napiRoot = resolveEmbindNapiRoot();
+    const jsiRoot = resolveEmbindJsiRoot();
+    const { libs, linkArgs, extraSources } = linkInputs(target);
+    const loaderConfig = nodeLoaderConfig(target);
+
+    const fingerprintFile = `${build}/${target.addonName}.fingerprint`;
+    const fingerprint = getContentHash(JSON.stringify({
+        builder: getFilesFingerprint([fileURLToPath(import.meta.url)]),
+        linkArgs,
+        libs: libs.map((lib) => {
+            const stat = fs.existsSync(lib) ? fs.statSync(lib) : null;
+            return { lib, size: stat ? stat.size : null, mtimeMs: stat ? stat.mtimeMs : null };
+        }),
+        loaderConfig,
+        runtime: getFilesFingerprint(filesUnder([
+            `${napiRoot}/cpp`, `${napiRoot}/js`, `${napiRoot}/third_party`, `${jsiRoot}/cpp/src`, `${jsiRoot}/js`,
+        ])),
+        extraSources: getFilesFingerprint(extraSources),
+    }));
+    const isLinkChanged = !fs.existsSync(fingerprintFile)
+        || fs.readFileSync(fingerprintFile, { encoding: 'utf8' }) !== fingerprint;
+    if (!options.force && !isLinkChanged
+        && fs.existsSync(`${build}/${target.addonName}`) && fs.existsSync(`${build}/${target.jsName}`)) {
+        logger.cachedStep(target, 'addon');
+        return false;
+    }
+
+    const platformPrefix = `Node-${buildType}`;
+    logger.startStep(target, 'addon');
+    run(null, [
+        'cmake', `${napiRoot}/cpp`,
+        `-DCMAKE_BUILD_TYPE=${buildType}`,
+        `-DCROSSBIND_ADDON_FILE=${target.addonName}`,
+        `-DCROSSBIND_JSI_ROOT=${jsiRoot}`,
+        `-DCROSSBIND_EXTRA_SOURCES=${extraSources.join(';')}`,
+        `-DCROSSBIND_LINK_ARGS=${linkArgs.join(';')}`,
+        `-DCROSSBIND_LINK_DEPENDS=${libs.join(';')}`,
+    ], 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');
+
+    logger.startStep(target, 'js');
+    await bundleLoader(target, napiRoot, loaderConfig);
+    logger.doneStep(target, 'js');
+
+    fs.writeFileSync(fingerprintFile, fingerprint);
+    return true;
+}

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;