crossbind 2.0.0-beta.62 → 2.0.0-beta.64

package/src/bin.js

@@ -2,75 +2,68 @@
 
 import fs from 'node:fs';
 import { execFileSync } from 'node:child_process';
-import { Command, Option } from 'commander';
+import { Option } from 'commander';
 
 import { state } from './index.js';
+import { addSystemCommands, createProgram, handleFatal } from './program.js';
 import createBridgeFile from './actions/createInterface.js';
 import createLib from './actions/createLib.js';
 import buildWasm from './actions/buildWasm.js';
 import buildWasiCommand from './actions/buildWasiCommand.js';
-import buildNode, { publishNodeData } from './actions/buildNode.js';
+import buildNode, { addonsInPackages, bundleNodeLoader, publishNodeData } from './actions/buildNode.js';
+import buildNativeCommand from './actions/buildNativeCommand.js';
 import buildExternal from './actions/buildExternal.js';
 import buildPackageTypes from './actions/buildTypes.js';
 import buildLib from './actions/buildLib.js';
 import buildDependencies from './actions/buildDependencies.js';
+import writeRuntimeEntry, { removeImportHooks, writeImportHooks, writeImportManifest } from './actions/writeRuntimeEntry.js';
+import { bindsAppImports, createImportedBridges, findAppNativeImports } from './actions/createImportedBridges.js';
+import { nativeExtensions } from './utils/nativeImports.js';
+import getDependFilePath from './integration/getDependFilePath.js';
+import { boundHeaderSpecifiers, bridgeTargets, nodeBridgeTarget, resolveBoundHeaders } from './utils/boundHeaders.js';
+import { ENTRY_RUNTIMES } from './utils/runtimeEntries.js';
+import { publishNativeCommand, publishNodeAddon, publishWasiCommand } from './actions/publishBinary.js';
 import runCrossbindApp from './actions/run.js';
 import { getBuildTargets, getFilteredBuildTargets } from './actions/target.js';
-import { OPT_IN_PLATFORMS } from './utils/targets.js';
+import { OPT_IN_PLATFORMS, selectRuntimeEnvs } from './utils/targets.js';
+import { resolveHostPlatform } from './utils/hostPlatform.js';
 import resolveEmbindNapiRoot, { resolveEmbindJsiRoot } from './utils/resolveEmbindNapi.js';
 
-import writeJson from './utils/writeJson.js';
-import flattenConfigForTable from './utils/flattenConfigForTable.js';
-import systemKeys from './utils/systemKeys.js';
 import logger from './utils/logger.js';
 import { getDockerImage, getDockerContainerName } from './utils/pullDockerImage.js';
+import {
+    RUNNER_PLATFORMS, RUNNER_ROLES, connectCommands, deleteRunner, deploySteps, initRunner, newRunnerToken, runnerHostPort, startRunner,
+} from './actions/runnerCommands.js';
 import { cargoHome } from './utils/runCargo.js';
+import { conanRoot } from './utils/runConan.js';
 import { cleanDepsCache } from './utils/dependencyRebuild.js';
 import collectLicenseRows from './actions/licenses.js';
 import { formatNoticesMarkdown, formatCycloneDxSbom, validateSpdx } from './utils/licenseReport.js';
+import { SBOM_FILE, nodePackageMeta, writeNodePackageLicense } from './utils/packageLicense.js';
 import findFiles from './utils/findFiles.js';
 
-const packageJSON = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url)));
-
 const platforms = [...new Set(state.targets.map(target => target.platform).filter(t => t))];
 const archs = [...new Set(state.targets.map(target => target.arch).filter(t => t))];
 const runtimes = [...new Set(state.targets.map(target => target.runtime).filter(t => t))];
 const buildTypes = [...new Set(state.targets.map(target => target.buildType).filter(t => t))];
 const runtimeEnvs = [...new Set(state.targets.map(target => target.runtimeEnv).filter(t => t))];
 
