crossbind 2.0.0-beta.63 → 2.0.0-beta.65

package/src/bin.js

@@ -1,25 +1,29 @@
 #!/usr/bin/env node
 
 import fs from 'node:fs';
-import { execFileSync } from 'node:child_process';
-import { Command, Option } from 'commander';
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { execFileSync, spawn } from 'node:child_process';
+import { Option } from 'commander';
 
 import { state } from './index.js';
-import createBridgeFile from './actions/createInterface.js';
+import { addSystemCommands, createProgram, handleFatal } from './program.js';
 import createLib from './actions/createLib.js';
 import buildWasm from './actions/buildWasm.js';
 import buildWasiCommand from './actions/buildWasiCommand.js';
 import buildNode, { addonsInPackages, bundleNodeLoader, publishNodeData } from './actions/buildNode.js';
 import buildNativeCommand from './actions/buildNativeCommand.js';
+import buildApp, { appOutputPath, assertAppRunner, publishApp } from './actions/buildApp.js';
+import { releaseSigning } from './actions/androidGradle.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 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 { createBridges, createNativeBridges } from './actions/nativeBridges.js';
 import { ENTRY_RUNTIMES } from './utils/runtimeEntries.js';
 import { publishNativeCommand, publishNodeAddon, publishWasiCommand } from './actions/publishBinary.js';
 import runCrossbindApp from './actions/run.js';
@@ -28,18 +32,11 @@ 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, deploySteps, initRunner, newRunnerToken, runnerHostPort, startRunner, stopRunner,
+    RUNNER_PLATFORMS, RUNNER_ROLES, connectCommands, deleteRunner, deploySteps, initRunner, newRunnerToken, runnerHostPort, startRunner,
 } 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';
@@ -48,36 +45,16 @@ import { formatNoticesMarkdown, formatCycloneDxSbom, validateSpdx } from './util
 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')
@@ -87,8 +64,9 @@ program.command('build')
     .addOption(new Option('-b, --build-type <buildType>', 'target build type').argParser(createListParser(buildTypes)))
     .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) {
@@ -109,7 +87,8 @@ program.command('build')
         if (state.config.build.withBuildConfig) {
             buildExternal(targetParams);
         } else {
-            build(targetParams, rebuildDeps, binaryRuntimeEnvs);
+            // An app builds only for the platforms -p names, so a plain build keeps making the archives alone.
+            build(targetParams, rebuildDeps, binaryRuntimeEnvs, { bindImports }, rest.platform ?? []);
         }
     });
 
@@ -124,13 +103,50 @@ function declaredSbomPath(projectDir) {
     }
 }
 
+// An app's page is the project's Vite build, which @crossbind/plugin-vite makes into the app of the platform named.
+const APP_PLATFORMS = ['android', 'ios', 'linux', 'macos', 'windows'];
+
+function projectVite() {
+    try {
+        const manifest = createRequire(`${state.config.paths.project}/package.json`).resolve('vite/package.json');
+        return path.join(path.dirname(manifest), JSON.parse(fs.readFileSync(manifest, 'utf8')).bin.vite);
+    } catch {
+        throw new Error("crossbind: crossbind app builds the app's page with the project's Vite, which the project does not have. Add vite and @crossbind/plugin-vite to it, as the desktop-app template has them.");
+    }
+}
+
+const commandApp = program.command('app').description('build the project as an app, or open it on the dev server');
+[
+    ['dev', 'open the app on the dev server, and open it anew as its native code changes'],
+    ['build', 'build the app with its page: for Android also its APK, and with an upload key its bundle'],
+].forEach(([name, description]) => commandApp.command(name).description(description)
+    .addOption(new Option('-p, --platform <platform>', "the app's platform (default: CROSSBIND_APP_PLATFORM, else this machine's)").choices(APP_PLATFORMS))
+    // Vite's own options, as --port or --mode, go on to Vite.
+    .allowUnknownOption()
+    .allowExcessArguments()
+    .action(({ platform }, command) => {
+        if (state.config.target.runtimeEnv !== 'app') {
+            throw new Error("crossbind: crossbind app builds an app, which this project is not: set target: { runtimeEnv: 'app' } in crossbind.config.js, as the desktop-app template does.");
+        }
+        // An Android build checks its upload key before the native build, not after it.
+        if (name === 'build' && (platform ?? process.env.CROSSBIND_APP_PLATFORM) === 'android') releaseSigning();
+        const vite = spawn(process.execPath, [projectVite(), ...(name === 'build' ? ['build'] : []), ...command.args], {
+            stdio: 'inherit',
+            cwd: state.config.paths.project,
+            env: platform ? { ...process.env, CROSSBIND_APP_PLATFORM: platform } : process.env,
+        });
+        // A signal sent to crossbind alone reaches Vite too, which ends through its exit hooks; Ctrl-C reaches both.
+        ['SIGINT', 'SIGTERM', 'SIGHUP'].forEach((signal) => process.prependListener(signal, () => vite.kill(signal)));
+        vite.on('exit', (code, signal) => process.exit(code ?? 128 + os.constants.signals[signal]));
+    }));
+
 program.command('licenses')
     .description('list bundled native dependencies with SPDX license, versions and source URL')
     .option('--notices [file]', 'write a THIRD-PARTY-NOTICES markdown file (default: THIRD-PARTY-NOTICES.md)')
     .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']))
