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

package/src/actions/buildWasiCommand.js

@@ -7,14 +7,18 @@ import logger from '../utils/logger.js';
 import { getContentHash, getFilesFingerprint } from '../utils/hash.js';
 import { buildLinkLibArgs } from '../utils/linkLayout.js';
 import { wasiCxxFlags, WASI_LINK_LIBS } from '../utils/wasiToolchain.js';
+import { stageWasiHttpLink, wasiHttpFiles } from '../utils/wasiHttp.js';
 
 // Links a platform:'wasi' target into one command module: main() is the entry, deps are DCE'd, data lands as a real dir for --dir preopens.
+// An http target links into a wasi:http/service component instead, whose entry is crossbind's handler export.
 export default async function buildWasiCommand(target, options = {}) {
     const isProd = target.buildType === 'release';
     const buildType = isProd ? 'Release' : 'Debug';
+    const isHttp = target.runtimeEnv === 'http';
+    const step = isHttp ? 'wasi http' : 'wasi command';
 
     if (state.config.export?.type === 'cargo') {
-        logger.info(`[${target.path}] wasi command skipped (cargo packages have no cargo wasi triple)`);
+        logger.info(`[${target.path}] ${step} skipped (cargo packages have no cargo wasi triple)`);
         return false;
     }
 
@@ -52,17 +56,17 @@ export default async function buildWasiCommand(target, options = {}) {
             return { lib, size: stat ? stat.size : null, mtimeMs: stat ? stat.mtimeMs : null };
         }),
         data: getData('data', target),
-        runtime: getFilesFingerprint([stubs]),
+        runtime: getFilesFingerprint([stubs, ...(isHttp ? wasiHttpFiles(state.config.paths.cli) : [])]),
     }));
     const linkChanged = !fs.existsSync(linkFingerprintFile)
         || fs.readFileSync(linkFingerprintFile, { encoding: 'utf8' }) !== linkFingerprint;
 
     if (!options.force && !linkChanged && fs.existsSync(`${state.config.paths.build}/${target.wasmName}`)) {
-        logger.cachedStep(target, 'wasi command');
+        logger.cachedStep(target, step);
         return false;
     }
 
-    logger.startStep(target, 'wasi command');
+    logger.startStep(target, step);
     const t0 = performance.now();
     // stubs.c lives outside the docker mount (paths.cli); stage it next to the artifact.
     const stagedStubs = `${state.config.paths.build}/crossbind-wasi-stubs.c`;