-// Build failures bubble up as exceptions with a `cause` chain (see actions/run.js);
-// show the operator a single line — DEBUG=1 for the full stack — and exit non-zero.
-const handleFatal = (e) => {
-    if (process.env.DEBUG) {
-        console.error(e);
-    } else {
-        let message = e?.message || String(e);
-        if (e?.cause?.message) message += `\n  caused by: ${e.cause.message.split('\n')[0]}`;
-        console.error(message);
-    }
-    process.exit(1);
-};
 process.on('uncaughtException', handleFatal);
 process.on('unhandledRejection', handleFatal);
 
-const program = new Command();
-
-program
-    .name('crossbind')
-    .description('Compile C++ files to WebAssembly and native platforms.')
-    .version(packageJSON.version)
-    .showHelpAfterError();
+const program = createProgram();
 
 program.command('build')
     .description('compile the project that was set up using crossbind')
-    .addOption(new Option('-p, --platform <platform>', 'target platform').argParser(createListParser(platforms)))
+    .addOption(new Option('-p, --platform <platform>', 'target platform (host: the one of this machine)').argParser(createListParser(platforms, resolveHostPlatform)))
     .addOption(new Option('-a, --arch <arch>', 'target architecture').argParser(createListParser(archs)))
     .addOption(new Option('-r, --runtime <runtime>', 'target runtime').argParser(createListParser(runtimes)))
     .addOption(new Option('-b, --build-type <buildType>', 'target build type').argParser(createListParser(buildTypes)))
-    .addOption(new Option('-e, --runtime-env <runtimeEnv>', 'target runtime environment').argParser(createListParser(runtimeEnvs)))
+    .addOption(new Option('-e, --runtime-env <runtimeEnv>', 'binaries to make, by runtime environment (without it, only the archives are built)').argParser(createListParser(runtimeEnvs)))
     .option('--rebuild-deps [list]', 'rebuild dependencies from source instead of using prebuilt (all, or a comma-separated list of names)')