+    .addOption(new Option('-e, --runtime-env <runtimeEnv>', "also list the crossbind runtime an addon of --platform compiles in (without --platform the one its loader bundles), or what an app's host carries").choices(['node', 'app']))
     .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) => {
@@ -200,7 +216,7 @@ program.command('clean-deps')
     });
 
 // A container belongs to one image: the web container carries no NDK, and android runs a forced platform.
-const IMAGE_ROLES = ['web', 'android', 'linux', 'windows'];
+const IMAGE_ROLES = ['web', 'android', 'android-app', 'linux', 'windows'];
 const dockerContainerName = (role) => {
     if (!IMAGE_ROLES.includes(role)) {
         console.error(`crossbind: unknown image "${role}" - expected one of ${IMAGE_ROLES.join(', ')}.`);
@@ -230,8 +246,8 @@ const imageArgument = (command) => command.argument('[image]', `image to act on
 
 imageArgument(commandDocker.command('create').description('create docker container'))
     .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;
+        // Google ships the linux NDK for x86_64 only, so an android or android-app container is always amd64.
+        const platform = ['android', 'android-app'].includes(image) ? '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([
@@ -284,10 +300,10 @@ commandRunner.command('start')
         connectCommands(options.role, runner.url, runner.displayToken).forEach((line) => console.log(`  ${line}`));
     }));
 
-commandRunner.command('stop')
-    .description('stop and remove the local runner')
+commandRunner.command('delete')
+    .description('stop and delete the local runner')
     .addOption(roleOption())
-    .action(runnerAction((options) => stopRunner({ role: options.role })));
+    .action(runnerAction((options) => deleteRunner({ role: options.role })));
 
 commandRunner.command('init')
     .description('write a folder that deploys a runner to a hosting platform')
@@ -306,76 +322,7 @@ commandRunner.command('init')
         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');
-
-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));
-
-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
@@ -388,67 +335,6 @@ if (['build', 'clean-deps', 'licenses'].includes(argv[2])) {
 
 program.parse(argv);
 
-function listSystemKeys() {
-    console.info('Available configurations:');
-    console.table(systemKeys);
-}
-
-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);
-}
-
-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(', ')}`);
-    }
-
-    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(', ')}`);
-    }
-    delete state.config.system[key];
-    writeJson(state.config.paths.systemConfig, state.config.system);
-}
-
-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 }));
-    }
-}
-
 function run(programName, params) {
     runCrossbindApp(programName, params, null, null, { console: true });
 }
@@ -461,18 +347,20 @@ function onlyLoadsPackagedAddons(binaryParams) {
     return targets.every((target) => target.runtimeEnv === 'node' && target.platform !== 'wasm') && addonsInPackages();
 }
 
-async function build(targetParams, rebuildOption, binaryRuntimeEnvs) {
+async function build(targetParams, rebuildOption, binaryRuntimeEnvs, wasmOptions = {}, appPlatforms = []) {
     await buildDependencies({ targetParams, rebuildOption });
     const binaryParams = { ...targetParams, runtimeEnv: binaryRuntimeEnvs };
     if (!onlyLoadsPackagedAddons(binaryParams)) {
-        buildLib(targetParams);
+        // An app links its archives into itself, so it publishes no xcframework or podspec of them.
+        buildLib(targetParams, { skipXcframework: binaryRuntimeEnvs.includes('app') });
     }
     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 createWasmJs(binaryParams, wasmOptions);
         await createNodeAddons(binaryParams);
         await createNativeCommands(binaryParams);
+        await createApps({ ...binaryParams, platform: appPlatforms });
         await createWasiCommands(binaryParams);
     }
     buildPackageTypes();
@@ -491,6 +379,26 @@ async function createNativeCommands(targetParams) {
     }
 }
 
+// An app built without a bundler has no page; the Vite plugin puts one in.
+async function createApps(targetParams) {
+    const targets = getBuildTargets(targetParams).filter((target) => target.runtimeEnv === 'app');
+    if (targets.length === 0) {
+        return;
+    }
+    targets.forEach(assertAppRunner);
+    const bridges = createNativeBridges(targets).headers.flatMap((header) => header.bridge ?? []);
+    // An iOS or Android app is one project for all its SDKs or ABIs, written once they are built, and every time, as it
+    // also takes the app's identity and the host package's template.
+    const projects = new Map();
+    for (const target of targets) {
+        const isProject = ['ios', 'android'].includes(target.platform);
+        const built = await buildApp(target, { bridges, force: !isProject && !fs.existsSync(appOutputPath(target)) });
+        if (isProject) projects.set(appOutputPath(target), target);
+        else if (built) publishApp(target);
+    }
+    projects.forEach((target) => publishApp(target));
+}
+
 async function createWasiCommands(targetParams) {
     const targets = getFilteredBuildTargets(targetParams, { platform: 'wasi' });
     if (targets.length === 0) {
@@ -506,23 +414,6 @@ async function createWasiCommands(targetParams) {
     }
 }
 
-function createBridges(target) {
-    let headers = [];
-    state.config.paths.header.forEach((headerPath) => {
-        headers.push(findFiles('**/*.h', { cwd: headerPath }));
-    });
-    headers = headers.filter((path) => !!path.toString()).flat();
-
-    return headers.map((header) => ({ file: header, bridge: createBridgeFile(header, target) }));
-}
-
-// 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 });
@@ -544,10 +435,7 @@ 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 { headers, imports } = createNativeBridges(targets);
     const opt = {
         buildSource: false,
         nativeGlob: [
@@ -593,16 +481,15 @@ function scopeOutputToCommonJs() {
     }
 }
 
-async function createWasmJs(targetParams) {
+async function createWasmJs(targetParams, wasmOptions = {}) {
     const targets = getFilteredBuildTargets(targetParams, { platform: 'wasm' });
     if (targets.length === 0) {
         return;
     }
     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 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: [
@@ -619,7 +506,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', optOf(isNode(target) ? nodeHeaders : headers));
+        createLib(target, 'Bridge', optOf(bindsImports(target) ? appHeaders : headers));
         const built = await buildWasm(target, { force: !distComplete });
         if (!built) {
             continue;
@@ -640,15 +527,21 @@ async function createWasmJs(targetParams) {
     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 (nodeHeaders.length && nodeTarget) {
+    if (appHeaders.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));
+        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) {

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

@@ -3,6 +3,12 @@ export { default as getParentPath } from './utils/getParentPath.js';
 export { default as createLib } from './actions/createLib.js';
 export { default as createBridgeFile } from './actions/createInterface.js';
 export { default as buildWasm } from './actions/buildWasm.js';
+export {
+    default as buildApp, buildProjectApp, publishApp, appLayout, appOutputName, appTargetParams,
+} from './actions/buildApp.js';
+export { default as openInSimulator, buildForSimulator } from './actions/iosSimulator.js';
+export { default as openOnDevice } from './actions/androidDevice.js';
+export { buildApk } from './actions/androidGradle.js';
 export { default as isSourceNewer } from './actions/isSourceNewer.js';
 export { default as getData } from './actions/getData.js';
 export { default as getCmakeParameters } from './actions/getCmakeParameters.js';

package/src/integration/getCrossbindScript.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import getData from '../actions/getData.js';
+import getEnv from '../actions/getEnv.js';
 import loadJson from '../utils/loadJson.js';
 import state from '../state/index.js';
 import { parseSurface, createRustBridgeCrate, createCrateImportBridge } from '../utils/rustBridgeGen.js';
@@ -70,6 +70,7 @@ export function getRustSymbols(rsFile) {
             modulePath,
             spec: cargoDeps[crateName],
             cacheDir: state.config.paths.cache,
+            projectDir: state.config.paths.project,
             dtsMode: state.config.dts,
             log: () => {},
         });
@@ -110,8 +111,10 @@ function buildScript(target, symbols, base) {
     if (!target) {
         throw new Error('The target is not available!');
     }
-    const env = JSON.stringify(getData('env', target));
-    const getPlatformScript = target.platform === 'wasm' ? getWebScript : getReactNativeScript;
+    const env = JSON.stringify(getEnv(target));
+    let getPlatformScript = getReactNativeScript;
+    if (target.platform === 'wasm') getPlatformScript = getWebScript;
+    else if (target.runtimeEnv === 'app') getPlatformScript = getAppScript;
 
     let symbolExportDefineString = '';
     let symbolExportAssignString = '';
@@ -178,7 +181,7 @@ function getReactNativeScript(env) {
         const RNJsiLib = TurboModuleRegistry.get('RNJsiLib');
 
         function setEnv() {
-            const env = JSON.parse('${env}');
+            const env = ${env};
             const CROSSBIND_DATA_PATH = Module.Crossbind.getEnv('CROSSBIND_DATA_PATH');
 
             Object.entries(env).forEach(([key, value]) => {
@@ -199,6 +202,18 @@ function getReactNativeScript(env) {
     `;
 }
 
+// An app's page loads the runtime the app serves as crossbind.js, which asks the app's host for the module. The build's
+// env is the host's own, so the page passes on only what initNative() is given.
+function getAppScript(env, base) {
+    return `
+        function __crossbindBoot(config) {
+            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(() => window.Crossbind.initNative(config));
+        }
+    `;
+}
+
 function getWebScript(env, base) {
     const params = `{
         path: base,