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

package/src/utils/packageLicense.js

@@ -74,9 +74,11 @@ export function nodePackageLicense({ name, version, repository, projectPath, add
 
 export function setManifestLicense(dir, expression) {
     const file = path.join(dir, 'package.json');
-    const manifest = JSON.parse(fs.readFileSync(file, 'utf8'));
+    const text = fs.readFileSync(file, 'utf8');
+    const manifest = JSON.parse(text);
     if (manifest.license === expression) return;
-    fs.writeFileSync(file, `${JSON.stringify({ ...manifest, license: expression }, null, 4)}\n`);
+    const indent = text.match(/^[ \t]+(?=")/m)?.[0] ?? 4;
+    fs.writeFileSync(file, `${JSON.stringify({ ...manifest, license: expression }, null, indent)}\n`);
 }
 
 export function writeNodePackageLicense(dir, meta) {

package/src/utils/plist.js

@@ -0,0 +1,42 @@
+// Property lists as Apple's tools read them: XML for an Info.plist, the older text form for an Xcode project.
+
+const XML_INDENT = '    ';
+const escapeXml = (text) => String(text).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+
+function xmlLines(value, indent) {
+    if (typeof value === 'boolean') return [`${indent}<${value}/>`];
+    const inner = indent + XML_INDENT;
+    if (Array.isArray(value)) return [`${indent}<array>`, ...value.flatMap((item) => xmlLines(item, inner)), `${indent}</array>`];
+    if (typeof value === 'object') {
+        const entries = Object.entries(value);
+        if (entries.length === 0) return [`${indent}<dict/>`];
+        return [
+            `${indent}<dict>`,
+            ...entries.flatMap(([key, item]) => [`${inner}<key>${escapeXml(key)}</key>`, ...xmlLines(item, inner)]),
+            `${indent}</dict>`,
+        ];
+    }
+    return [`${indent}<string>${escapeXml(value)}</string>`];
+}
+
+export function xmlPlist(dict) {
+    return '<?xml version="1.0" encoding="UTF-8"?>\n'
+        + '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n'
+        + `<plist version="1.0">\n${xmlLines(dict, '').join('\n')}\n</plist>\n`;
+}
+
+// Every value of the text form is a string, quoted here whatever it holds.
+const quote = (text) => `"${String(text).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+
+function textValue(value, indent) {
+    const inner = `${indent}\t`;
+    if (Array.isArray(value)) return `(\n${value.map((item) => `${inner}${textValue(item, inner)},\n`).join('')}${indent})`;
+    if (typeof value === 'object') {
+        return `{\n${Object.entries(value).map(([key, item]) => `${inner}${quote(key)} = ${textValue(item, inner)};\n`).join('')}${indent}}`;
+    }
+    return quote(value);
+}
+
+export function textPlist(root) {
+    return `// !$*UTF8*$!\n${textValue(root, '')}\n`;
+}

package/src/utils/pullDockerImage.js

@@ -8,7 +8,11 @@ const table = createRequire(import.meta.url)('../assets/toolchain-digests.json')
 const REGISTRY = table.registry;
 const IMAGE_VERSION = table.version;
 const OVERRIDE_KEYS = {
-    web: 'CROSSBIND_IMAGE_WEB', android: 'CROSSBIND_IMAGE_ANDROID', linux: 'CROSSBIND_IMAGE_LINUX', windows: 'CROSSBIND_IMAGE_WINDOWS',
+    web: 'CROSSBIND_IMAGE_WEB',
+    android: 'CROSSBIND_IMAGE_ANDROID',
+    'android-app': 'CROSSBIND_IMAGE_ANDROID_APP',
+    linux: 'CROSSBIND_IMAGE_LINUX',
+    windows: 'CROSSBIND_IMAGE_WINDOWS',
 };
 const IMAGES = Object.fromEntries(
     Object.keys(OVERRIDE_KEYS).map((role) => [
@@ -21,9 +25,11 @@ const IMAGES = Object.fromEntries(
 );
 
 // Which image a target compiles in: wasm and wasi share the web image, linux and linuxmusl the linux
-// image, ios and darwin never reach docker.
+// image, ios and darwin never reach docker. An Android app builds in android-app, the android image with
+// what packages the app.
 export function imageRoleFor(target) {
-    if (target?.platform === 'android' || target?.platform === 'linux') return target.platform;
+    if (target?.platform === 'android') return target.runtimeEnv === 'app' ? 'android-app' : 'android';
+    if (target?.platform === 'linux') return 'linux';
     if (target?.platform === 'linuxmusl') return 'linux';
     if (target?.platform === 'win32') return 'windows';
     return 'web';

package/src/utils/replaceBasePathForDocker.js

@@ -1,5 +1,13 @@
+import path from 'node:path';
+
 export const DOCKER_BASE = '/tmp/crossbind/live';
 
+// Whether a container, which sees the project's base alone, sees dir.
+export function isUnderBase(dir, basePath) {
+    const relative = path.relative(basePath, path.resolve(dir));
+    return !/^\.\.(?:[\\/]|$)/.test(relative) && !path.isAbsolute(relative);
+}
+
 export default function replaceBasePathForDocker(data, basePath) {
     if (typeof data === 'string' || data instanceof String) {
         return data.replaceAll(basePath, DOCKER_BASE);

package/src/utils/resetCMakeCacheForSource.js

@@ -0,0 +1,26 @@
+import fs from 'node:fs';
+import state from '../state/index.js';
+import replaceBasePathForDocker from './replaceBasePathForDocker.js';
+import { isLocalRunner } from './selectRunner.js';
+import { HOST_BUILT_PLATFORMS } from './targets.js';
+
+const normalize = (dir) => dir.replaceAll('\\', '/').replace(/\/+$/, '');
+
+// The directory as the cmake run() starts sees it: a container, Docker or a remote runner, has the project at
+// DOCKER_BASE; macOS and iOS builds and the LOCAL runner see this machine's paths.
+function seenByCMake(dir, target) {
+    const isLocal = HOST_BUILT_PLATFORMS.includes(target.platform) || isLocalRunner(state.config.system);
+    return isLocal ? dir : replaceBasePathForDocker(dir, state.config.paths.base);
+}
+
+// A CMake build tree remembers the source directory it was configured from and refuses another one. The CMake
+// projects crossbind ships move with its version (node_modules/.pnpm/crossbind@<version>/...), so a tree configured
+// from another directory starts afresh, as `cmake --fresh` would.
+export default function resetCMakeCacheForSource(buildPath, sourceDir, target) {
+    const cache = `${buildPath}/CMakeCache.txt`;
+    if (!fs.existsSync(cache)) return;
+    const configuredFrom = fs.readFileSync(cache, 'utf8').match(/^CMAKE_HOME_DIRECTORY:INTERNAL=(.*)$/m)?.[1];
+    if (configuredFrom !== undefined && normalize(configuredFrom) === normalize(seenByCMake(sourceDir, target))) return;
+    fs.rmSync(cache, { force: true });
+    fs.rmSync(`${buildPath}/CMakeFiles`, { recursive: true, force: true });
+}

package/src/utils/resolveAppHost.js

@@ -0,0 +1,21 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import createCompanionResolver from './resolveCompanionPackage.js';
+
+const PKG = '@crossbind/core-app-host';
+
+const resolveAppHostRoot = createCompanionResolver({
+    pkg: PKG,
+    siblingDir: 'app-host',
+    siblingMarker: 'cpp/src/main.cpp',
+    missingMessage: `crossbind: apps need ${PKG} - add it to your devDependencies.`,
+});
+
+export default resolveAppHostRoot;
+
+// The embind runtime ships in @crossbind/core-embind-jsi, a dependency of the app host package.
+export function resolveAppEmbindJsiRoot() {
+    const req = createRequire(path.join(resolveAppHostRoot(), 'package.json'));
+    return path.dirname(fs.realpathSync(req.resolve('@crossbind/core-embind-jsi/package.json')));
+}

package/src/utils/rustBridgeGen.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { followCargoLock } from './cargoLock.js';
 import resolveEmbindRustRoot, { embindRustVersion } from './resolveEmbindRust.js';
 import runCargo, { toHostPath } from './runCargo.js';
 import writeIfChanged from './writeIfChanged.js';
@@ -303,7 +304,9 @@ export function createRustBridgeCrate({ rsFile, cacheDir, projectPath, vectors =
 // through the root and through a module registers once and is the same JS class for both.
 const crateSourceCache = new Map();
 const crateModelCache = new Map();
-export function createCrateImportBridge({ crateName, modulePath = [], spec, cacheDir, dtsMode = 'sync', log = console.log }) {
+export function createCrateImportBridge({
+    crateName, modulePath = [], spec, cacheDir, projectDir, dtsMode = 'sync', log = console.log,
+}) {
     const importName = [crateName, ...modulePath].join('/');
     const crateIdent = crateName.replaceAll('-', '_');
     const stem = `crate_${crateName.replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase()}`;
@@ -343,7 +346,9 @@ export function createCrateImportBridge({ crateName, modulePath = [], spec, cach
     // cargo metadata needs a resolvable lib target before the real bridge exists.
     if (!fs.existsSync(`${dir}/src/lib.rs`)) writeIfChanged(`${dir}/src/lib.rs`, '// crossbind placeholder\n');
 
-    const { srcDir, features } = crateSource({ dir, depLine, crateName, importName });
+    const { srcDir, features } = crateSource({
+        dir, depLine, crateName, importName, projectDir,
+    });
     const ownKey = modulePath.join('::');
     const imports = [];
     for (const importPath of crateImports(cacheDir, crateName, modulePath)) {
@@ -385,10 +390,14 @@ export function createCrateImportBridge({ crateName, modulePath = [], spec, cach
 }
 
 // cargo metadata locates the crate's source and the feature set it resolves to (fetching the crate
-// on first use); both hold for every import of the crate.
-function crateSource({ dir, depLine, crateName, importName }) {
+// on first use); both hold for every import of the crate. It resolves with the project's pins, so
+// the bridge is made from the version the app links.
+function crateSource({
+    dir, depLine, crateName, importName, projectDir,
+}) {
     const cacheKey = `${dir}|${depLine}`;
     if (crateSourceCache.has(cacheKey)) return crateSourceCache.get(cacheKey);
+    followCargoLock(projectDir, dir);
     let meta;
     try {
         const probe = runCargo(['metadata', '--format-version', '1', '--manifest-path', `${dir}/Cargo.toml`], {

package/src/utils/rustMt.js

@@ -1,4 +1,5 @@
 import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
 import path from 'node:path';
 
 // One argv per flag: runCargo joins these with cargo's 0x1F separator, so a flag must not
@@ -39,6 +40,10 @@ export function cargoTargetDirFor(baseDir, target) {
 // points at whatever version that image pinned, so the CLI carries no version of its own.
 const CONTAINER_SYSROOT = '/opt/crossbind/rust/current';
 
+// True only inside the toolchain image. A CLI running there with RUNNER=LOCAL (the playground
+// compiler) has these trees, but not rustup's stock wasm target.
+export const hasContainerSysroot = () => fs.existsSync(CONTAINER_SYSROOT);
+
 export function cargoBuildInvocation({
     target, triple, targetDir, manifestPath, sysroot = false,
 }) {

package/src/utils/rustSysroot.js

@@ -5,7 +5,7 @@ import { spawnSync } from 'node:child_process';
 import withDirLock from './dirLock.js';
 import fetchOciLayer from './ociArtifact.js';
 import { cargoRunner } from './runCargo.js';
-import { isMtWasm } from './rustMt.js';
+import { hasContainerSysroot, isMtWasm } from './rustMt.js';
 import PIN from './rustSysrootPin.js';
 
 // The second consumption channel for the Rust sysroots. A containerized build gets them as an image
@@ -149,7 +149,7 @@ let resolved = null;
 // Called from buildDependencies, the one async step every build path awaits before the sync work
 // starts. Only downloads when a target will actually consume it.
 export async function prepareRustSysroot(targets, log = console.log) {
-    if (resolved || !PIN) return resolved;
+    if (resolved || !PIN || hasContainerSysroot()) return resolved;
     if (!targets.some((target) => isMtWasm(target) && cargoRunner(target) === 'LOCAL')) return null;
     try {
         resolved = await ensureRustSysroot({ image: PIN.image, index: PIN.index });
@@ -161,11 +161,13 @@ export async function prepareRustSysroot(targets, log = console.log) {
     return resolved;
 }
 
-// What cargoBuildInvocation takes for `sysroot`: true where the image carries the trees, an
-// absolute path where a downloaded artifact answers, false where mt must rebuild std on nightly.
-// st needs nothing - rustup's stock std is already correct for it.
+// What cargoBuildInvocation takes for `sysroot`: true where the image carries the trees (also a
+// LOCAL build running inside the image), an absolute path where a downloaded artifact answers,
+// false where mt must rebuild std on nightly. st needs nothing - rustup's stock std is already
+// correct for it.
 export function sysrootFor(target) {
     if (cargoRunner(target) !== 'LOCAL') return true;
+    if (target.platform === 'wasm' && hasContainerSysroot()) return true;
     if (!isMtWasm(target)) return false;
     return resolved ?? false;
 }

package/src/utils/selectRunner.js

@@ -7,7 +7,7 @@ const SYSTEM_CONFIG = '~/.crossbind.json';
 const SHARED = { key: 'REMOTE_URL', url: 'CROSSBIND_REMOTE_URL', token: 'CROSSBIND_TOKEN' };
 
 export const remoteVariables = (role) => {
-    const suffix = `_${role.toUpperCase()}`;
+    const suffix = `_${role.toUpperCase().replaceAll('-', '_')}`;
     return { key: `${SHARED.key}${suffix}`, url: `${SHARED.url}${suffix}`, token: `${SHARED.token}${suffix}` };
 };
 

package/src/utils/swigInterface.js

@@ -75,8 +75,9 @@ export function buildInterfaceContent({
     // The marker keeps a preamble that starts with #define apart from the macro block the retry drops.
     const preambleBlock = preamble.length ? `// package preamble\n${preamble.join('\n')}\n\n` : '';
     const extraBlock = extras.length ? `${extras.join('\n')}\n\n` : '';
-    // Named constants are asked for ahead of the macros, which may define one. Every constant is asked for after them:
-    // SWIG binds an interface's own #define lines, and the prelude only carries other headers' values for the parse.
+    // Named constants and functions are asked for ahead of the macros, which may define an imported name. Every constant
+    // is asked for after them: SWIG binds an interface's own #define lines, and the prelude only carries other headers'
+    // values for the parse.
     const everyConstant = constants === ALL_NAMES;
     const module = moduleName.replace(/\W/g, '_');
     return `#ifndef _${module}_I
@@ -88,10 +89,10 @@ ${extraBlock}%{
 ${includes}
 %}
 
-${everyConstant ? '' : constantRequests(constants)}%feature("shared_ptr");
+${everyConstant ? '' : constantRequests(constants)}${functionRequests(functions)}%feature("shared_ptr");
 %feature("polymorphic_shared_ptr");
 
-${macros}${functionRequests(functions)}${ignores}${preambleBlock}${everyConstant ? constantRequests(constants) : ''}%include "${headerPath}"
+${macros}${ignores}${preambleBlock}${everyConstant ? constantRequests(constants) : ''}%include "${headerPath}"
 
 #endif
 `;

package/src/utils/systemConfig.js

@@ -0,0 +1,13 @@
+import os from 'node:os';
+import loadJson from './loadJson.js';
+import systemKeys from './systemKeys.js';
+
+export const systemConfigPath = () => `${os.homedir()}/.crossbind.json`;
+
+export default function loadSystemConfig() {
+    const system = loadJson(systemConfigPath()) || {};
+    const defaults = Object.entries(systemKeys)
+        .filter(([key]) => !(key in system))
+        .map(([key, value]) => [key, value.default]);
+    return { ...system, ...Object.fromEntries(defaults) };
+}

package/src/utils/systemKeys.js

@@ -48,6 +48,10 @@ const systemKeys = {
         description: 'Image reference used for android builds instead of the pinned one. A reference without the release digest disables the reproducibility guarantee. The CROSSBIND_IMAGE_ANDROID environment variable overrides it.',
         default: '',
     },
+    DOCKER_IMAGE_ANDROID_APP: {
+        description: 'Image reference used for Android apps instead of the pinned one. A reference without the release digest disables the reproducibility guarantee. The CROSSBIND_IMAGE_ANDROID_APP environment variable overrides it.',
+        default: '',
+    },
     DOCKER_IMAGE_LINUX: {
         description: 'Image reference used for linux (Node.js addon) builds instead of the pinned one. A reference without the release digest disables the reproducibility guarantee. The CROSSBIND_IMAGE_LINUX environment variable overrides it.',
         default: '',

package/src/utils/targets.js

@@ -68,6 +68,12 @@ const BASE_TARGETS = [
     {
         platform: 'wasi', arch: 'wasm32', runtime: 'st', buildType: 'debug', runtimeEnv: 'wasi',
     },
+    {
+        platform: 'wasi', arch: 'wasm32', runtime: 'st', buildType: 'release', runtimeEnv: 'http',
+    },
+    {
+        platform: 'wasi', arch: 'wasm32', runtime: 'st', buildType: 'debug', runtimeEnv: 'http',
+    },
     {
         platform: 'android', arch: 'arm64-v8a', runtime: 'mt', buildType: 'release',
     },
@@ -142,12 +148,17 @@ const BASE_TARGETS = [
     },
 ];
 
-// A native executable links the same archives as the Node-API addon of its platform and arch.
+// A native executable links the same archives as the Node-API addon of its platform and arch, and so does an app's
+// host on macOS, glibc Linux and Windows. An iOS or Android app links the archives React Native does, one target per
+// SDK or ABI.
 export const TARGETS = [
     ...BASE_TARGETS,
     ...BASE_TARGETS
         .filter((target) => target.runtimeEnv === 'node' && target.platform !== 'wasm')
         .map((target) => ({ ...target, runtimeEnv: 'native' })),
+    ...BASE_TARGETS
+        .filter((target) => (target.runtimeEnv === 'node' && ['darwin', 'linux', 'win32'].includes(target.platform)) || ['ios', 'android'].includes(target.platform))
+        .map((target) => ({ ...target, runtimeEnv: 'app' })),
 ];
 
 // Built only when named with -p: a plain `crossbind build` keeps producing what it did before
@@ -157,8 +168,8 @@ export const OPT_IN_PLATFORMS = ['darwin', 'linux', 'linuxmusl', 'win32'];
 // Built on the host itself: Apple's linker and SDKs exist in no toolchain image.
 export const HOST_BUILT_PLATFORMS = ['ios', 'darwin'];
 
-// The runtime environment names the binary a build makes; android and ios have none, since
-// React Native links them.
+// The runtime environment names the binary a build makes; on android and ios React Native links
+// the archives, and the app is the one binary.
 export const runtimeEnvsOf = (platform) => [
     ...new Set(TARGETS.filter((target) => target.platform === platform && target.runtimeEnv).map((target) => target.runtimeEnv)),
 ];
@@ -192,6 +203,22 @@ export function nodeAddonNamesOf(target, projectName) {
     };
 }
 
+// A wasi build is one component, with no JS glue: the command keeps the plain name, an http component adds its own.
+export const wasiNamesOf = (target, projectName) => ({
+    wasmName: `${projectName}-${targetPathOf(target)}${target.runtimeEnv === 'http' ? '.http' : ''}.wasm`,
+});
+
+// One app per platform, arch and build type, and one page runtime per build type for all of them. A macOS app is a
+// bundle; a Linux app a directory; an iOS or Android one what its SDK or ABI brings to the app's Xcode or Gradle
+// project.
+export function appNamesOf(target, projectName) {
+    const suffix = target.buildType === 'debug' ? '.debug' : '';
+    return {
+        appName: `${projectName}.${target.platform}-${target.arch}${suffix}${target.platform === 'darwin' ? '.app' : ''}`,
+        appJsName: `${projectName}.app${suffix}.js`,
+    };
+}
+
 // One executable per platform, arch and build type, named like the addons it replaces.
 export function nativeCommandNamesOf(target, projectName) {
     const suffix = target.buildType === 'debug' ? '.debug' : '';

package/src/utils/wasiHttp.js

@@ -0,0 +1,50 @@
+// The runtime of an http build: crossbind's wasi:http/handler export, which calls the app's
+// crossbind::http::handle, and the bindings wit-bindgen generated for it (assets/wasi-runtime/http/README.md).
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+const RUNTIME = 'assets/wasi-runtime/http';
+// The stack of each request: wasi-libc mallocs one per concurrent request, with no guard below it.
+const STACK_SIZE = 1024 * 1024;
+const HEADER = 'include/crossbind/http.h';
+const LINKED = [
+    'handler.cpp',
+    'bindings/crossbind_http.c',
+    'bindings/crossbind_http.h',
+    'bindings/crossbind_http_component_type.o',
+    HEADER,
+];
+
+// paths.cli can lie outside the docker mount, so the files are copied into the build tree first.
+function stage(cliPath, dir, files) {
+    files.forEach((file) => {
+        fs.mkdirSync(path.dirname(`${dir}/${file}`), { recursive: true });
+        fs.copyFileSync(`${cliPath}/${RUNTIME}/${file}`, `${dir}/${file}`);
+    });
+}
+
+export const wasiHttpFiles = (cliPath) => LINKED.map((file) => `${cliPath}/${RUNTIME}/${file}`);
+
+export const wasiHttpHeader = (cliPath) => `${cliPath}/${RUNTIME}/${HEADER}`;
+
+// The include dir of a wasi source build, where the app's handler finds <crossbind/http.h>.
+export function stageWasiHttpInclude(cliPath, dir) {
+    stage(cliPath, dir, [HEADER]);
+    return `${dir}/include`;
+}
+
+// What an http link adds to a command's: the handler export, its bindings (C, hence -x c) with the world
+// they implement, the reactor model, which has no main, and a stack as large as the wasm builds'.
+export function stageWasiHttpLink(cliPath, dir) {
+    stage(cliPath, dir, LINKED);
+    return [
+        `-I${dir}/include`,
+        `-I${dir}/bindings`,
+        `${dir}/handler.cpp`,
+        '-x', 'c', `${dir}/bindings/crossbind_http.c`, '-x', 'none',
+        `${dir}/bindings/crossbind_http_component_type.o`,
+        '-mexec-model=reactor',
+        `-Wl,-z,stack-size=${STACK_SIZE}`,
+    ];
+}

package/vitest.config.js

@@ -1,6 +1,11 @@
+import { fileURLToPath } from 'node:url';
 import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
+    // The app host package's scripts import crossbind's runtime modules the way buildApp bundles them.
+    resolve: {
+        alias: [{ find: /^crossbind\/runtime\//, replacement: fileURLToPath(new URL('./src/assets/js-runtime/', import.meta.url)) }],
+    },
     // loadJs/loadConfig dynamically import config files written to os.tmpdir()
     // during tests. Vite 6 tightened server.fs.allow and rejects those out-of-root
     // paths ("Does the file exist?"); relax the fs check for the test runner.