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

package/src/bin.js

@@ -9,14 +9,23 @@ 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 } from './actions/writeRuntimeEntry.js';
+import { 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';
@@ -24,10 +33,19 @@ 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, deploySteps, initRunner, newRunnerToken, runnerHostPort, startRunner, stopRunner,
+} from './actions/runnerCommands.js';
+import {
+    deleteAccount as deleteCloudAccount, fetchUsage, login as loginToCloud, logout as logoutOfCloud, usageLines,
+} from './actions/cloudCommands.js';
+import { cloudUrl } from './utils/cloudAccount.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)));
@@ -63,11 +81,11 @@ program
 
 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)')
     .action((options) => {
         const { rebuildDeps, ...rest } = options;
@@ -84,12 +102,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);
         }
     });
 
@@ -110,8 +130,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 +162,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 +232,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,6 +257,98 @@ imageArgument(commandDocker.command('stop').description('stop docker container')
 imageArgument(commandDocker.command('delete').description('delete docker container'))
     .action((image) => dockerExec(['rm', dockerContainerName(image)]));
 
+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('stop')
+    .description('stop and remove the local runner')
+    .addOption(roleOption())
+    .action(runnerAction((options) => stopRunner({ 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}`));
+    }));
+
+program.command('login')
+    .description('sign in to crossbind cloud with your GitHub account')
+    .action(async () => {
+        const url = cloudUrl(state.config.system);
+        const { login } = await loginToCloud({ url });
+        console.log(`crossbind: signed in to ${url} as ${login}.`);
+    });
+
+program.command('logout')
+    .description('sign out of crossbind cloud on this machine')
+    .option('--all', 'sign out every machine signed in to this account')
+    .action(async (options) => {
+        const url = cloudUrl(state.config.system);
+        const result = await logoutOfCloud({ url, all: Boolean(options.all) });
+        if (!result) {
+            console.log(`crossbind: not signed in to ${url}.`);
+        } else if (result.revoked) {
+            console.log(`crossbind: signed ${result.login} out${options.all ? ' on every machine' : ''}.`);
+        } else {
+            console.warn(`crossbind: signed out here, but crossbind cloud did not revoke the token (${result.reason.replace(/^crossbind: /, '')}). Sign in again and run crossbind logout --all to revoke it.`);
+        }
+    });
+
+program.command('usage')
+    .description('show what you used of crossbind cloud this month and what is left')
+    .action(async () => {
+        usageLines(await fetchUsage({ url: cloudUrl(state.config.system) })).forEach((line) => console.log(line));
+    });
+
+program.command('account')
+    .description('manage your crossbind cloud account')
+    .command('delete')
+    .description('delete your crossbind cloud account, with the sign-in of every machine (https://crossbind.dev/privacy/)')
+    .option('--yes', 'delete it; without this, nothing is deleted')
+    .action(async (options) => {
+        const url = cloudUrl(state.config.system);
+        if (!options.yes) {
+            throw new Error(`crossbind: this deletes your crossbind cloud account at ${url}, with the sign-in of every machine. Run crossbind account delete --yes to go ahead.`);
+        }
+        const { login } = await deleteCloudAccount({ url });
+        console.log(`crossbind: deleted the crossbind cloud account of ${login}.`);
+    });
+
 const commandConfig = program.command('config')
     .description('manage the crossbind configuration files');
 
@@ -322,15 +453,44 @@ function run(programName, params) {
     runCrossbindApp(programName, params, null, null, { console: true });
 }
 
-async function build(targetParams, rebuildOption) {
+// 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();
+}
+
+async function build(targetParams, rebuildOption, binaryRuntimeEnvs) {
     await buildDependencies({ targetParams, rebuildOption });
-    buildLib(targetParams);
-    await createWasmJs(targetParams);
-    await createNodeAddons(targetParams);
-    await createWasiCommands(targetParams);
+    const binaryParams = { ...targetParams, runtimeEnv: binaryRuntimeEnvs };
+    if (!onlyLoadsPackagedAddons(binaryParams)) {
+        buildLib(targetParams);
+    }
+    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);
+        await createNodeAddons(binaryParams);
+        await createNativeCommands(binaryParams);
+        await createWasiCommands(binaryParams);
+    }
     buildPackageTypes();
 }
 
+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);
+    }
+}
+
 async function createWasiCommands(targetParams) {
     const targets = getFilteredBuildTargets(targetParams, { platform: 'wasi' });
     if (targets.length === 0) {
@@ -342,35 +502,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 +544,72 @@ 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);
         }
+    }
+    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);
+    }
+}
+
+// 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.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}`);
+        fs.writeFileSync(file, OUTPUT_SCOPE);
     }
 }
 
 async function createWasmJs(targetParams) {
-    if (state.config.export.bundle === false) {
-        return;
-    }
     const targets = getFilteredBuildTargets(targetParams, { platform: 'wasm' });
     if (targets.length === 0) {
         return;
     }
-    const opt = {
+    const headers = createBridges();
+    // A Node app imports what it uses through the module hooks, so a Node binary binds those imports too.
+    const isNode = (target) => target.runtimeEnv === 'node';
+    const imports = targets.some(isNode) ? findAppNativeImports([state.targets.find((t) => t.platform === 'wasm')]) : new Map();
+    const nodeHeaders = [...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 +619,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(isNode(target) ? nodeHeaders : headers));
         const built = await buildWasm(target, { force: !distComplete });
         if (!built) {
             continue;
@@ -447,11 +636,29 @@ 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();
+    }
+    // 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 (nodeHeaders.length && nodeTarget) {
+        const entry = `${state.config.paths.output}/node/wasm.mjs`;
+        writeRuntimeEntry(entry, nodeHeaders, ENTRY_RUNTIMES.node(nodeTarget.jsName));
+        if (imports.size) writeImportHooks(entry, nodeHeaders, 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/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));
+}

package/src/integration/getCrossbindScript.js

@@ -5,18 +5,53 @@ import loadJson from '../utils/loadJson.js';
 import state from '../state/index.js';
 import { parseSurface, createRustBridgeCrate, createCrateImportBridge } from '../utils/rustBridgeGen.js';
 import { parseCargoMarkerName } from '../utils/cargoImport.js';
+import { UNBOUND_MESSAGE } from '../assets/js-runtime/adapters/unboundMessage.js';
 
-export default function getCrossbindScript(target, bridgePath) {
+// `base` is where the bundler serves the app from, as Vite's `base` names it; webpack's public path wins at run time.
+// Metro asks for `liveExports`: it keeps a header's module as it first transformed it while the app's imports change.
+export default function getCrossbindScript(target, bridgePath, { base = '/', liveExports: isLive = false } = {}) {
     if (!bridgePath) {
         throw new Error('getCrossbindScript needs the bridge file of the imported header');
     }
-    return buildScript(target, loadJson(`${bridgePath}.exports.json`));
+    const script = buildScript(target, loadJson(`${bridgePath}.exports.json`), base);
+    return isLive ? `${script}${liveExportsScript()}` : script;
+}
+
+// A name the module does not export comes off the booted module: undefined before initNative. A name the module the page
+// or app loaded lacks, exported or not, is a function that says why. Serialized into the generated module, so it
+// references nothing outside itself.
+export function liveExports(exportsObject, unbound) {
+    return new Proxy(exportsObject, {
+        get(target, name, receiver) {
+            const value = Reflect.get(target, name, receiver);
+            const bound = globalThis.__crossbindModule;
+            if (value != null || !bound || typeof name !== 'string' || ['then', 'default', 'toJSON'].includes(name)) return value;
+            if (bound[name] !== undefined) return bound[name];
+            if (!/^[A-Za-z_]\w*$/.test(name)) return value;
+            return function notBound() {
+                throw new Error(`crossbind: ${name} ${unbound}`);
+            };
+        },
+    });
+}
+
+function liveExportsScript() {
+    return `
+        const __crossbindLiveExports = ${liveExports.toString()};
+        if (typeof module === 'object' && module) module.exports = __crossbindLiveExports(module.exports, ${JSON.stringify(UNBOUND_MESSAGE)});
+    `;
 }
 
 // The Rust analog of a .h import: parse the crate surface and emit the same proxy module
 // (per-symbol lets assigned inside this module's initNative). Vectors come from the owning
 // cargo package's config; classes/enums come from the parsed source.
-export function getRustJsScript(target, rsFile) {
+export function getRustJsScript(target, rsFile, { base = '/' } = {}) {
+    return buildScript(target, getRustSymbols(rsFile), base);
+}
+
+// The names a Rust import exports. An app-local file or a cargo: crate gets its bridge crate here, the way a header
+// gets its bridge from createBridgeFile.
+export function getRustSymbols(rsFile) {
     // Compare real paths: dependency paths go through node_modules symlinks (pnpm workspaces)
     // while bundlers hand the transformer the resolved real file.
     const realCrateDir = (d) => {
@@ -40,7 +75,7 @@ export function getRustJsScript(target, rsFile) {
         });
         // A crate registers its public names under per-crate names (two crates may export the
         // same name), so the proxy exports the clean name and reads the registered one off the module.
-        return buildScript(target, exports);
+        return exports;
     }
 
     const pkg = state.config.allDependencies.find((d) => d.export?.type === 'cargo'
@@ -60,7 +95,7 @@ export function getRustJsScript(target, rsFile) {
             log: () => {},
         });
     }
-    const symbols = [
+    return [
         ...model.classes.map((c) => c.name),
         ...(model.streams ?? []).map((s) => s.name),
         ...model.enums.map((e) => e.name),
@@ -69,10 +104,9 @@ export function getRustJsScript(target, rsFile) {
         ...(model.consts ?? []).map((c) => c.name),
         ...vectors.map((v) => v.name),
     ];
-    return buildScript(target, symbols);
 }
 
-function buildScript(target, symbols) {
+function buildScript(target, symbols, base) {
     if (!target) {
         throw new Error('The target is not available!');
     }
@@ -90,7 +124,7 @@ function buildScript(target, symbols) {
     }
 
     return `
-        ${getPlatformScript(env)}
+        ${getPlatformScript(env, base)}
 
         export let AllSymbols = {};
         ${symbolExportDefineString}
@@ -165,8 +199,9 @@ function getReactNativeScript(env) {
     `;
 }
 
-function getWebScript(env) {
+function getWebScript(env, base) {
     const params = `{
+        path: base,
         ...config,
         env: {...${env}, ...config.env},
         paths: {
@@ -179,7 +214,8 @@ function getWebScript(env) {
 
     return `
         function __crossbindBoot(config) {
-            return import(/* webpackIgnore: true */ '/crossbind.js')
+            const base = new URL((typeof __webpack_public_path__ === 'string' ? __webpack_public_path__ : ${JSON.stringify(base)}) || './', document.baseURI).href;
+            return import(/* webpackIgnore: true */ /* @vite-ignore */ base + 'crossbind.js')
                 .then(n => window.Crossbind.initNative(${params}));
         }
     `;

package/src/integration/getDependFilePath.js

@@ -2,6 +2,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import state from '../state/index.js';
 import { parseCargoImport, writeCargoMarker } from '../utils/cargoImport.js';
+import { CONAN_PREFIX, resolveConanHeader } from '../utils/conanImport.js';
+import refreshConanDependencies from '../state/refreshConanDependencies.js';
 
 const LAYOUT = { header: 'include', module: 'swig', source: '' };
 
@@ -92,6 +94,13 @@ export default function getDependFilePath(source, target) {
         return marker;
     }
 
+    // `conan:<package>/<header>` names a header of a declared Conan package, staged per target like a
+    // port's prebuilt; from there the header takes the same path as any other.
+    if (source.startsWith(CONAN_PREFIX)) {
+        refreshConanDependencies(state.config);
+        return resolveConanHeader(state.config, source, target ?? state.targets.find((t) => t.platform === 'wasm'));
+    }
+
     const matches = getMatchingPackages(source);
     if (matches.length === 0) return null;
 

package/src/integration/resolveNativeImport.js

@@ -0,0 +1,14 @@
+import { createRequire } from 'node:module';
+import upath from 'upath';
+import getDependFilePath from './getDependFilePath.js';
+
+// A package that is not a crossbind dependency (the conformance kit) resolves the way the bundler finds it.
+export default function resolveNativeImport(specifier, importer, target) {
+    if (specifier.startsWith('.')) return upath.resolve(upath.dirname(importer), specifier);
+    if (upath.isAbsolute(specifier)) return specifier;
+    try {
+        return getDependFilePath(specifier, target) ?? createRequire(importer).resolve(specifier);
+    } catch (e) {
+        return null;
+    }
+}