+    .option('--bind-imports', "also bind what the app's JavaScript imports into browser binaries (node binaries always do), for a page that resolves those imports itself")
     .action((options) => {
-        const { rebuildDeps, ...rest } = options;
+        const { rebuildDeps, bindImports, ...rest } = options;
         const targetParams = { ...rest };
 
         if (!targetParams.arch) {
@@ -84,12 +77,14 @@ program.command('build')
         targetParams.arch = targetParams.arch || archs;
         targetParams.runtime = targetParams.runtime || runtimes;
         targetParams.buildType = targetParams.buildType || buildTypes;
-        targetParams.runtimeEnv = targetParams.runtimeEnv || runtimeEnvs;
+        const binaryRuntimeEnvs = selectRuntimeEnvs(targetParams.runtimeEnv, state.config.target.runtimeEnv);
+        // The archives do not depend on the runtime environment; only the binaries do.
+        targetParams.runtimeEnv = runtimeEnvs;
 
         if (state.config.build.withBuildConfig) {
             buildExternal(targetParams);
         } else {
-            build(targetParams, rebuildDeps);
+            build(targetParams, rebuildDeps, binaryRuntimeEnvs, { bindImports });
         }
     });
 
@@ -110,8 +105,14 @@ program.command('licenses')
     .option('--sbom [file]', 'write a CycloneDX SBOM json file (default: sbom.cdx.json)')
     .option('--check', 'exit non-zero when a license field is missing or not valid SPDX')
     .option('--platform <platform>', "also list what this platform's artifact statically links beyond the package graph (vendored copies, toolchain runtime)")
+    .addOption(new Option('-e, --runtime-env <runtimeEnv>', 'also list the crossbind runtime an addon of --platform compiles in, or without --platform the one its loader bundles').choices(['node']))
+    .option('--json [file]', 'write the rows, license texts included, as JSON (default: licenses.json)')
+    .option('--package', "write this Node-API package's LICENSE, sbom.cdx.json and package.json license field (with -e node)")
     .action(async (options) => {
-        const rows = await collectLicenseRows(options.platform || null);
+        if (options.package && options.runtimeEnv !== 'node') {
+            throw new Error('crossbind licenses --package writes the license files of a Node-API package; pass -e node.');
+        }
+        const rows = await collectLicenseRows(options.platform || null, { runtimeEnv: options.runtimeEnv || null });
         rows.forEach((row) => {
             console.log(`${row.isCopyleft ? '! ' : '  '}${(row.name || '').padEnd(14)} ${String(row.license || '(missing)').padEnd(48)} native ${String(row.nativeVersion || '-').padEnd(10)} ${row.sourceUrl || ''}`);
         });
@@ -136,6 +137,15 @@ program.command('licenses')
             fs.writeFileSync(file, formatCycloneDxSbom(rows, target));
             logger.info(`crossbind: wrote ${file}`);
         }
+        if (options.json) {
+            const file = typeof options.json === 'string' ? options.json : `${state.config.paths.project}/licenses.json`;
+            fs.writeFileSync(file, `${JSON.stringify(rows, null, 2)}\n`);
+            logger.info(`crossbind: wrote ${file}`);
+        }
+        if (options.package) {
+            const expression = writeNodePackageLicense(state.config.paths.project, { ...nodePackageMeta(state.config), rows });
+            logger.info(`crossbind: wrote LICENSE and ${SBOM_FILE} (${expression})`);
+        }
         if (options.check) {
             const invalid = rows
                 .map((row) => ({ row, result: validateSpdx(row.license) }))
@@ -197,13 +207,17 @@ imageArgument(commandDocker.command('create').description('create docker contain
     .action((image) => {
         // Google ships the linux NDK for x86_64 only, so an android container is always amd64.
         const platform = image === 'android' ? 'linux/amd64' : undefined;
+        // Docker on Linux makes a missing mount source owned by root, which the user's builds cannot write.
+        [cargoHome(), conanRoot()].forEach((dir) => fs.mkdirSync(dir, { recursive: true }));
         dockerExec([
             'run', '-dit',
             ...(platform ? ['--platform', platform] : []),
             '--name', dockerContainerName(image),
             '-v', `${state.config.paths.base}:/tmp/crossbind/live`,
-            // Cargo's registry cache, shared with host builds and with every other project.
+            // Cargo's registry cache, shared with host builds and with every other project, and the
+            // Conan store and work directories every other container build uses.
             '-v', `${cargoHome()}:/var/cache/crossbind/cargo`,
+            '-v', `${conanRoot()}:/var/cache/crossbind/conan`,
             getDockerImage(image, platform),
             'bash',
         ]);
@@ -218,33 +232,56 @@ imageArgument(commandDocker.command('stop').description('stop docker container')
 imageArgument(commandDocker.command('delete').description('delete docker container'))
     .action((image) => dockerExec(['rm', dockerContainerName(image)]));
 
-const commandConfig = program.command('config')
-    .description('manage the crossbind configuration files');
-
-commandConfig.command('get')
-    .description('get the crossbind system configuration')
-    .argument('<key>', 'configuration key to read')
-    .action((key) => getSystemConfig(key));
-
-commandConfig.command('set')
-    .description('set the crossbind system configuration')
-    .argument('<key>', 'configuration key to set')
-    .argument('<value>', 'value to assign')
-    .action((key, value) => setSystemConfig(key, value));
-
-commandConfig.command('delete')
-    .description('delete the crossbind system configuration')
-    .argument('<key>', 'configuration key to remove')
-    .action((key) => deleteSystemConfig(key));
-
-commandConfig.command('list')
-    .description('list the crossbind configurations')
-    .addOption(new Option('-t, --type <type>', 'config type').default('system').choices(['all', 'system', 'project']))
-    .action((options) => listSystemConfig(options.type));
+const runnerAction = (fn) => (...args) => {
+    try {
+        fn(...args);
+    } catch (e) {
+        console.error(e.message);
+        process.exit(1);
+    }
+};
+const roleOption = () => new Option('--role <role>', 'toolchain image the runner serves').choices(RUNNER_ROLES).default('web');
+
+const commandRunner = program.command('runner')
+    .description('run the remote build runner that RUNNER=REMOTE sends builds to');
+
+commandRunner.command('start')
+    .description('start a runner in local docker, from the toolchain image this CLI pins')
+    .addOption(roleOption())
+    .option('--port <port>', `host port (default: ${RUNNER_ROLES.map((role) => `${runnerHostPort(role)} for ${role}`).join(', ')})`)
+    .option('--host <address>', 'host address to listen on', '127.0.0.1')
+    .option('--token <token>', 'token builds must send (default: $CROSSBIND_RUNNER_TOKEN, else a new one)')
+    .action(runnerAction((options) => {
+        const runner = startRunner({
+            role: options.role, port: options.port && Number(options.port), host: options.host, token: options.token,
+        });
+        console.log(`crossbind: ${runner.name} is running. Build against it with:`);
+        connectCommands(options.role, runner.url, runner.displayToken).forEach((line) => console.log(`  ${line}`));
+    }));
+
+commandRunner.command('delete')
+    .description('stop and delete the local runner')
+    .addOption(roleOption())
+    .action(runnerAction((options) => deleteRunner({ role: options.role })));
+
+commandRunner.command('init')
+    .description('write a folder that deploys a runner to a hosting platform')
+    .argument('<platform>', `hosting platform (${RUNNER_PLATFORMS.join(', ')})`)
+    .addOption(roleOption())
+    .option('--dir <dir>', 'folder to write (default: crossbind-runner-<platform>-<role>)')
+    .option('--vcpu <count>', 'cloudflare: vCPUs of the container (1-4), with the least memory Cloudflare allows them (default: standard-4)')
+    .action(runnerAction((platform, options) => {
+        const { dir, url } = initRunner({
+            platform,
+            role: options.role,
+            dir: options.dir ?? `crossbind-runner-${platform}-${options.role}`,
+            vcpu: options.vcpu === undefined ? undefined : Number(options.vcpu),
+        });
+        console.log(`crossbind: wrote ${dir}. Deploy it:`);
+        deploySteps(platform, dir, newRunnerToken(), options.role, url).forEach((step) => console.log(`  ${step}`));
+    }));
 
-commandConfig.command('keys')
-    .description('list all available system configuration keys for crossbind')
-    .action(() => listSystemKeys());
+addSystemCommands(program);
 
 // `pnpm run <script> -- --flag` forwards the `--` literally and commander would then
 // treat the flags as positionals. Strip the first separator for commands where every
@@ -257,80 +294,48 @@ if (['build', 'clean-deps', 'licenses'].includes(argv[2])) {
 
 program.parse(argv);
 
-function listSystemKeys() {
-    console.info('Available configurations:');
-    console.table(systemKeys);
+function run(programName, params) {
+    runCrossbindApp(programName, params, null, null, { console: true });
 }
 
-function getSystemConfig(systemKey) {
-    if (!systemKey) {
-        listSystemConfig('system');
-        return;
-    }
-    const key = systemKey.toUpperCase();
-    const output = {};
-    if (key in state.config.system) {
-        output[key] = { value: state.config.system[key] || 'undefined', default: systemKeys[key].default };
-    }
-    Object.keys(systemKeys).filter((k) => k.includes(key)).forEach((k) => {
-        if (k in state.config.system) {
-            output[k] = { value: state.config.system[k] || 'undefined', default: systemKeys[k].default };
-        }
-    });
-
-    console.table(output);
+// A package whose platform packages link its addons, building nothing else, has no archive of its own that
+// anything links.
+function onlyLoadsPackagedAddons(binaryParams) {
+    if (binaryParams.runtimeEnv.length === 0) return false;
+    const targets = getBuildTargets(binaryParams);
+    return targets.every((target) => target.runtimeEnv === 'node' && target.platform !== 'wasm') && addonsInPackages();
 }
 
-function setSystemConfig(key, value) {
-    if (!systemKeys[key]) {
-        throw new Error(`Configuration ${key} is not available. Please choose from the following available configurations: ${Object.keys(systemKeys).join(', ')}`);
-    }
-    if (systemKeys[key].options && !systemKeys[key].options.includes(value)) {
-        throw new Error(`Value ${value} is not available. Please choose from the following available values: ${systemKeys[key].options.join(', ')}`);
+async function build(targetParams, rebuildOption, binaryRuntimeEnvs, wasmOptions = {}) {
+    await buildDependencies({ targetParams, rebuildOption });
+    const binaryParams = { ...targetParams, runtimeEnv: binaryRuntimeEnvs };
+    if (!onlyLoadsPackagedAddons(binaryParams)) {
+        buildLib(targetParams);
     }
-
-    state.config.system[key] = value;
-    writeJson(state.config.paths.systemConfig, state.config.system);
-}
-
-function deleteSystemConfig(key) {
-    if (!systemKeys[key]) {
-        throw new Error(`Configuration ${key} is not available. Please choose from the following available configurations: ${Object.keys(systemKeys).join(', ')}`);
+    if (binaryRuntimeEnvs.length === 0) {
+        logger.info(`crossbind: no runtime environment was selected, so only the archives were built - pass -e (${runtimeEnvs.join(', ')}) for a binary.`);
+    } else {
+        await createWasmJs(binaryParams, wasmOptions);
+        await createNodeAddons(binaryParams);
+        await createNativeCommands(binaryParams);
+        await createWasiCommands(binaryParams);
     }
-    delete state.config.system[key];
-    writeJson(state.config.paths.systemConfig, state.config.system);
+    buildPackageTypes();
 }
 
-function listSystemConfig(type) {
-    const { system: systemConfig, ...projectConfig } = state.config;
-    if (type === 'all' || type === 'system') {
-        console.log('System Configuration');
-        console.table(systemConfig);
-    }
-
-    if (type === 'all') {
-        console.log('');
-    }
-
-    if (type === 'all' || type === 'project') {
-        console.log(`Project Configuration (paths relative to ${projectConfig.paths.base})`);
-        console.table(flattenConfigForTable(projectConfig, { base: projectConfig.paths.base }));
+async function createNativeCommands(targetParams) {
+    const targets = getBuildTargets(targetParams).filter((target) => target.runtimeEnv === 'native');
+    for (const target of targets) {
+        const distCommand = `${state.config.paths.output}/${target.commandName}`;
+        const built = await buildNativeCommand(target, { force: !fs.existsSync(distCommand) });
+        publishNodeData(target, { refresh: built });
+        if (!built) {
+            continue;
+        }
+        publishNativeCommand(target);
     }
 }
 
-function run(programName, params) {
-    runCrossbindApp(programName, params, null, null, { console: true });
-}
-
-async function build(targetParams, rebuildOption) {
-    await buildDependencies({ targetParams, rebuildOption });
-    buildLib(targetParams);
-    await createWasmJs(targetParams);
-    await createNodeAddons(targetParams);
-    await createWasiCommands(targetParams);
-    buildPackageTypes();
-}
-
 async function createWasiCommands(targetParams) {
     const targets = getFilteredBuildTargets(targetParams, { platform: 'wasi' });
     if (targets.length === 0) {
@@ -342,35 +347,38 @@ async function createWasiCommands(targetParams) {
         if (!built) {
             continue;
         }
-        fs.copyFileSync(`${state.config.paths.build}/${target.wasmName}`, distWasm);
-        // Copied (not renamed) so a later fingerprint cache-hit still has the
-        // build-dir tree to serve from.
-        if (fs.existsSync(`${state.config.paths.build}/data`)) {
-            fs.rmSync(`${state.config.paths.output}/data`, { recursive: true, force: true });
-            fs.cpSync(`${state.config.paths.build}/data`, `${state.config.paths.output}/data`, { recursive: true });
-        }
+        publishWasiCommand(target);
     }
 }
 
-function createBridges() {
+function createBridges(target) {
     let headers = [];
     state.config.paths.header.forEach((headerPath) => {
         headers.push(findFiles('**/*.h', { cwd: headerPath }));
     });
     headers = headers.filter((path) => !!path.toString()).flat();
 
-    const bridges = [];
-    headers.forEach((header) => {
-        const bridgePath = createBridgeFile(header);
-        bridges.push(bridgePath);
-    });
-    return bridges;
+    return headers.map((header) => ({ file: header, bridge: createBridgeFile(header, target) }));
 }
 
-async function createNodeAddons(targetParams) {
-    if (state.config.export.bundle === false) {
-        return;
+// The dependency headers the config binds whole, each read where one of the targets' packages ships it.
+function createBoundBridges(targets) {
+    const headers = resolveBoundHeaders(boundHeaderSpecifiers(state.config), bridgeTargets(targets, state.targets), getDependFilePath);
+    const wholeHeaders = headers.map((header) => header.file);
+    return headers.map((header) => ({ ...header, bridge: createBridgeFile(header.file, header.target, { wholeHeaders }) }));
+}
+
+// A package whose platform packages link its addons ships what loads them: the loader and the data.
+async function publishLoaders(targets) {
+    fs.mkdirSync(state.config.paths.output, { recursive: true });
+    targets.forEach((target) => publishNodeData(target, { refresh: true }));
+    for (const target of new Map(targets.map((t) => [t.jsName, t])).values()) {
+        await bundleNodeLoader(target);
+        fs.copyFileSync(`${state.config.paths.build}/${target.jsName}`, `${state.config.paths.output}/${target.jsName}`);
     }
+}
+
+async function createNodeAddons(targetParams) {
     const targets = getBuildTargets(targetParams)
         .filter((target) => target.runtimeEnv === 'node' && target.platform !== 'wasm');
     if (targets.length === 0) {
@@ -381,46 +389,71 @@ async function createNodeAddons(targetParams) {
         `${resolveEmbindJsiRoot()}/cpp/src`,
         `${resolveEmbindNapiRoot()}/third_party/node-api-jsi/jsi`,
     ];
+    const boundHeaders = createBoundBridges(targets);
+    const ownHeaders = [...createBridges(nodeBridgeTarget(targets)), ...boundHeaders];
+    const imports = findAppNativeImports(bridgeTargets(targets, state.targets));
+    const headers = [...ownHeaders, ...createImportedBridges(ownHeaders, imports)];
     const opt = {
         buildSource: false,
         nativeGlob: [
             `${state.config.paths.cli}/assets/cpp-runtime/commonBridges.cpp`,
-            ...createBridges(),
+            ...headers.flatMap((header) => header.bridge ?? []),
         ],
         headerDirs,
         inputs: headerDirs.flatMap((dir) => findFiles('**/*.h', { cwd: dir })),
     };
 
-    for (const target of targets) {
-        const distComplete = fs.existsSync(`${state.config.paths.output}/${target.addonName}`)
-            && fs.existsSync(`${state.config.paths.output}/${target.jsName}`);
-        createLib(target, 'Bridge', opt);
-        const built = await buildNode(target, { force: !distComplete });
-        publishNodeData(target, { refresh: built });
-        if (!built) {
-            continue;
+    if (addonsInPackages()) {
+        await publishLoaders(targets);
+    } else {
+        for (const target of targets) {
+            const distComplete = fs.existsSync(`${state.config.paths.output}/${target.addonName}`)
+                && fs.existsSync(`${state.config.paths.output}/${target.jsName}`);
+            createLib(target, 'Bridge', opt);
+            const built = await buildNode(target, { force: !distComplete });
+            publishNodeData(target, { refresh: built });
+            if (!built) {
+                continue;
+            }
+            publishNodeAddon(target);
         }
-        fs.mkdirSync(state.config.paths.output, { recursive: true });
-        fs.copyFileSync(`${state.config.paths.build}/${target.addonName}`, `${state.config.paths.output}/${target.addonName}`);
-        fs.copyFileSync(`${state.config.paths.build}/${target.jsName}`, `${state.config.paths.output}/${target.jsName}`);
+    }
+    const loaderTarget = targets.find((target) => target.buildType === 'release') ?? targets[0];
+    if (headers.length && fs.existsSync(`${state.config.paths.output}/${loaderTarget.jsName}`)) {
+        const entry = `${state.config.paths.output}/node/napi.mjs`;
+        writeRuntimeEntry(entry, headers, ENTRY_RUNTIMES.node(loaderTarget.jsName));
+        if (imports.size) writeImportHooks(entry, headers, imports, nativeExtensions(state.config.ext));
+        else removeImportHooks(entry);
     }
 }
 
-async function createWasmJs(targetParams) {
-    if (state.config.export.bundle === false) {
-        return;
+// The Node and edge wasm builds are CommonJS with a .js extension, which a "type": "module" package loads as
+// ESM. A package.json of the output's own scopes them back, unless the output is a package root.
+const OUTPUT_SCOPE = '{\n    "type": "commonjs"\n}\n';
+function scopeOutputToCommonJs() {
+    const file = `${state.config.paths.output}/package.json`;
+    if (!fs.existsSync(file)) {
+        fs.mkdirSync(state.config.paths.output, { recursive: true });
+        fs.writeFileSync(file, OUTPUT_SCOPE);
     }
+}
+
+async function createWasmJs(targetParams, wasmOptions = {}) {
     const targets = getFilteredBuildTargets(targetParams, { platform: 'wasm' });
     if (targets.length === 0) {
         return;
     }
-    const opt = {
+    const headers = createBridges();
+    const bindsImports = (target) => bindsAppImports(target, wasmOptions);
+    const imports = targets.some(bindsImports) ? findAppNativeImports([state.targets.find((t) => t.platform === 'wasm')]) : new Map();
+    const appHeaders = [...headers, ...createImportedBridges(headers, imports)];
+    const optOf = (bridged) => ({
         buildSource: false,
         nativeGlob: [
             `${state.config.paths.cli}/assets/cpp-runtime/commonBridges.cpp`,
-            ...createBridges(),
+            ...bridged.flatMap((header) => header.bridge ?? []),
         ],
-    };
+    });
 
     for (const target of targets) {
         // An artifact merely existing in dist used to short-circuit this whole
@@ -430,7 +463,7 @@ async function createWasmJs(targetParams) {
         // link and the copy step below moved build/data away on the last run.
         const distComplete = fs.existsSync(`${state.config.paths.output}/${target.jsName}`)
             && fs.existsSync(`${state.config.paths.output}/${target.wasmName}`);
-        createLib(target, 'Bridge', opt);
+        createLib(target, 'Bridge', optOf(bindsImports(target) ? appHeaders : headers));
         const built = await buildWasm(target, { force: !distComplete });
         if (!built) {
             continue;
@@ -447,11 +480,35 @@ async function createWasmJs(targetParams) {
             fs.copyFileSync(`${state.config.paths.build}/${target.dataTxtName}`, `${state.config.paths.output}/${target.dataTxtName}`);
         }
     }
+
+    if (targets.some((target) => ['node', 'edge'].includes(target.runtimeEnv))) {
+        scopeOutputToCommonJs();
+    }
+    // The list a page that maps the app's imports itself reads; a build without --bind-imports is not for one.
+    if (targets.some((target) => target.runtimeEnv === 'browser')) {
+        const manifest = `${state.config.paths.output}/browser/imports.json`;
+        if (wasmOptions.bindImports) writeImportManifest(manifest, appHeaders, imports, state.config.paths.project);
+        else fs.rmSync(manifest, { force: true });
+    }
+    // A runtime's entry loads its single-thread wasm32 release build.
+    const entryTargetOf = (runtimeEnv) => targets.find((target) => target.runtimeEnv === runtimeEnv && target.arch === 'wasm32'
+        && target.runtime === 'st' && target.buildType === 'release' && fs.existsSync(`${state.config.paths.output}/${target.jsName}`));
+    const nodeTarget = entryTargetOf('node');
+    const edgeTarget = entryTargetOf('edge');
+    if (appHeaders.length && nodeTarget) {
+        const entry = `${state.config.paths.output}/node/wasm.mjs`;
+        writeRuntimeEntry(entry, appHeaders, ENTRY_RUNTIMES.node(nodeTarget.jsName));
+        if (imports.size) writeImportHooks(entry, appHeaders, imports, nativeExtensions(state.config.ext));
+        else removeImportHooks(entry);
+    }
+    if (headers.length && edgeTarget) {
+        writeRuntimeEntry(`${state.config.paths.output}/edge/wasm.mjs`, headers, ENTRY_RUNTIMES.edge(edgeTarget.jsName, edgeTarget.wasmName));
+    }
 }
 
-function createListParser(validList) {
+function createListParser(validList, resolve = (items) => items) {
     return (value, previous) => {
-        const items = value.split(',').map(item => item.trim());
+        const items = resolve(value.split(',').map(item => item.trim()));
         for (const item of items) {
             if (!validList.includes(item)) {
                 throw new Error(`Invalid value: "${item}". Allowed values: ${validList.join(', ')}`);

package/src/cli.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+import { addSystemCommands, createProgram, handleFatal } from './program.js';
+
+// bin.js loads the project before it reads the command line, which fails outside a project; these commands need none.
+const program = createProgram();
+addSystemCommands(program);
+const withoutProject = [...program.commands.map((command) => command.name()), '-V', '--version'];
+
+if (withoutProject.includes(process.argv[2])) {
+    await program.parseAsync().catch(handleFatal);
+} else {
+    await import('./bin.js');
+}

package/src/index.js

@@ -13,9 +13,12 @@ export { getTargetParams, getBuildTargets, getFilteredBuildTargets, getFilteredT
 export { default as getCrossbindScript, getRustJsScript } from './integration/getCrossbindScript.js';
 export { default as getDependFilePath } from './integration/getDependFilePath.js';
 export { default as buildDependencies, getDependenciesStamp } from './actions/buildDependencies.js';
+export { default as prepareConanDependencies } from './actions/prepareConanDependencies.js';
 export { default as findFiles } from './utils/findFiles.js';
 export { getContentHash, getFileHash } from './utils/hash.js';
 export {
     collectInputFiles, collectRustBridgeFiles, collectRustSources, computeInputStamp,
 } from './utils/inputStamp.js';
 export { default as buildAppRustCrates } from './utils/appRustCrates.js';
+export { default as appSourceFiles, isAppSource } from './utils/appSources.js';
+export { default as bindHeaderImports } from './integration/bindHeaderImports.js';

package/src/integration/bindHeaderImports.js

@@ -0,0 +1,18 @@
+import fs from 'node:fs';
+import upath from 'upath';
+import state from '../state/index.js';
+import createBridgeFile from '../actions/createInterface.js';
+import resolveNativeImport from './resolveNativeImport.js';
+import { isAppSource } from '../utils/appSources.js';
+import { findHeaderImports } from '../utils/headerImports.js';
+
+// Metro keeps a header's module as it first transformed it, so a source of the app that imports the header binds it
+// again: the functions it names reach the next native build or page load.
+export default function bindHeaderImports(source, file, target) {
+    if (!isAppSource(state.config.paths.project, file)) return [];
+    const headers = findHeaderImports(source, state.config.ext.header)
+        .map(({ specifier }) => resolveNativeImport(specifier, file, target))
+        .filter((header) => header && fs.existsSync(header))
+        .map((header) => upath.normalize(header));
+    return [...new Set(headers)].map((header) => createBridgeFile(header, target));
+}