@@ -71,6 +75,7 @@ export default async function buildWasiCommand(target, options = {}) {
     run(null, [
         'wasi-clang++',
         stagedStubs,
+        ...(isHttp ? stageWasiHttpLink(state.config.paths.cli, `${state.config.paths.build}/crossbind-wasi-http`) : []),
         ...wasiCxxFlags(),
         ...(isProd ? ['-O3'] : ['-O0']),
         ...wasiFlags,
@@ -79,7 +84,7 @@ export default async function buildWasiCommand(target, options = {}) {
         '-o', `${state.config.paths.build}/${target.wasmName}`,
     ], null, target);
     const ms = Math.round(performance.now() - t0);
-    logger.doneStep(target, 'wasi command', ms < 1000 ? `${ms}ms` : `${(ms / 1000).toFixed(1)}s`);
+    logger.doneStep(target, step, ms < 1000 ? `${ms}ms` : `${(ms / 1000).toFixed(1)}s`);
 
     // Dep data lands as a real folder next to the artifact for --dir preopens.
     Object.entries(getData('data', target)).forEach(([key, value]) => {

package/src/actions/buildWasm.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'node:url';
 import run from './run.js';
 import getLinkInputs from './getLinkInputs.js';
 import getData from './getData.js';
+import getEnv from './getEnv.js';
 import buildJs from './buildJs.js';
 import triggerExtensions from './extensions.js';
 import state from '../state/index.js';
@@ -14,9 +15,10 @@ import { buildLinkLibArgs } from '../utils/linkLayout.js';
 import { guardBigIntArguments, guardEmbindArguments } from '../utils/embindArgumentGuards.js';
 import { separateCallArguments } from '../utils/embindCallArguments.js';
 import { queueJspiCalls } from '../utils/embindJspiQueue.js';
+import { releaseOwnedHandles } from '../utils/embindObjectLifetime.js';
 import { spawnPthreadsFromMainScript } from '../utils/pthreadMainScript.js';
 
-const GLUE_REWRITES = ['../utils/embindArgumentGuards.js', '../utils/embindCallArguments.js', '../utils/embindJspiQueue.js', '../utils/pthreadMainScript.js']
+const GLUE_REWRITES = ['../utils/embindArgumentGuards.js', '../utils/embindCallArguments.js', '../utils/embindJspiQueue.js', '../utils/embindObjectLifetime.js', '../utils/pthreadMainScript.js']
     .map((file) => fileURLToPath(new URL(file, import.meta.url)));
 
 // embind's bigint converter turns any Number into a BigInt, so 2^53+1 silently becomes 2^53.
@@ -64,6 +66,17 @@ function queueJspiEmbindCalls(target) {
     }
 }
 
+// Objects JavaScript owns outside a smart pointer were freed only by .delete() (utils/embindObjectLifetime.js);
+// each runtimeEnv links its own glue, so each one calls this after its link.
+function releaseOwnedObjects(target) {
+    const gluePath = `${state.config.paths.build}/${target.rawJsName}`;
+    const { text, missed } = releaseOwnedHandles(fs.readFileSync(gluePath, 'utf8'));
+    fs.writeFileSync(gluePath, text);
+    if (missed) {
+        logger.error('embind object lifetime rewrite missed (emscripten glue format changed?): returned values and constructed vectors are freed only by .delete()');
+    }
+}
+
 // A direct-mode mt init in a browser spawns its pthreads from "/undefined" (utils/pthreadMainScript.js).
 function pointPthreadSpawn(target) {
     const gluePath = `${state.config.paths.build}/${target.rawJsName}`;
@@ -173,6 +186,8 @@ export default async function buildWasm(target, options = {}) {
             return { lib, size: stat ? stat.size : null, mtimeMs: stat ? stat.mtimeMs : null };
         }),
         data: getData('data', target),
+        // The JS the link step writes carries the env.
+        env: getEnv(target),
         runtime: getFilesFingerprint(runtimeAssets),
         rustSources: getFilesFingerprint(rustSources),
     }));
