crossbind 2.0.0-beta.63 → 2.0.0-beta.64

package/src/utils/bridgeExtras.js

@@ -4,14 +4,16 @@ import { parseMacroDump, stripComments, declaresAtFileScope } from './swigInterf
 // SWIG binds no function-like macro, variadic function or mutable global. crossbind binds them for the names an app
 // imports by name: a function-like macro takes the parameter types of the one function it calls, a macro naming a
 // function binds that function under its own name, a variadic function takes its extra arguments by their JavaScript
-// type, and a mutable global binds as a handle to its address. A macro binds only through a function SWIG bound, the
-// one place that proves the name is a single declared function.
+// type, a mutable global binds as a handle to its address, and a constant SWIG drops for a cast in its value binds as
+// the number the compiler makes of it. A macro binds only through a function SWIG bound, the one place that proves the
+// name is a single declared function.
 
 const C_IDENTIFIER = /^[A-Za-z_]\w*$/;
 const MACRO_LINE = /^\/\/ crossbind:macro ([A-Za-z_]\w*) (#define .*)$/gm;
 const ALIAS_LINE = /^\/\/ crossbind:alias ([A-Za-z_]\w*) ([A-Za-z_]\w*)$/gm;
+const CONSTANT_LINE = /^\/\/ crossbind:constant ([A-Za-z_]\w*)$/gm;
 const NOTE_MARKER = '// crossbind:note ';
-const EXTRA_LINES = /^(?:\/\/ crossbind:(?:macro|alias|note) .*\n)+\n/m;
+const EXTRA_LINES = /^(?:\/\/ crossbind:(?:macro|alias|constant|note) .*\n)+\n/m;
 // The arguments one call may add to a variadic function: each registration count dispatches over 2^n argument kinds.
 const MAX_VARIADIC_ARGUMENTS = 6;
 const VARIADIC_WARNING = /^Variable length arguments are not supported by embind, (\S+) skipped\.$/;
@@ -90,9 +92,66 @@ export function macroCall(macro) {
 // The identifier an object-like macro stands for, as in `#define iconv_open libiconv_open`.
 const identifierOf = (macro) => (macro && !macro.params && C_IDENTIFIER.test(macro.body) ? macro.body : null);
 
+const NUMBER_TYPE_WORDS = new Set(['unsigned', 'signed', 'short', 'long', 'int', 'char', 'float', 'double', 'bool', '_Bool']);
+const NUMBER_TYPEDEFS = new Set([
+    'size_t', 'ssize_t', 'ptrdiff_t', 'intptr_t', 'uintptr_t', 'intmax_t', 'uintmax_t', 'off_t', 'wchar_t',
+    'int8_t', 'uint8_t', 'int16_t', 'uint16_t', 'int32_t', 'uint32_t', 'int64_t', 'uint64_t',
+]);
+const VALUE_TOKEN = /0[xX][\dA-Fa-f]+[uUlL]*|\d+(?:\.\d*)?(?:[eE][-+]?\d+)?[uUlLfF]*|'(?:\\.|[^'\\])+'|[A-Za-z_]\w*|<<|>>|\S/g;
+const OPERATOR = /^(?:<<|>>|[-+*/%&|^~!()<>=?:])$/;
+const LITERAL = /^(?:\d|')/;
+const CAST_OPERAND = /^(?:\d|'|[-+~!(])/;
+
+// A type named by number words, a standard number typedef, or a typedef of one that the header declares.
+function isNumberType(words, headerText, depth = 0) {
+    if (words.every((word) => NUMBER_TYPE_WORDS.has(word))) return true;
+    if (words.length !== 1 || depth > 3) return false;
+    if (NUMBER_TYPEDEFS.has(words[0])) return true;
+    const declared = stripComments(headerText).match(new RegExp(`\\btypedef\\s+([A-Za-z_][\\w\\s]*?)\\s+${words[0]}\\s*;`));
+    return Boolean(declared) && isNumberType(declared[1].trim().split(/\s+/), headerText, depth + 1);
+}
+
+// The tokens of an object-like macro's value with the object-like macros in it spelled out; null for anything else.
+function expandedTokens(name, macros, depth = 0) {
+    const macro = macros.get(name);
+    if (!macro || macro.params || depth > 16) return null;
+    const tokens = [];
+    for (const token of macro.body.match(VALUE_TOKEN) ?? []) {
+        if (!C_IDENTIFIER.test(token) || !macros.has(token)) {
+            tokens.push(token);
+            continue;
+        }
+        const inner = expandedTokens(token, macros, depth + 1);
+        if (!inner) return null;
+        tokens.push('(', ...inner, ')');
+    }
+    return tokens;
+}
+
+// SWIG drops a #define whose value holds a name, so every cast. A value of numbers, operators and casts binds through
+// the compiler when every cast is to a number type: { numbers }, or null for a value with no cast or with other names.
+function castConstant(name, macros, headerText) {
+    const tokens = expandedTokens(name, macros);
+    if (!tokens) return null;
+    let casts = 0;
+    let numbers = true;
+    for (let at = 0; at < tokens.length; at += 1) {
+        if (LITERAL.test(tokens[at]) || OPERATOR.test(tokens[at])) continue;
+        const close = tokens.indexOf(')', at);
+        const words = tokens.slice(at, close);
+        const isCast = tokens[at - 1] === '(' && close > at && CAST_OPERAND.test(tokens[close + 1] ?? '')
+            && words.every((word) => word === '*' || C_IDENTIFIER.test(word));
+        if (!isCast) return null;
+        casts += 1;
+        numbers &&= !words.includes('*') && isNumberType(words, headerText);
+        at = close;
+    }
+    return casts ? { numbers } : null;
+}
+
 // What the interface carries for the names an app imports by name, read by the bridge once SWIG has run: their
 // function-like macros and their macros naming a function, and the functions they reach, which SWIG has to bind.
-export function interfaceExtras(names, macros) {
+export function interfaceExtras(names, macros, headerText = '') {
     if (names === ALL_NAMES || !names.length) return { lines: [], functions: [] };
     const lines = [];
     const functions = [];
@@ -104,6 +163,10 @@ export function interfaceExtras(names, macros) {
             if (target && target !== name && !macros.has(target) && !C_KEYWORDS.has(target)) {
                 lines.push(`// crossbind:alias ${name} ${target}`);
                 functions.push(target);
+            } else {
+                const constant = castConstant(name, macros, headerText);
+                if (constant?.numbers) lines.push(`// crossbind:constant ${name}`);
+                else if (constant) lines.push(`${NOTE_MARKER}${name}: a constant whose value has a cast binds only when every cast is to a number type the header declares; skipped.`);
             }
             continue;
         }
@@ -168,7 +231,8 @@ export function bridgeExtras({ interfaceText = '', named = [], bridgeText = '',
     const globalWarnings = warningsAbout(warnings, GLOBAL_WARNING, imported);
     const globals = [...globalWarnings.keys()].filter((name) => declaresAtFileScope(headerText, name));
     const answered = new Set([...variadics.map((name) => variadicWarnings.get(name)), ...globals.map((name) => globalWarnings.get(name))]);
-    if (!macros.length && !aliases.length && !variadics.length && !globals.length) return { code: '', exports: [], answered, notes };
+    const constants = [...interfaceText.matchAll(CONSTANT_LINE)].map(([, name]) => name).filter((name) => !bridgeText.includes(`bindConstant("${name}"`));
+    if (!macros.length && !aliases.length && !variadics.length && !globals.length && !constants.length) return { code: '', exports: [], answered, notes };
 
     // The macros register ahead of the fallbacks below, which would make a function a variadic shares its name with an
     // overload set.
@@ -184,10 +248,13 @@ export function bridgeExtras({ interfaceText = '', named = [], bridgeText = '',
         `EMSCRIPTEN_BINDINGS(CrossbindExtras_${module}) {`,
         ...variadics.map((name) => `  { using F = decltype(crossbind::variadicType(&${name}, 0)); crossbind::bindVariadic<F, static_cast<F>(&${name}), ${MAX_VARIADIC_ARGUMENTS}>("${name}"); }`),
         ...globals.map((name) => `  crossbind::bindGlobal("${name}", &${name});`),
+        ...constants.map((name) => `  crossbind::bindConstant("${name}", ${name});`),
         '}',
         '',
     ].join('\n');
-    const exports = [...macros.map(({ name }) => name), ...aliases.map(({ name }) => name), ...variadics, ...globals, ...(variadics.length ? ['vaDouble'] : [])];
+    const exports = [
+        ...macros.map(({ name }) => name), ...aliases.map(({ name }) => name), ...variadics, ...globals, ...constants, ...(variadics.length ? ['vaDouble'] : []),
+    ];
     return { code, exports, answered, notes };
 }
 
@@ -261,6 +328,7 @@ template<typename R> constexpr bool isJsResult = std::is_void_v<R> || isJsArgume
 template<typename T> auto argumentFromJs(const emscripten::val &value) {
   using U = std::remove_cv_t<T>;
   if constexpr (std::is_same_v<U, const char *>) return fromJsCString<const char>(value);
+  else if constexpr (isFunctionPointer<U>) return fromJsCallback<U>(value);
   else if constexpr (std::is_pointer_v<U>) return fieldFromJs<U>(value);
   else if constexpr (std::is_same_v<U, bool>) {
     double number = 0;

package/src/utils/cargoLock.js

@@ -0,0 +1,19 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import writeIfChanged from './writeIfChanged.js';
+
+// The versions of every crate the app's Rust links, next to crossbind.config.js and committed like conan.lock, since
+// the manifests cargo resolves are generated under the cache. Not Cargo.lock: a package whose crate sits at the
+// project root already has one.
+const lockOf = (projectDir) => path.join(projectDir, 'crossbind.cargo.lock');
+
+// Before cargo resolves a generated manifest, so it keeps every version the project pins.
+export function followCargoLock(projectDir, manifestDir) {
+    const lock = lockOf(projectDir);
+    if (fs.existsSync(lock)) writeIfChanged(path.join(manifestDir, 'Cargo.lock'), fs.readFileSync(lock, 'utf8'));
+}
+
+// After a build: what cargo resolved, a crate the lock did not list yet included.
+export function recordCargoLock(projectDir, manifestDir) {
+    writeIfChanged(lockOf(projectDir), fs.readFileSync(path.join(manifestDir, 'Cargo.lock'), 'utf8'));
+}

package/src/utils/cppDts.js

@@ -225,6 +225,8 @@ export function emitCppDts(model, exportNames, mode = 'sync') {
         for (const method of cls.methods) {
             out.push(`    ${method.isStatic ? 'static ' : ''}${method.name}(${method.args.map((a) => `${a.name}: ${a.type}`).join(', ')}): ${wrap(method.ret)};`);
         }
+        // Frees the object now instead of when the garbage collector reclaims the handle (lifecycle-and-types.md).
+        out.push(`    delete(): ${wrap('void')};`);
         out.push('}');
     }
     for (const name of exportNames) {

package/src/utils/embindObjectLifetime.js

@@ -0,0 +1,35 @@
+// embind frees an object when JavaScript's handle to it is collected only behind a smart pointer. A value a call
+// returns, which embind copied for JavaScript, and an object JavaScript made through a raw constructor (a vector, a
+// Rust class) were freed by .delete() alone, though they are as much JavaScript's own. This rewrite marks both on the
+// count a handle shares with its clones and gives them the same finalizer. A copy is known only where its converter
+// makes the handle, since embind then types the handle as a pointer to the object's own class. A raw pointer stays
+// its library's. The debug glue's leak warning goes: a collected handle is freed by design. Without
+// FinalizationRegistry (Hermes) nothing is registered, as before.
+
+// The release glue spells each on one line, the debug glue one statement per line with comments.
+const FINALIZER = /if\s*\(hasSmartPtr\)\s*\{[\s\S]*?finalizationRegistry\.register\(handle,\s*info,\s*handle\);?/;
+const OWNED_FINALIZER = 'if(hasSmartPtr||$$.count.owned){finalizationRegistry.register(handle,{$$},handle);';
+const LEAK_WARNING = /console\.warn\(info\.leakWarning\);?\s*/;
+const FROM_WIRE = /function RegisteredPointer_fromWireType\(ptr\)\s*\{/g;
+const OWN_FROM_WIRE = 'function crossbindOwnHandle(handle){var $$=handle.$$;if(!$$.smartPtr&&!$$.count.owned){$$.count.owned=true;'
+    + 'if(finalizationRegistry)finalizationRegistry.register(handle,{$$},handle)}return handle}'
+    + 'function RegisteredPointer_fromWireType(ptr){var handle=crossbindHandleFromWire.call(this,ptr);'
+    + 'return this.isReference&&handle?crossbindOwnHandle(handle):handle}'
+    + 'function crossbindHandleFromWire(ptr){';
+const CONSTRUCTED = /return body\.apply\(this,\s*args\);?/g;
+const OWN_CONSTRUCTED = 'return crossbindOwnHandle(body.apply(this,args));';
+
+const count = (text, pattern) => text.match(pattern)?.length ?? 0;
+
+// Returns the rewritten glue and whether it holds embind classes this rewrite does not recognise.
+export function releaseOwnedHandles(glue) {
+    if (!glue.includes('attachFinalizer')) return { text: glue, missed: false };
+    const recognised = count(glue, FROM_WIRE) === 1 && count(glue, CONSTRUCTED) === 1;
+    // Functions, not strings: `$$` in a replacement string is a lone `$`.
+    const text = glue
+        .replace(FINALIZER, () => OWNED_FINALIZER)
+        .replace(LEAK_WARNING, '')
+        .replace(FROM_WIRE, () => OWN_FROM_WIRE)
+        .replace(CONSTRUCTED, () => OWN_CONSTRUCTED);
+    return { text, missed: !recognised || !text.includes(OWNED_FINALIZER) };
+}

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/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/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/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/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',
     },
@@ -192,6 +198,11 @@ 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 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}`,
+    ];
+}