crossbind 2.0.0-beta.64 → 2.0.0-beta.65

package/src/actions/nativeBridges.js

@@ -0,0 +1,35 @@
+import createBridgeFile from './createInterface.js';
+import { createImportedBridges, findAppNativeImports } from './createImportedBridges.js';
+import getDependFilePath from '../integration/getDependFilePath.js';
+import state from '../state/index.js';
+import findFiles from '../utils/findFiles.js';
+import {
+    boundHeaderSpecifiers, bridgeTargets, nodeBridgeTarget, resolveBoundHeaders,
+} from '../utils/boundHeaders.js';
+
+// The project's own headers, each with its bridge.
+export 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.
+export 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 }) }));
+}
+
+// What a native binary binds, an addon or an app host: the project's headers, the dependency headers the config binds
+// whole, and the ones the app's sources import.
+export function createNativeBridges(targets) {
+    const boundHeaders = createBoundBridges(targets);
+    const ownHeaders = [...createBridges(nodeBridgeTarget(targets)), ...boundHeaders];
+    const imports = findAppNativeImports(bridgeTargets(targets, state.targets));
+    return { headers: [...ownHeaders, ...createImportedBridges(ownHeaders, imports)], imports };
+}

package/src/actions/run.js

@@ -22,7 +22,7 @@ import {
 } from '../utils/darwinToolchain.js';
 
 // Native builds can outrun Node's 1 MiB default pipe buffer; without a raised cap a successful build dies with ENOBUFS.
-const EXEC_MAX_BUFFER = 512 * 1024 * 1024;
+export const EXEC_MAX_BUFFER = 512 * 1024 * 1024;
 // Containers share the memory of Docker's VM, and one compile at full -j can take most of a desktop VM
 // (GDAL's bindings peak at 7.5 of 7.7 GiB), so the exclusive steps of parallel builds take turns.
 const DOCKER_COMPILE_LOCK = path.join(os.homedir(), '.crossbind', 'docker-compile.lock');