@@ -233,6 +248,7 @@ export default async function buildWasm(target, options = {}) {
         guardArgumentConversions(target);
         separateEmbindCalls(target);
         queueJspiEmbindCalls(target);
+        releaseOwnedObjects(target);
         await buildJs(target);
         // fs.rmSync(`${state.config.paths.build}/${state.config.general.name}.js`);
         // fs.copyFileSync(`${state.config.paths.build}/${state.config.general.name}.browser.js`, `${state.config.paths.build}/${state.config.general.name}.js`);
@@ -257,12 +273,13 @@ export default async function buildWasm(target, options = {}) {
             // it any linked Rust package archive fails with undefined crossbind_* symbols.
             ...linkLibs, ...rustSources,
             '-s', 'WASM=1', '-s', 'MODULARIZE=1', '-s', 'DYNAMIC_EXECUTION=0',
-            '-s', 'RESERVED_FUNCTION_POINTERS=200', // '-s', 'FORCE_FILESYSTEM=1',
+            '-s', 'RESERVED_FUNCTION_POINTERS=200',
             '-s', 'ALLOW_MEMORY_GROWTH=1',
             // See the GROWABLE_ARRAYBUFFERS note in the browser block (Firefox/WebKit TextDecoder).
             '-s', 'GROWABLE_ARRAYBUFFERS=0',
+            '-s', 'FORCE_FILESYSTEM=1',
             '-s', 'ENVIRONMENT=web',
-            '-s', 'EXPORTED_RUNTIME_METHODS=["ENV", "getExceptionMessage"]',
+            '-s', 'EXPORTED_RUNTIME_METHODS=["FS", "ENV", "getExceptionMessage"]',
             '-fwasm-exceptions',
             '-sEXPORT_EXCEPTION_HANDLING_HELPERS',
             '-o', `${state.config.paths.build}/${target.rawJsName}`,
@@ -275,6 +292,7 @@ export default async function buildWasm(target, options = {}) {
         guardArgumentConversions(target);
         separateEmbindCalls(target);
         queueJspiEmbindCalls(target);
+        releaseOwnedObjects(target);
         await buildJs(target);
         logger.doneStep(target, 'js');
     }
@@ -292,6 +310,8 @@ export default async function buildWasm(target, options = {}) {
             // '-s', 'FETCH', '-sJSPI', '-pthread', '-sPTHREAD_POOL_SIZE=5',
             '-s', 'FORCE_FILESYSTEM=1',
             ...linkLibs, ...rustSources, `${state.config.paths.cli}/assets/cpp-runtime/node.cpp`,
+            // node.cpp answers fsync and fdatasync for host files.
+            '-Wl,--wrap=__wasi_fd_sync', '-Wl,--wrap=__syscall_fdatasync',
             '-s', 'WASM=1', '-s', 'MODULARIZE=1', '-s', 'DYNAMIC_EXECUTION=0',
             '-s', 'RESERVED_FUNCTION_POINTERS=200', // '-s', 'DISABLE_EXCEPTION_CATCHING=0', '-s', 'FORCE_FILESYSTEM=1',
             '-s', 'ALLOW_MEMORY_GROWTH=1',
@@ -311,6 +331,7 @@ export default async function buildWasm(target, options = {}) {
         guardArgumentConversions(target);
         separateEmbindCalls(target);
         queueJspiEmbindCalls(target);
+        releaseOwnedObjects(target);
         await buildJs(target);
         if (emccFlags.includes('FETCH')) {
             fs.appendFileSync(`${state.config.paths.build}/${target.jsName}`, 'var XMLHttpRequest = require(\'xhr2\');\n');

package/src/actions/createImportedBridges.js

@@ -34,6 +34,13 @@ function resolveImport(specifier, importer, targets) {
     return null;
 }
 
+// Whether a binary binds what the app's own sources import. A Node binary does: its module hooks resolve those
+// imports. A browser binary only with --bind-imports: without a bundler a page cannot resolve a header import
+// unless it maps the specifiers itself, as the playground's sandbox does. Nothing on an edge runtime resolves one.
+export function bindsAppImports(target, { bindImports = false } = {}) {
+    return target.runtimeEnv === 'node' || (bindImports && target.runtimeEnv === 'browser');
+}
+
 // The native files the app's own sources import, by real path, each under the first target whose packages ship it
 // and with the bare specifiers that name it, which Node cannot resolve on its own.
 export function findAppNativeImports(targets) {

package/src/actions/createInterface.js

@@ -21,16 +21,15 @@ import {
 } from '../utils/swigInterface.js';
 import writeIfChanged from '../utils/writeIfChanged.js';
 import { withDirLockSync } from '../utils/dirLock.js';
-import { imageRoleFor } from '../utils/pullDockerImage.js';
 import { conanImportOfHeader } from '../utils/conanImport.js';
 import run, { cxxPreprocessorFor } from './run.js';
 import isSourceCmakePackage from '../utils/isSourceCmakePackage.js';
 
 // Part of every interface hash, so interfaces cached by an older generator are rebuilt.
-const INTERFACE_FORMAT = 'swig-macros-3';
+const INTERFACE_FORMAT = 'swig-macros-4';
 // Part of every bridge hash: each bridge carries the SWIG fork's runtime and all bridges of a module must share it, so
 // bridges from a fork before field bindings and constants are rebuilt.
-const BRIDGE_FORMAT = 'swig-extras-1';
+const BRIDGE_FORMAT = 'swig-extras-2';
 const predefinedMacros = new Map();
 const typeDefinitions = new Map();
 
@@ -188,7 +187,7 @@ function createInterfaceFile(headerOrModuleFilePath, target, sourceDir, { consta
     const fileName = interfaceName(headerOrModuleFilePath, filePathWithoutExt.split('/').at(-1));
 
     const macros = collectSwigMacros(headerOrModuleFilePath, interfaceIncludes(headerPath, prelude), fileName, target, sourceDir, constants);
-    const extras = interfaceExtras(named, macros.table);
+    const extras = interfaceExtras(named, macros.table, fs.readFileSync(headerOrModuleFilePath, 'utf8'));
     const content = buildInterfaceContent({
         moduleName: fileName.toUpperCase(),
         headerPath,
@@ -355,7 +354,7 @@ const RELEASE_DEFINE = '-DNDEBUG';
 // One bridge serves every desktop target, so SWIG and the macro table it reads come from the web image's em++,
 // which defines no operating system; an android bridge is read with the NDK it compiles with. The headers
 // still come from the target's own packages.
-const toolTargetFor = (target) => (imageRoleFor(target) === 'android' ? target : { ...target, platform: 'wasm' });
+const toolTargetFor = (target) => (target?.platform === 'android' ? target : { ...target, platform: 'wasm' });
 
 function dumpMacros(outputFile, includes, includePath, target, defines = []) {
     const tool = toolTargetFor(target);

package/src/actions/createLib.js

@@ -10,11 +10,13 @@ import triggerExtensions from './extensions.js';
 import state from '../state/index.js';
 import logger from '../utils/logger.js';
 import { WASI_EMULATION_LIBS, WASI_LINK_LIBS, wasiCFlags, wasiCxxFlags } from '../utils/wasiToolchain.js';
+import { stageWasiHttpInclude, wasiHttpHeader } from '../utils/wasiHttp.js';
 import { getFilesFingerprint, getContentHash } from '../utils/hash.js';
 import { withDependencyBridges } from '../utils/dependencyBridges.js';
 import { targetArchiveFlags } from '../utils/archiveFlags.js';
 import { conanInputsOf } from '../utils/conanDependencies.js';
 import { nativeSourceStampChanged, writeNativeSourceStamp } from '../utils/nativeSourceStamp.js';
+import resetCMakeCacheForSource from '../utils/resetCMakeCacheForSource.js';
 
 const cpuCount = Math.max(1, os.cpus().length - 1);
 const sharedPlatforms = ['android'];
@@ -56,7 +58,15 @@ export default function createLib(target, fileType, options = {}) {
     const conanInputs = conanInputsOf(state.config);
     const compileInputs = compileOptions.length ? { emccFlags: configEmccFlags, compileOptions } : configEmccFlags;
     const flagsInputs = sourceReplacements.length ? { compileInputs, sourceReplacements } : compileInputs;
-    const flagsFingerprint = getContentHash(JSON.stringify(conanInputs ? [flagsInputs, conanInputs] : flagsInputs));
+    const keyInputs = conanInputs ? [flagsInputs, conanInputs] : flagsInputs;
+    // An app's wasi source compiles against <crossbind/http.h>, so a new one misses this cache too.
+    const httpHeader = target.platform === 'wasi' && !state.config.build.withBuildConfig
+        ? getFilesFingerprint([wasiHttpHeader(state.config.paths.cli)])
+        : null;
+    // An Android app links the project's archives from the build where React Native's shared library comes from.
+    const appArchives = target.platform === 'android' && target.runtimeEnv === 'app' ? 'archives' : null;
+    const extraKeys = [httpHeader, appArchives].filter(Boolean);
+    const flagsFingerprint = getContentHash(JSON.stringify(extraKeys.length ? [keyInputs, ...extraKeys] : keyInputs));
     const flagsChanged = !fs.existsSync(flagsFingerprintFile)
         || fs.readFileSync(flagsFingerprintFile, { encoding: 'utf8' }) !== flagsFingerprint;
 
@@ -142,7 +152,11 @@ export default function createLib(target, fileType, options = {}) {
             buildEnv.params.push('-e', e);
         });
     } else {
-        buildParams = getCmakeParameters(target, { ...options, nativeGlob });
+        // The source of an http build includes <crossbind/http.h>.
+        const headerDirs = target.platform === 'wasi'
+            ? [...(options.headerDirs ?? []), stageWasiHttpInclude(state.config.paths.cli, `${buildPath}/crossbind-wasi-http`)]
+            : options.headerDirs;
+        buildParams = getCmakeParameters(target, { ...options, nativeGlob, headerDirs });
 
         triggerExtensions('createLib', 'setFlagWithoutBuildConfig', [buildEnv]);
 
@@ -229,6 +243,7 @@ export default function createLib(target, fileType, options = {}) {
                 stageWasiStubs();
                 buildParams.push(`-DCMAKE_EXE_LINKER_FLAGS=${[...wasiCxxFlags(), wasiStubObj, ...WASI_LINK_LIBS].join(' ')}`);
             }
+            resetCMakeCacheForSource(buildPath, cmakeDir, target);
             run(null, [
                 target.platform === 'ios' && state.config.build?.useIOSCMake ? 'ios-cmake' : 'cmake', cmakeDir,
                 `-DCMAKE_BUILD_TYPE=${buildType}`,

package/src/actions/getCmakeParameters.js

@@ -32,8 +32,9 @@ export default function getCmakeParameters(target, options = {}) {
         ...(options.headerDirs || []),
     ];
 
+    // React Native loads a library on Android as a shared one; an app's host links the project's archives into itself.
     const sharedPlatforms = ['android'];
-    const buildType = sharedPlatforms.includes(target.platform) ? 'SHARED' : 'STATIC';
+    const buildType = sharedPlatforms.includes(target.platform) && target.runtimeEnv !== 'app' ? 'SHARED' : 'STATIC';
     const otherBuildType = buildType === 'STATIC' ? 'SHARED' : 'STATIC';
 
     const cmakeCompileOptions = [...new Set(getData('cmake', target)?.compileOptions || [])];

package/src/actions/getData.js

@@ -30,7 +30,8 @@ function getRecursiveData(obj, config, dependency, field, target) {
                 obj[dKey] = [...(obj[dKey] || []), ...value];
             } else if (typeof value === 'object') {
                 obj[dKey] = { ...(obj[dKey] || {}), ...value };
-            } else {
+            } else if (!Object.hasOwn(obj, dKey)) {
+                // The app comes before its dependencies and a package before its own, so the nearest value stays.
                 obj[dKey] = value;
             }
         }

package/src/actions/getDependLibs.js

@@ -11,9 +11,15 @@ export default function getDependLibs(target) {
             const ignoreLibNames = getFilteredTargetSpec(d?.targetSpecs, target).map(s => s.ignoreLibName).flat();
             d.export.libName.forEach((fileName) => {
                 if (ignoreLibNames?.includes(fileName)) return;
-                let libPaths = findFiles(`${d.paths.output}/prebuilt/${target.path}/lib/lib${fileName}.a`, { cwd: d.paths.project });
+                // On Android a package ships the shared library React Native packages, which an app carries beside
+                // its host.
+                const extensions = target.platform === 'android' ? ['a', 'so'] : ['a'];
+                const libsIn = (targetPath) => extensions
+                    .map((extension) => findFiles(`${d.paths.output}/prebuilt/${targetPath}/lib/lib${fileName}.${extension}`, { cwd: d.paths.project }))
+                    .find((found) => found.length > 0) ?? [];
+                let libPaths = libsIn(target.path);
                 if (libPaths.length === 0) {
-                    libPaths = findFiles(`${d.paths.output}/prebuilt/${target.releasePath}/lib/lib${fileName}.a`, { cwd: d.paths.project });
+                    libPaths = libsIn(target.releasePath);
                 }
                 dependLibs.push(...libPaths);
             });

package/src/actions/getEnv.js

@@ -0,0 +1,7 @@
+import state from '../state/index.js';
+import getData from './getData.js';
+
+export default function getEnv(target) {
+    return Object.fromEntries(Object.entries(getData('env', target))
+        .map(([key, value]) => [key, typeof value === 'function' ? value(state, target) : value]));
+}

package/src/actions/getLinkInputs.js

@@ -3,20 +3,23 @@ import getDependLibs from './getDependLibs.js';
 import state from '../state/index.js';
 import buildAppRustCrates from '../utils/appRustCrates.js';
 
-// The archives of a final link (wasm, Node-API addon or native executable) and which of them must
+// The archives of a final link (wasm, Node-API addon, native executable or app host) and which of them must
 // survive whole. keepFlag spells "keep this symbol" for the target's linker; a native executable
-// binds nothing, so it links no bridge.
-export default function getLinkInputs(target, { keepFlag, withBridge = true }) {
+// binds nothing, so it links no bridge. An app host's bridges compile against another JSI, in an archive of their own.
+export default function getLinkInputs(target, { keepFlag, withBridge = true, bridge = 'Bridge' }) {
     const buildType = target.buildType === 'release' ? 'Release' : 'Debug';
     const { build, output, cache } = state.config.paths;
     const { name } = state.config.general;
 
     // buildLib's cache is keyed on paths.output/prebuilt; after a cache clean the
     // build-dir copy can be gone while the output artifact is still valid — link it then.
-    const sourceLibCandidates = [
-        `${build}/Source-${buildType}/${target.path}/lib${name}.a`,
-        `${output}/prebuilt/${target.path}/lib/lib${name}.a`,
+    // An Xcode build (iOS) leaves its archive in the install tree alone.
+    const builtLib = (prefix) => [
+        `${build}/${prefix}-${buildType}/${target.path}/lib${name}.a`,
+        `${build}/${prefix}-${buildType}/prebuilt/${target.path}/lib/lib${name}.a`,
     ];
+    const sourceLibCandidates = [...builtLib('Source'), `${output}/prebuilt/${target.path}/lib/lib${name}.a`];
+    const bridgeLibCandidates = builtLib(bridge);
     // App-local Rust surfaces (imported .rs files) arrive as ONE super staticlib; it is the
     // single fully-loaded Rust archive of the link (see the libstd rule below).
     const appRustLibs = buildAppRustCrates(target, cache, state.config.cargoDependencies ?? {});
@@ -24,7 +27,7 @@ export default function getLinkInputs(target, { keepFlag, withBridge = true }) {
         ...getDependLibs(target),
         ...appRustLibs,
         sourceLibCandidates.find((lib) => fs.existsSync(lib)) ?? sourceLibCandidates[0],
-        ...(withBridge ? [`${build}/Bridge-${buildType}/${target.path}/lib${name}.a`] : []),
+        ...(withBridge ? [bridgeLibCandidates.find((lib) => fs.existsSync(lib)) ?? bridgeLibCandidates[0]] : []),
     ];
 
     // By default only the Bridge archive is kept whole (see linkLayout.js) so the linker

package/src/actions/gradleProject.js

@@ -0,0 +1,110 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import state from '../state/index.js';
+import { ANDROID_API_LEVEL } from '../utils/androidToolchain.js';
+import { HERMES } from '../utils/hermes.js';
+import resolveAppHostRoot from '../utils/resolveAppHost.js';
+import { SIGNING } from './androidGradle.js';
+
+// The ABIs an Android app builds for: phones and Apple silicon's emulators, and the emulators of x86_64 machines.
+export const ANDROID_ABIS = ['arm64-v8a', 'x86_64'];
+// The Android release the app is compiled against and declares it was tested on.
+const TARGET_SDK = 36;
+export const ANDROIDX_WEBKIT = '1.17.1';
+
+const groovyString = (text) => `'${text.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+
+const buildGradle = ({ id, label, version, abis }) => `// crossbind writes this project anew on every build: the module comes prebuilt in src/main/jniLibs/, and the app's
+// files are in src/main/assets/app/.
+plugins {
+    id 'com.android.application'
+}
+
+android {
+    namespace 'dev.crossbind.app'
+    compileSdk ${TARGET_SDK}
+
+    defaultConfig {
+        applicationId ${groovyString(id)}
+        // The module's libraries are built against this API level.
+        minSdk ${ANDROID_API_LEVEL}
+        targetSdk ${TARGET_SDK}
+        versionCode ${version.code}
+        versionName ${groovyString(version.name)}
+        manifestPlaceholders = [appName: ${groovyString(label)}]
+        ndk {
+            abiFilters ${abis.map(groovyString).join(', ')}
+        }
+    }
+
+    // A release is signed with the upload key crossbind's environment names, else with the debug key.
+    signingConfigs {
+        release {
+            def keystore = System.getenv('${SIGNING.keystore}')
+            if (keystore) {
+                storeFile file(keystore)
+                storePassword System.getenv('${SIGNING.password}')
+                keyAlias System.getenv('${SIGNING.alias}')
+                keyPassword System.getenv('${SIGNING.keyPassword}') ?: System.getenv('${SIGNING.password}')
+            }
+        }
+    }
+
+    buildTypes {
+        release {
+            signingConfig System.getenv('${SIGNING.keystore}') ? signingConfigs.release : signingConfigs.debug
+        }
+    }
+
+    // Release builds skip lint's vital checks, whose tools crossbind's android-app image leaves out: the module's code is
+    // crossbind's own.
+    lint {
+        checkReleaseBuilds false
+    }
+
+    packaging {
+        jniLibs {
+            // Hermes brings fbjni, and with it an older libc++_shared.so; the module's is the NDK's it was built with.
+            pickFirsts += ['**/libc++_shared.so']
+            // The libraries come stripped, and stripping them again would take an NDK of the plugin's own.
+            keepDebugSymbols += ['**/*.so']
+        }
+    }
+
+    // The page keeps all its files, an _app directory or a .well-known one among them, which Android leaves out by default.
+    androidResources {
+        ignoreAssetsPattern = '!.svn:!.git:!.ds_store:!*.scc:!CVS:!thumbs.db:!picasa.ini:!*~'
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+}
+
+dependencies {
+    // Hermes' release build in every variant: it is the one the host links against.
+    implementation('com.facebook.hermes:hermes-android:${HERMES.version}') {
+        attributes {
+            attribute(com.android.build.api.attributes.BuildTypeAttr.ATTRIBUTE, objects.named(com.android.build.api.attributes.BuildTypeAttr, 'release'))
+        }
+    }
+    implementation 'androidx.webkit:webkit:${ANDROIDX_WEBKIT}'
+}
+`;
+
+// An Android app as a Gradle project, written anew from the parts its ABI targets built: each brings its libraries,
+// the first also the app's files. Gradle adds Hermes and androidx.webkit from Maven, and makes the APK or the bundle.
+export default function writeGradleProject(to, { parts, id, version }) {
+    const { name } = state.config.general;
+    if (parts.length === 0) throw new Error(`crossbind: no part of the Android app ${name} is built, so there is no Gradle project to write.`);
+    fs.rmSync(to, { recursive: true, force: true });
+    fs.cpSync(path.join(resolveAppHostRoot(), 'android'), to, { recursive: true });
+    const main = path.join(to, 'app', 'src', 'main');
+    parts.forEach(({ arch, dir }) => fs.cpSync(path.join(dir, 'lib'), path.join(main, 'jniLibs', arch), { recursive: true }));
+    fs.cpSync(path.join(parts[0].dir, 'app'), path.join(main, 'assets', 'app'), { recursive: true });
+    fs.writeFileSync(path.join(to, 'app', 'build.gradle'), buildGradle({
+        id, label: name, version, abis: parts.map(({ arch }) => arch),
+    }));
+    return to;
+}

package/src/actions/iosSimulator.js

@@ -0,0 +1,63 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { EXEC_MAX_BUFFER } from './run.js';
+import state from '../state/index.js';
+import logger from '../utils/logger.js';
+
+let hasToldNoWindow = false;
+
+function tool(program, args) {
+    const result = spawnSync(program, args, { encoding: 'utf8', maxBuffer: EXEC_MAX_BUFFER });
+    if (result.status !== 0) {
+        throw new Error(`crossbind: ${program} ${args.join(' ')} failed: ${`${result.stdout ?? ''}${result.stderr ?? ''}`.trim() || result.error?.message}`);
+    }
+    return result.stdout;
+}
+
+// Newer iOS first: 27.0 before 18.5.
+function byNewerIos(a, b) {
+    const index = a.version.findIndex((part, i) => part !== b.version[i]);
+    return index === -1 ? 0 : (b.version[index] ?? 0) - a.version[index];
+}
+
+// The Simulator an app opens in: one already booted, or else an iPhone of the newest iOS, booted for it.
+function simulator() {
+    const { devices } = JSON.parse(tool('xcrun', ['simctl', 'list', 'devices', 'available', '--json']));
+    const all = Object.entries(devices)
+        .filter(([runtime]) => runtime.includes('.SimRuntime.iOS-'))
+        .flatMap(([runtime, list]) => list.map((device) => ({ ...device, version: runtime.split('.SimRuntime.iOS-')[1].split('-').map(Number) })));
+    const booted = all.find((device) => device.state === 'Booted');
+    if (booted) return booted.udid;
+    const [newest] = all.filter((device) => device.name.startsWith('iPhone')).sort(byNewerIos);
+    if (!newest) throw new Error('crossbind: no iPhone Simulator is installed. Add the iOS platform in Xcode, under Settings > Components.');
+    tool('xcrun', ['simctl', 'boot', newest.udid]);
+    tool('xcrun', ['simctl', 'bootstatus', newest.udid, '-b']);
+    return newest.udid;
+}
+
+// Builds an iOS app's Xcode project for the Simulator, and returns the app.
+export function buildForSimulator(project, configuration = 'Release') {
+    const { name } = state.config.general;
+    const products = `${state.config.paths.build}/xcode`;
+    tool('xcodebuild', ['-project', `${project}/${name}.xcodeproj`, '-configuration', configuration, '-sdk', 'iphonesimulator',
+        `SYMROOT=${products}`, '-quiet', 'build']);
+    return `${products}/${configuration}-iphonesimulator/${name}.app`;
+}
+
+// Opens a Simulator build of an iOS app, with `env` in its environment. The process returned carries the app's output
+// and ends with the app; close() ends the app.
+export default function openInSimulator(app, { env = {}, show = false, stdio = 'pipe' } = {}) {
+    const device = simulator();
+    // Simulator.app only shows the device, which runs the app without it as well.
+    if (show && spawnSync('open', ['-b', 'com.apple.iphonesimulator']).status !== 0 && !hasToldNoWindow) {
+        hasToldNoWindow = true;
+        logger.info('crossbind: Simulator.app is not installed, so the Simulator shows no window; the app runs in it all the same.');
+    }
+    tool('xcrun', ['simctl', 'install', device, app]);
+    const bundleId = tool('plutil', ['-extract', 'CFBundleIdentifier', 'raw', '-o', '-', `${app}/Info.plist`]).trim();
+    const childEnv = { ...process.env };
+    Object.entries(env).forEach(([key, value]) => {
+        childEnv[`SIMCTL_CHILD_${key}`] = value;
+    });
+    const child = spawn('xcrun', ['simctl', 'launch', '--console-pty', '--terminate-running-process', device, bundleId], { env: childEnv, stdio });
+    return { child, close: () => spawnSync('xcrun', ['simctl', 'terminate', device, bundleId]) };
+}