@@ -124,7 +124,7 @@ const iosParams = [
 
 // The C++ compiler of the image that runs SWIG for the target, so its -dM macro table matches that parse.
 export function cxxPreprocessorFor(target) {
-    if (imageRoleFor(target) !== 'android') return 'em++';
+    if (target?.platform !== 'android') return 'em++';
     return `${t}/${target.arch === 'x86_64' ? CROSSCOMPILER_x86_64 : CROSSCOMPILER_ARM64}-clang++`;
 }
 
@@ -196,7 +196,7 @@ export default function run(program, params = [], platformPrefix = null, target
             case 'android':
                 [dProgram, ...dParams] = params;
                 platformParams = target.arch === 'x86_64' ? androidParamsX86_64 : androidParamsArm64;
-                if (dProgram === 'cmake') {
+                if (dProgram === 'cmake' && dParams[0] !== '--build' && dParams[0] !== '--install') {
                     dParams = [
                         ...dParams,
                         `-DCMAKE_TOOLCHAIN_FILE=${ANDROID_NDK}/build/cmake/android.toolchain.cmake`,

package/src/actions/target.js

@@ -28,7 +28,8 @@ export function getTargetParams(givenTargetParams = {}, noParamCheck = false) {
 }
 
 export function getBuildTargets(targetParams) {
-    const { platform, arch, runtime, buildType, runtimeEnv } = targetParams;
+    // A lookup that names no runtime environment finds the targets that have none: the archives' alone.
+    const { platform, arch, runtime, buildType, runtimeEnv = [] } = targetParams;
     return state.targets.filter(t => (
         (!t.platform || platform.includes(t.platform))
         && (!t.arch || arch.includes(t.arch))

package/src/actions/xcodeProject.js

@@ -0,0 +1,152 @@
+import fs from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import state from '../state/index.js';
+import { IOS_DEPLOYMENT_TARGET } from '../utils/iosToolchain.js';
+import { textPlist, xmlPlist } from '../utils/plist.js';
+
+// The SDKs an iOS app builds for, one target each, and the slice of Hermes' release each takes.
+export const IOS_SDKS = ['iphoneos', 'iphonesimulator'];
+export const HERMES_SLICES = { iphoneos: 'ios-arm64', iphonesimulator: 'ios-arm64_x86_64-simulator' };
+// What the host's own code needs from the system: Xcode adds it only for the sources it compiles itself.
+const SYSTEM_LIBS = ['-framework', 'UIKit', '-framework', 'WebKit', '-framework', 'CoreGraphics', '-lc++'];
+
+const MAIN = `// crossbind writes this project anew on every build: the app comes prebuilt in lib/, and its files are in app/.
+int crossbind_app_main(int argc, char *argv[]);
+
+int main(int argc, char *argv[]) { return crossbind_app_main(argc, argv); }
+`;
+
+const OBJECT_NAMES = ['project', 'mainGroup', 'products', 'target', 'product', 'main', 'info', 'app', 'hermes', 'mainBuild',
+    'appBuild', 'hermesLink', 'hermesEmbed', 'sources', 'frameworks', 'resources', 'embed', 'projectDebug', 'projectRelease',
+    'targetDebug', 'targetRelease', 'projectConfigs', 'targetConfigs'];
+// Xcode names its objects by 24 hex digits. Fixed ones leave the project unchanged while what it holds is.
+const ID = Object.fromEntries(OBJECT_NAMES.map((name, index) => [name, `CB${(index + 1).toString(16).toUpperCase().padStart(22, '0')}`]));
+
+const PROJECT_SETTINGS = {
+    SDKROOT: 'iphoneos',
+    SUPPORTED_PLATFORMS: 'iphoneos iphonesimulator',
+    IPHONEOS_DEPLOYMENT_TARGET: IOS_DEPLOYMENT_TARGET,
+    TARGETED_DEVICE_FAMILY: '1,2',
+    // crossbind's iOS archives are arm64 alone, for devices and the Simulator alike.
+    ARCHS: 'arm64',
+    ALWAYS_SEARCH_USER_PATHS: 'NO',
+    CLANG_ENABLE_OBJC_ARC: 'YES',
+    DEAD_CODE_STRIPPING: 'YES',
+};
+
+const ORIENTATIONS = ['UIInterfaceOrientationPortrait', 'UIInterfaceOrientationLandscapeLeft', 'UIInterfaceOrientationLandscapeRight'];
+
+const infoPlist = (name) => xmlPlist({
+    CFBundleDevelopmentRegion: 'en',
+    CFBundleDisplayName: name,
+    CFBundleExecutable: '$(EXECUTABLE_NAME)',
+    CFBundleIdentifier: '$(PRODUCT_BUNDLE_IDENTIFIER)',
+    CFBundleInfoDictionaryVersion: '6.0',
+    CFBundleName: '$(PRODUCT_NAME)',
+    CFBundlePackageType: 'APPL',
+    CFBundleShortVersionString: '$(MARKETING_VERSION)',
+    CFBundleVersion: '$(CURRENT_PROJECT_VERSION)',
+    LSRequiresIPhoneOS: true,
+    UIApplicationSceneManifest: { UIApplicationSupportsMultipleScenes: false },
+    UILaunchScreen: {},
+    UISupportedInterfaceOrientations: ORIENTATIONS,
+    'UISupportedInterfaceOrientations~ipad': [...ORIENTATIONS, 'UIInterfaceOrientationPortraitUpsideDown'],
+});
+
+function objects(name, targetSettings) {
+    const file = (path, type) => ({ isa: 'PBXFileReference', lastKnownFileType: type, path, sourceTree: '<group>' });
+    const phase = (isa, files, extra = {}) => ({ isa, buildActionMask: 2147483647, files, runOnlyForDeploymentPostprocessing: 0, ...extra });
+    const configuration = (configurationName, buildSettings) => ({ isa: 'XCBuildConfiguration', buildSettings, name: configurationName });
+    const configurations = (debug, release) => ({
+        isa: 'XCConfigurationList', buildConfigurations: [debug, release], defaultConfigurationIsVisible: 0, defaultConfigurationName: 'Release',
+    });
+    return {
+        [ID.main]: file('main.m', 'sourcecode.c.objc'),
+        [ID.info]: file('Info.plist', 'text.plist.xml'),
+        [ID.app]: file('app', 'folder'),
+        [ID.hermes]: file('Frameworks/hermesvm.xcframework', 'wrapper.xcframework'),
+        [ID.product]: {
+            isa: 'PBXFileReference', explicitFileType: 'wrapper.application', includeInIndex: 0, path: `${name}.app`, sourceTree: 'BUILT_PRODUCTS_DIR',
+        },
+        [ID.mainBuild]: { isa: 'PBXBuildFile', fileRef: ID.main },
+        [ID.appBuild]: { isa: 'PBXBuildFile', fileRef: ID.app },
+        [ID.hermesLink]: { isa: 'PBXBuildFile', fileRef: ID.hermes },
+        [ID.hermesEmbed]: { isa: 'PBXBuildFile', fileRef: ID.hermes, settings: { ATTRIBUTES: ['CodeSignOnCopy', 'RemoveHeadersOnCopy'] } },
+        [ID.sources]: phase('PBXSourcesBuildPhase', [ID.mainBuild]),
+        [ID.frameworks]: phase('PBXFrameworksBuildPhase', [ID.hermesLink]),
+        [ID.resources]: phase('PBXResourcesBuildPhase', [ID.appBuild]),
+        [ID.embed]: phase('PBXCopyFilesBuildPhase', [ID.hermesEmbed], { dstPath: '', dstSubfolderSpec: 10, name: 'Embed Frameworks' }),
+        [ID.mainGroup]: { isa: 'PBXGroup', children: [ID.main, ID.info, ID.app, ID.hermes, ID.products], sourceTree: '<group>' },
+        [ID.products]: { isa: 'PBXGroup', children: [ID.product], name: 'Products', sourceTree: '<group>' },
+        [ID.target]: {
+            isa: 'PBXNativeTarget',
+            buildConfigurationList: ID.targetConfigs,
+            buildPhases: [ID.sources, ID.frameworks, ID.resources, ID.embed],
+            buildRules: [],
+            dependencies: [],
+            name,
+            productName: name,
+            productReference: ID.product,
+            productType: 'com.apple.product-type.application',
+        },
+        [ID.project]: {
+            isa: 'PBXProject',
+            buildConfigurationList: ID.projectConfigs,
+            compatibilityVersion: 'Xcode 14.0',
+            developmentRegion: 'en',
+            hasScannedForEncodings: 0,
+            knownRegions: ['en', 'Base'],
+            mainGroup: ID.mainGroup,
+            productRefGroup: ID.products,
+            projectDirPath: '',
+            projectRoot: '',
+            targets: [ID.target],
+        },
+        [ID.projectDebug]: configuration('Debug', PROJECT_SETTINGS),
+        [ID.projectRelease]: configuration('Release', PROJECT_SETTINGS),
+        [ID.targetDebug]: configuration('Debug', targetSettings),
+        [ID.targetRelease]: configuration('Release', targetSettings),
+        [ID.projectConfigs]: configurations(ID.projectDebug, ID.projectRelease),
+        [ID.targetConfigs]: configurations(ID.targetDebug, ID.targetRelease),
+    };
+}
+
+// An iOS app as an Xcode project, written anew from the parts its SDK targets built: each brings its archives and
+// their link line, and its slice of Hermes; the first also the app's files. Xcode signs the app and runs it, in the
+// Simulator or on a device.
+export default function writeXcodeProject(to, { parts, identity, version }) {
+    const { name } = state.config.general;
+    if (parts.length === 0) throw new Error(`crossbind: no part of the iOS app ${name} is built, so there is no Xcode project to write.`);
+    fs.rmSync(to, { recursive: true, force: true });
+    fs.mkdirSync(`${to}/${name}.xcodeproj`, { recursive: true });
+    const linkFlags = {};
+    parts.forEach(({ sdk, dir }) => {
+        fs.cpSync(`${dir}/lib`, `${to}/lib/${sdk}`, { recursive: true });
+        // The quotes keep a project path with spaces in one argument.
+        const args = JSON.parse(fs.readFileSync(`${dir}/link.json`, 'utf8'))
+            .map((arg) => arg.replace(/\{lib\}\/(.+)$/, `"$(PROJECT_DIR)/lib/${sdk}/$1"`));
+        linkFlags[`OTHER_LDFLAGS[sdk=${sdk}*]`] = [...args, ...SYSTEM_LIBS];
+    });
+    fs.cpSync(`${parts[0].dir}/app`, `${to}/app`, { recursive: true });
+    const frameworks = parts.flatMap(({ dir }) => ['-framework', `${dir}/hermesvm.framework`]);
+    const result = spawnSync('xcodebuild', ['-create-xcframework', ...frameworks, '-output', `${to}/Frameworks/hermesvm.xcframework`], { encoding: 'utf8' });
+    if (result.status !== 0) throw new Error(`crossbind: cannot make Hermes' xcframework for ${to}: ${result.stderr || result.error?.message}`);
+
+    fs.writeFileSync(`${to}/main.m`, MAIN);
+    fs.writeFileSync(`${to}/Info.plist`, infoPlist(name));
+    const targetSettings = {
+        PRODUCT_NAME: name,
+        PRODUCT_BUNDLE_IDENTIFIER: identity.id,
+        DEVELOPMENT_TEAM: identity.team,
+        CODE_SIGN_STYLE: 'Automatic',
+        INFOPLIST_FILE: 'Info.plist',
+        MARKETING_VERSION: version,
+        CURRENT_PROJECT_VERSION: version,
+        LD_RUNPATH_SEARCH_PATHS: ['$(inherited)', '@executable_path/Frameworks'],
+        ...linkFlags,
+    };
+    fs.writeFileSync(`${to}/${name}.xcodeproj/project.pbxproj`, textPlist({
+        archiveVersion: 1, classes: {}, objectVersion: 56, objects: objects(name, targetSettings), rootObject: ID.project,
+    }));
+    return to;
+}

package/src/assets/js-runtime/adapters/worker-comlink.js

@@ -41,8 +41,12 @@ const ownsObject = (obj) => {
     return Boolean($$ && ($$.smartPtr || $$.count?.owned));
 };
 
+// The module's own objects, its globals above all, live as long as the module, so letting go of a handle to one
+// frees nothing.
+const moduleObjects = new WeakSet();
+
 const freeIfOwned = (obj) => {
-    if (ownsObject(obj) && !obj.isDeleted()) obj.delete();
+    if (ownsObject(obj) && !moduleObjects.has(obj) && !obj.isDeleted()) obj.delete();
 };
 
 // The worker side of a handle the main thread no longer reaches: its id goes, and the object with the last id.
@@ -297,6 +301,9 @@ export function moduleRoot(m) {
         configurable: true,
     });
     Object.defineProperty(m, RELEASE, { value: releaseEmbindObjects, configurable: true });
+    Object.values(m).forEach((value) => {
+        if (value !== null && typeof value === 'object') moduleObjects.add(value);
+    });
     return wrapWithVectorCoercion(m);
 }
 

package/src/assets/toolchain-digests.json

@@ -1,49 +1,55 @@
 {
-    "version": "1.0.13",
+    "version": "1.0.15",
     "registry": "ghcr.io/crossbind",
     "toolchains": {
         "rust": "1.99.1"
     },
     "images": {
         "rust-sysroot": {
-            "index": "sha256:c545ea396bd8919f7a671617dbbdf184bd0d6eb904d3170dd120d6671db3e0a9",
+            "index": "sha256:720469aca3cff3f1abe69374882d2c48399864be3778225e7754e94036e3be7a",
             "platforms": {
-                "linux/arm64": "sha256:c53ee0a31c52fdc6eba175e479218ddbff0c071654b5e93a08ae768cdbbfe35a",
-                "linux/amd64": "sha256:1427255e619c3f5dcd3fa7fd284d15afbe00eef1a0798e08a9b50ebbb86c5234"
+                "linux/arm64": "sha256:3aa68ad3736491de26c6ca9b52a49c80e6291228cc17a05caba4c060ea68913c",
+                "linux/amd64": "sha256:e77357a8c763244a5a5b4086fb771e81bec385526432ec6e77fb316f39158c53"
             }
         },
         "base": {
-            "index": "sha256:5f5d133504cb2c81ee67a93ca5795698423277522caac742478510d6158ed559",
+            "index": "sha256:a7c9342c50a493c990f8c26f1bec7e3919ad6010ce8a6cdfaa772487a1040989",
             "platforms": {
-                "linux/arm64": "sha256:df1c82f4b7e00a4ab33e2423f6d5bbaa66dd67bc45b96e5498e3391ec5f55fae",
-                "linux/amd64": "sha256:ffc0a178bc821e56975d9348b7e44d8081b9c6fb9351bc168b38d5063d9864ea"
+                "linux/arm64": "sha256:c9152c3ff4854ba898df1b9fe89e8a94fd29aa5832e8cc5a4bd5fa2e06cee10f",
+                "linux/amd64": "sha256:817fc177f488b975bbbd196d9ec9d1d3effbf2c59d1ed82e979fcf5124c4c1aa"
             }
         },
         "web": {
-            "index": "sha256:b5ee271886c316404cae103c5412bc02d811ad48fd36a919fdf3a82af14fe688",
+            "index": "sha256:143c2e79a950f732913726f32559f7c70323accf2727b34a12f332df91b765ef",
             "platforms": {
-                "linux/arm64": "sha256:91d35c9eac65f479f5139ba476b3daa3b517aab6f21f5206070af610cec5b62c",
-                "linux/amd64": "sha256:f308cb1702f308d69d9f21eb99aa109cdbf62e655549b483580476d8f01fb07b"
+                "linux/arm64": "sha256:ebd0dbeee77a5fde4659b5f129713e5006cc205c629f837b56478e3691e85b9c",
+                "linux/amd64": "sha256:14429be7ee52afa0bd9c94248db3a84f90e74c29700a3f5f34da2989d7161431"
             }
         },
         "android": {
-            "index": "sha256:a01ddeaed550091f45e720d09bd559978d4c46e396c4553b3fc4544b90033fd1",
+            "index": "sha256:249bdfda25dcd394c1e4955f3cd3e63140264697e9a543fbae1dce2ec3d80c38",
             "platforms": {
-                "linux/amd64": "sha256:3bafd0a3f80bf7370a19522a3b75cb58a977d1b1b28940ed02b87db1058a8fd6"
+                "linux/amd64": "sha256:725375a79e64c93a7cc7e35f4708e36511f6a36212e0a3aaf44f6b5ec1057724"
+            }
+        },
+        "android-app": {
+            "index": "sha256:d739c6b72e1545b086f38fe5613b58f52877a36e14c2ffd763acdd0296802802",
+            "platforms": {
+                "linux/amd64": "sha256:a7124034f1ba3d888b3cd32c18051f87498c47ec515eac809b7440394c54ecb7"
             }
         },
         "linux": {
-            "index": "sha256:c1d7f9672edb6eeea86172d8ba8cc8ba824f6c53134587ea247ea5dc126d6c43",
+            "index": "sha256:433af720cf95a99c4e007c0cfc98ab358c6ddc61fecca75a0b844f598d750b1b",
             "platforms": {
-                "linux/amd64": "sha256:0ff9ee1d5c139eb97934919f7b9535af0eb2c3bebd9c1974fa95cfb143e3ccf7",
-                "linux/arm64": "sha256:f476e4a95635c04aca741937c2174a1915731c52c9d182b247e17d4ca4163b33"
+                "linux/arm64": "sha256:0cf32948302c1a23294d28d20dd3b784790c7789b9e99bc8be56888bddb6aeb7",
+                "linux/amd64": "sha256:6da084ff433e792381aadd280b769aa1b09ba593e3e21ea4580f4736776e3cb9"
             }
         },
         "windows": {
-            "index": "sha256:53b08c8918a84023ea90c6420fff783564aced0ec711fa0e7b71a09578643a32",
+            "index": "sha256:c1fb594cb245f6b0414f04cb7413881532438b204c7ce06f78f6deaea2d3cb24",
             "platforms": {
-                "linux/arm64": "sha256:402f115c8eed9e6418cf9e47a6bcad2d456d15d032c9b2baaa54a5005f00c8ba",
-                "linux/amd64": "sha256:50f359882015ca93c8b356a01bf03ce4cb098307f72c30122c7b6ad123eae339"
+                "linux/amd64": "sha256:3ee3a4f9c565b0d2adedc3c699871bf8de4c2d7034b2b7a24309f4a6c4d0e64c",
+                "linux/arm64": "sha256:44702d741848f96d71dfb0a5322c37c9c248f7a38fe9e7c09b7d307ce000cc3f"
             }
         }
     }

package/src/bin.js

@@ -1,17 +1,21 @@
 #!/usr/bin/env node
 
 import fs from 'node:fs';
-import { execFileSync } from 'node:child_process';
+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 { 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, { 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';
@@ -19,8 +23,7 @@ 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 { 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';
@@ -84,7 +87,8 @@ program.command('build')
         if (state.config.build.withBuildConfig) {
             buildExternal(targetParams);
         } else {
-            build(targetParams, rebuildDeps, binaryRuntimeEnvs, { bindImports });
+            // 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 ?? []);
         }
     });
 
@@ -99,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) => {
@@ -175,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(', ')}.`);
@@ -205,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([
@@ -306,11 +347,12 @@ function onlyLoadsPackagedAddons(binaryParams) {
     return targets.every((target) => target.runtimeEnv === 'node' && target.platform !== 'wasm') && addonsInPackages();
 }
 
-async function build(targetParams, rebuildOption, binaryRuntimeEnvs, wasmOptions = {}) {
+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.`);
@@ -318,6 +360,7 @@ async function build(targetParams, rebuildOption, binaryRuntimeEnvs, wasmOptions
         await createWasmJs(binaryParams, wasmOptions);
         await createNodeAddons(binaryParams);
         await createNativeCommands(binaryParams);
+        await createApps({ ...binaryParams, platform: appPlatforms });
         await createWasiCommands(binaryParams);
     }
     buildPackageTypes();
@@ -336,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) {
@@ -351,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 });
@@ -389,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: [

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

@@ -112,7 +112,9 @@ function buildScript(target, symbols, base) {
         throw new Error('The target is not available!');
     }
     const env = JSON.stringify(getEnv(target));
-    const getPlatformScript = target.platform === 'wasm' ? getWebScript : getReactNativeScript;
+    let getPlatformScript = getReactNativeScript;
+    if (target.platform === 'wasm') getPlatformScript = getWebScript;
+    else if (target.runtimeEnv === 'app') getPlatformScript = getAppScript;
 
     let symbolExportDefineString = '';
     let symbolExportAssignString = '';
@@ -200,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,

package/src/state/index.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import loadJson from '../utils/loadJson.js';
 import writeJson from '../utils/writeJson.js';
 import {
-    TARGETS, targetPathOf, nodeAddonNamesOf, nativeCommandNamesOf, wasiNamesOf,
+    TARGETS, targetPathOf, nodeAddonNamesOf, nativeCommandNamesOf, wasiNamesOf, appNamesOf,
 } from '../utils/targets.js';
 import { findCargoModuleImportsIn, writeCargoMarker } from '../utils/cargoImport.js';
 import { exportWasiSdkPath } from '../utils/wasiToolchain.js';
@@ -35,6 +35,7 @@ async function initProcessState() {
         DOCKER_REGISTRY_MIRROR: 'CROSSBIND_REGISTRY_MIRROR',
         DOCKER_IMAGE_WEB: 'CROSSBIND_IMAGE_WEB',
         DOCKER_IMAGE_ANDROID: 'CROSSBIND_IMAGE_ANDROID',
+        DOCKER_IMAGE_ANDROID_APP: 'CROSSBIND_IMAGE_ANDROID_APP',
         DOCKER_IMAGE_LINUX: 'CROSSBIND_IMAGE_LINUX',
         DOCKER_IMAGE_WINDOWS: 'CROSSBIND_IMAGE_WINDOWS',
     }).forEach(([key, envKey]) => {
@@ -62,6 +63,9 @@ async function initProcessState() {
         if (target.runtimeEnv === 'native') {
             Object.assign(target, nativeCommandNamesOf(target, state.config.general.name));
         }
+        if (target.runtimeEnv === 'app') {
+            Object.assign(target, appNamesOf(target, state.config.general.name));
+        }
     });
 
     setAllDependecyPaths();

package/src/state/loadConfig.js

@@ -133,6 +133,8 @@ export function getFilledConfig(config, options = { isDepend: false }) {
         targetSpecs: config.targetSpecs || [],
         build: config.build || {},
         target: config.target || {},
+        // An app's identity: its bundle id, and on iOS the Apple team that signs it.
+        app: config.app || {},
         extensions: config.extensions || [],
         package: null,
         functions: config.functions || {},

package/src/utils/appRustCrates.js

@@ -80,7 +80,9 @@ export default function buildAppRustCrates(target, cacheDir, cargoDependencies =
         ...crates.map((c) => `${c.replaceAll('_', '-')}-crossbind-app = { path = "${relPath(superDir, `${root}/${c}`)}" }`),
         '',
         '[profile.release]',
-        'panic = "abort"',
+        // Unwinding, as in a package's bridge, whose shims raise a panic as a JS exception: an abort runtime here could
+        // end the process on a panic in any crate. wasm still aborts, as its std does.
+        'panic = "unwind"',
         '',
         ...crates.flatMap((c) => [`[profile.release.package.${c.replaceAll('_', '-')}-crossbind-app]`, 'codegen-units = 1', '']),
         '[workspace]',