crossbind 2.0.0-beta.62 → 2.0.0-beta.64

package/AGENTS.md

@@ -4,7 +4,8 @@
 
 ## What lives here
 
-- `src/bin.js` — `crossbind` CLI entry; commander commands, target filtering and top-level orchestration.
+- `src/cli.js` — `crossbind` CLI entry: `login`, `logout`, `usage`, `account`, `config` and `--version` run from `src/program.js` without loading a project (only `config list -t all|project` loads it); every other command goes to `src/bin.js`.
+- `src/bin.js` — the commands that need a project; commander commands, target filtering and top-level orchestration.
 - `src/index.js` — public API barrel re-exported as the `crossbind` npm package (`createLib`, `buildWasm`, `state`, `getData`, `isSourceNewer`, …).
 - `src/actions/` — the actual build steps. **Most edits land here.**
 - `src/state/` — config loading + target matrix.

package/README.md

@@ -255,7 +255,7 @@ OpenSSL · PROJ · SpatiaLite · SQLite · libTIFF · WebP · zlib · Zstandard*
 
 Each family has target-specific packages. For example, a browser or Node.js
 project uses `@crossbind/port-gdal-wasm`, while mobile, native Node.js addon and
-WASI builds use the matching `-android`, `-ios`, `-darwin`, `-linux`, `-win32`,
+WASI builds use the matching `-android`, `-ios`, `-darwin`, `-linux`, `-linuxmusl`, `-win32`,
 or `-wasi` variant. Import the variant's `crossbind.config.js` into the
 application's dependency list:
 
@@ -285,7 +285,7 @@ Some upstream command-line tools are also published as WASI-powered npm
 commands. They require `wasmtime` on `PATH`, but no compiler:
 
 ```bash
-npm install --global @crossbind/port-gdal-bin-wasi@beta
+npm install --global @crossbind/port-gdal-standalone-wasi@beta
 gdalinfo-wasi --version
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "crossbind",
-    "version": "2.0.0-beta.62",
+    "version": "2.0.0-beta.64",
     "license": "MIT",
     "homepage": "https://crossbind.dev",
     "repository": "https://github.com/crossbind/crossbind.git",
@@ -10,9 +10,14 @@
         "node": ">=24"
     },
     "bin": {
-        "crossbind": "./src/bin.js"
+        "crossbind": "./src/cli.js"
     },
     "main": "src/index.js",
+    "exports": {
+        ".": "./src/index.js",
+        "./node/dev": "./src/node/dev.mjs",
+        "./*": "./*"
+    },
     "scripts": {
         "test": "vitest run",
         "test:watch": "vitest",

package/src/actions/buildDependencies.js

@@ -14,6 +14,7 @@ import {
 } from '../utils/dependencyRebuild.js';
 import withDirLock from '../utils/dirLock.js';
 import { prepareRustSysroot } from '../utils/rustSysroot.js';
+import prepareConanDependencies from './prepareConanDependencies.js';
 import getAbsolutePath from '../utils/getAbsolutePath.js';
 import getCMakeListsFilePath from '../utils/getCMakeListsFilePath.js';
 import getParentPath from '../utils/getParentPath.js';
@@ -25,6 +26,7 @@ export default async function buildDependencies({ targetParams, rebuildOption })
     // sync cargo work downstream reads what it resolves. A project with nothing to rebuild still
     // needs its sysroot.
     await prepareRustSysroot(getBuildTargets(targetParams));
+    await prepareConanDependencies(getBuildTargets(targetParams));
     await buildMissingCargoDependencies(getBuildTargets(targetParams), targetParams);
 
     const rebuildDeps = getRebuildDeps(state.config.allDependencies, rebuildOption);
@@ -59,6 +61,11 @@ export default async function buildDependencies({ targetParams, rebuildOption })
     }
 }
 
+const isWasm = (target) => target.platform === 'wasm';
+const paramsOf = (target) => ({
+    platform: [target.platform], arch: [target.arch], runtime: [target.runtime], buildType: [target.buildType], runtimeEnv: [target.runtimeEnv],
+});
+
 // A cargo dependency carries every target in ONE package, so unlike a platform-split port there
 // is no "this sibling isn't for this target" case: a missing prebuilt means it was never built.
 // Nothing else builds these packages - buildDependencies only rebuilds deps that carry a source
@@ -66,11 +73,16 @@ export default async function buildDependencies({ targetParams, rebuildOption })
 // pre-build step nobody had written down. Worse, only the cmake link asserts the dependency is
 // there: on wasm a missing one silently drops out and the module builds clean, then dies at init.
 // Build it here instead, in the dependency's own package, where its prebuilt belongs.
-async function buildMissingCargoDependencies(targets, targetParams) {
-    if (targets.length === 0) return;
+async function buildMissingCargoDependencies(buildTargets, targetParams) {
+    if (buildTargets.length === 0) return;
     const appConfig = state.config;
     const cargoDependencies = (appConfig.allDependencies ?? []).filter((dep) => dep !== appConfig && dep.export?.type === 'cargo');
     if (cargoDependencies.length === 0) return;
+    // Bridges read every header for the first wasm target (see prepareConanDependencies), which an app configured for
+    // another wasm runtime does not build: there a dependency built for the app's runtime alone counts as half built.
+    const bridgeTarget = buildTargets.some(isWasm) ? state.targets.find(isWasm) : undefined;
+    const extraTarget = bridgeTarget && !buildTargets.some((target) => target.path === bridgeTarget.path) ? bridgeTarget : undefined;
+    const targets = extraTarget ? [...buildTargets, extraTarget] : buildTargets;
     // A prebuilt from another embind-rs counts as missing: linked, it carries stale glue or clashes with the others.
     const fingerprint = getEmbindRsFingerprint();
     const prebuiltOf = (dep, target) => [target.path, target.releasePath]
@@ -91,6 +103,7 @@ async function buildMissingCargoDependencies(targets, targetParams) {
             state.config = scoped;
             try {
                 buildLib(targetParams);
+                if (extraTarget) buildLib(paramsOf(extraTarget));
             } finally {
                 state.config = prev;
             }

package/src/actions/buildExternal.js

@@ -1,10 +1,12 @@
 import fs from 'node:fs';
 import replace from 'replace';
 import downloadAndExtractFile from '../utils/downloadAndExtractFile.js';
+import copyToDistSource from '../utils/copyToDistSource.js';
 import { getBuildTargets } from './target.js';
 import state from '../state/index.js';
 import buildLib from './buildLib.js';
 import buildBinTools from './buildBinTools.js';
+import { copyBundledLicenses } from '../utils/bundledLicenses.js';
 
 export default async function buildExternal(targetParams, options = {}) {
     const version = state.config.package.nativeVersion;
@@ -31,6 +33,12 @@ export default async function buildExternal(targetParams, options = {}) {
 
     buildLib(targetParams, options);
 
+    const { bundled } = state.config.build;
+    if (bundled) {
+        new Set(getBuildTargets(targetParams).map((target) => target.platform))
+            .forEach((platform) => copyBundledLicenses(bundled[platform], sourcePath, state.config.paths.output));
+    }
+
     if (state.config.build.bin) {
         await buildBinTools(targetParams);
     }
@@ -48,7 +56,7 @@ export default async function buildExternal(targetParams, options = {}) {
                 targets.forEach(target => {
                     const assetPath = `${state.config.paths.output}/prebuilt/${target.path}/${v}`;
                     if (!fs.existsSync(assetPath)) {
-                        fs.copyFileSync(`${state.config.paths.project}/${key}`, assetPath);
+                        fs.copyFileSync(copyToDistSource(state.config.paths.project, key), assetPath);
                     }
                 });
             });

package/src/actions/buildJs.js

@@ -5,7 +5,7 @@ import { nodeResolve } from '@rollup/plugin-node-resolve';
 import commonjs from '@rollup/plugin-commonjs';
 import virtual from '@rollup/plugin-virtual';
 import state from '../state/index.js';
-import getData from './getData.js';
+import getEnv from './getEnv.js';
 
 const SUPPRESSED_WARN_CODES = new Set([
     'MISSING_GLOBAL_NAME',
@@ -53,14 +53,7 @@ options.edge = options.browser;
 
 export default async function buildJS(target) {
     const entryJS = `${state.config.paths.cli}/assets/js-runtime/${target.runtimeEnv}.js`;
-    const rawEnv = getData('env', target);
-    const resolvedEnv = Object.fromEntries(
-        Object.entries(rawEnv).map(([key, value]) => [
-            key,
-            typeof value === 'function' ? value(state, target) : value,
-        ]),
-    );
-    const env = JSON.stringify(resolvedEnv);
+    const env = JSON.stringify(getEnv(target));
     const systemConfig = `export default {
         env: ${env},
         useWorker: !!globalThis.Worker,

package/src/actions/buildLib.js

@@ -8,6 +8,9 @@ import logger from '../utils/logger.js';
 import findFiles from '../utils/findFiles.js';
 import { getSourceFingerprint, isSourceFingerprintStale, staleTargetDirectories, writeSourceFingerprint } from '../utils/sourceFingerprint.js';
 import { getEmbindRsFingerprint, writeEmbindRsFingerprint } from '../utils/embindRsFingerprint.js';
+import relocatePrebuilt from '../utils/relocatePrebuilt.js';
+import replaceBasePathForDocker, { DOCKER_BASE } from '../utils/replaceBasePathForDocker.js';
+import { writeNativeSourceStamp } from '../utils/nativeSourceStamp.js';
 
 export default function buildLib(targetParams, options = {}) {
     let isChanged = false;
@@ -22,9 +25,10 @@ export default function buildLib(targetParams, options = {}) {
         // existence-only skip below would keep serving a stale staged staticlib after source edits.
         const isCargo = state.config.export?.type === 'cargo';
         const libdir = `${state.config.paths.output}/prebuilt/${target.path}`;
-        const sourceFingerprint = getSourceFingerprint(state.config);
+        const sourceFingerprint = getSourceFingerprint(state.config, target);
         const sourceChanged = isSourceFingerprintStale(libdir, sourceFingerprint);
-        if (isCargo || sourceChanged || !fs.existsSync(`${libdir}/lib`)) {
+        const nativeChanged = isNativeSourceNewerThan(`${libdir}/lib`);
+        if (isCargo || sourceChanged || nativeChanged || !fs.existsSync(`${libdir}/lib`)) {
             if (sourceChanged) {
                 for (const stale of staleTargetDirectories({
                     buildPath: state.config.paths.build,
@@ -33,8 +37,9 @@ export default function buildLib(targetParams, options = {}) {
                 })) fs.rmSync(stale, { recursive: true, force: true });
             }
             // createLib caches on existence too, so re-entering is not enough: a stale stamp means
-            // the lib on disk came from a different upstream release and has to be rebuilt.
-            createLib(target, 'Source', { buildSource: true, force: sourceChanged });
+            // the lib on disk came from a different upstream release, and a newer native source means
+            // it predates an edit; either way it has to be rebuilt.
+            createLib(target, 'Source', { buildSource: true, force: sourceChanged || nativeChanged });
 
             const modules = [];
             state.config.paths.module.forEach((modulePath) => {
@@ -52,10 +57,6 @@ export default function buildLib(targetParams, options = {}) {
             if (isCargo) writeEmbindRsFingerprint(libdir, getEmbindRsFingerprint());
             isChanged = true;
         } else {
-            // The skip is existence-only; without this warning a source edit is served stale silently.
-            if (isNativeSourceNewerThan(`${state.config.paths.output}/prebuilt/${target.path}/lib`)) {
-                logger.info(`[${target.path}] lib cached but native sources are newer - delete the prebuilt output (rm -rf dist .crossbind) and rebuild to pick them up`);
-            }
             logger.cachedStep(target, 'lib');
         }
     });
@@ -66,6 +67,11 @@ export default function buildLib(targetParams, options = {}) {
     if (isChanged && fs.existsSync(`${state.config.paths.build}/Source-Debug/prebuilt`)) {
         fs.cpSync(`${state.config.paths.build}/Source-Debug/prebuilt`, `${state.config.paths.output}/prebuilt`, { recursive: true, dereference: true });
     }
+    if (isChanged) targets.forEach((target) => {
+        writeNativeSourceStamp(`${state.config.paths.output}/prebuilt/${target.path}/lib`, state.config.paths.native);
+    });
+    // Cached trees too, so a rebuild fixes a prebuilt made before relocation existed.
+    targets.forEach(relocateTargetPrebuilt);
 
     if (!options.skipXcframework) {
         createXCFramework();
@@ -129,3 +135,14 @@ export default function buildLib(targetParams, options = {}) {
         fs.writeFileSync(`${state.config.paths.output}/prebuilt/CMakeLists.txt`, distCmakeContent);
     }
 }
+
+function relocateTargetPrebuilt(target) {
+    const { base, build, output } = state.config.paths;
+    const prefixDir = `${output}/prebuilt/${target.path}`;
+    if (!fs.existsSync(prefixDir)) return;
+    const installPrefix = `${build}/Source-${target.buildType === 'release' ? 'Release' : 'Debug'}/prebuilt/${target.path}`;
+    relocatePrebuilt(prefixDir, {
+        installPrefixes: [installPrefix, replaceBasePathForDocker(installPrefix, base)],
+        buildBases: [base, DOCKER_BASE],
+    });
+}

package/src/actions/buildNativeCommand.js

@@ -0,0 +1,84 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import run from './run.js';
+import getLinkInputs from './getLinkInputs.js';
+import getData from './getData.js';
+import state from '../state/index.js';
+import logger from '../utils/logger.js';
+import { getContentHash, getFilesFingerprint } from '../utils/hash.js';
+import { buildLinkLibArgs } from '../utils/linkLayout.js';
+
+const cpuCount = Math.max(1, os.cpus().length - 1);
+const PROJECT_SOURCE = fileURLToPath(new URL('../assets/cmake/command', import.meta.url));
+const PROJECT_FILES = ['CMakeLists.txt', 'command.cpp'];
+
+const statOf = (lib) => {
+    const stat = fs.existsSync(lib) ? fs.statSync(lib) : null;
+    return { lib, size: stat ? stat.size : null, mtimeMs: stat ? stat.mtimeMs : null };
+};
+
+// The CLI may sit outside the docker mount, so the project is copied next to the build.
+function stageProject(build) {
+    const projectDir = `${build}/crossbind-command`;
+    fs.mkdirSync(projectDir, { recursive: true });
+    PROJECT_FILES.forEach((file) => fs.copyFileSync(`${PROJECT_SOURCE}/${file}`, `${projectDir}/${file}`));
+    return projectDir;
+}
+
+function linkInputs(target) {
+    const { libs, wholeArchiveAll, wholeArchiveNames } = getLinkInputs(target, { keepFlag: () => '', withBridge: false });
+    const linkArgs = [
+        ...buildLinkLibArgs(libs, { wholeArchiveAll, wholeArchiveNames, forceLoad: target.platform === 'darwin' }),
+        // The system libraries the archives need, declared by the packages that bring them in.
+        ...(getData('binary', target)?.addonFlags ?? []),
+    ];
+    return { libs, linkArgs };
+}
+
+// Links the project's main() and the archives it reaches into one executable.
+export default async function buildNativeCommand(target, options = {}) {
+    if (target.platform === 'darwin' && process.platform !== 'darwin') {
+        logger.info(`[${target.path}] native command skipped (macOS executables link on a macOS host)`);
+        return false;
+    }
+    if (state.config.export.type === 'cargo') {
+        logger.info(`[${target.path}] native command skipped (cargo package - staticlib only)`);
+        return false;
+    }
+
+    const buildType = target.buildType === 'release' ? 'Release' : 'Debug';
+    const { build } = state.config.paths;
+    const { libs, linkArgs } = linkInputs(target);
+    const isStatic = target.platform === 'linuxmusl';
+
+    const fingerprintFile = `${build}/${target.commandName}.fingerprint`;
+    const fingerprint = getContentHash(JSON.stringify({
+        builder: getFilesFingerprint([fileURLToPath(import.meta.url), ...PROJECT_FILES.map((file) => `${PROJECT_SOURCE}/${file}`)]),
+        linkArgs,
+        isStatic,
+        libs: libs.map(statOf),
+    }));
+    const isLinkChanged = !fs.existsSync(fingerprintFile) || fs.readFileSync(fingerprintFile, 'utf8') !== fingerprint;
+    if (!options.force && !isLinkChanged && fs.existsSync(`${build}/${target.commandName}`)) {
+        logger.cachedStep(target, 'native command');
+        return false;
+    }
+
+    const platformPrefix = `Native-${buildType}`;
+    logger.startStep(target, 'native command');
+    run(null, [
+        'cmake', stageProject(build),
+        `-DCMAKE_BUILD_TYPE=${buildType}`,
+        `-DCROSSBIND_COMMAND_FILE=${target.commandName}`,
+        `-DCROSSBIND_LINK_ARGS=${linkArgs.join(';')}`,
+        `-DCROSSBIND_LINK_DEPENDS=${libs.join(';')}`,
+        `-DCROSSBIND_STATIC=${isStatic ? 'ON' : 'OFF'}`,
+    ], platformPrefix, target);
+    run(null, ['cmake', '--build', '.', '-j', String(cpuCount)], platformPrefix, target, { exclusive: true });
+    fs.copyFileSync(`${build}/${platformPrefix}/${target.path}/${target.commandName}`, `${build}/${target.commandName}`);
+    logger.doneStep(target, 'native command');
+
+    fs.writeFileSync(fingerprintFile, fingerprint);
+    return true;
+}

package/src/actions/buildNode.js

@@ -8,15 +8,21 @@ import virtual from '@rollup/plugin-virtual';
 import run from './run.js';
 import getLinkInputs from './getLinkInputs.js';
 import getData from './getData.js';
+import getEnv from './getEnv.js';
+import resetCMakeCacheForSource from '../utils/resetCMakeCacheForSource.js';
 import { suppressNodeBuiltinWarnings } from './buildJs.js';
 import state from '../state/index.js';
 import logger from '../utils/logger.js';
 import { getContentHash, getFilesFingerprint } from '../utils/hash.js';
 import { buildLinkLibArgs } from '../utils/linkLayout.js';
 import resolveEmbindNapiRoot, { resolveEmbindJsiRoot } from '../utils/resolveEmbindNapi.js';
+import scopedEmbind from '../utils/scopedEmbind.js';
 import resolveEmbindRustRoot from '../utils/resolveEmbindRust.js';
+import { rustStdLibsFor } from '../utils/cargoTarget.js';
+import toolchainNoticesDir from '../utils/toolchainNotices.js';
 
 const cpuCount = Math.max(1, os.cpus().length - 1);
+const WINDOWS_IMAGE_NOTICES = '/opt/licenses/llvm-mingw';
 
 function filesUnder(dirs) {
     return dirs.flatMap((dir) => (fs.existsSync(dir)
@@ -28,35 +34,54 @@ function filesUnder(dirs) {
 
 function linkInputs(target) {
     const {
-        libs, wholeArchiveAll, wholeArchiveNames, rustKeepFlags, hasRust,
+        libs, appRustLibs, wholeArchiveAll, wholeArchiveNames, rustKeepFlags, hasRust,
     } = getLinkInputs(target, {
         // The linker loads the archive member that defines a -u symbol; Mach-O prefixes C names with _.
         keepFlag: (name) => `-Wl,-u,${target.platform === 'darwin' ? '_' : ''}crossbind_keep_${name}`,
     });
+    // The app's Rust goes first: what a package's kept member needs from std and rustc's allocator shims is then
+    // already the app's, and the package's own copies stay in its archive instead of defining them twice.
+    const ordered = [...appRustLibs, ...libs.filter((lib) => !appRustLibs.includes(lib))];
     const linkArgs = [
-        ...buildLinkLibArgs(libs, { wholeArchiveAll, wholeArchiveNames, forceLoad: target.platform === 'darwin' }),
+        ...buildLinkLibArgs(ordered, { wholeArchiveAll, wholeArchiveNames, forceLoad: target.platform === 'darwin' }),
         ...rustKeepFlags,
         // The system libraries the archives need, declared by the packages that bring them in.
         ...(getData('binary', target)?.addonFlags ?? []),
+        ...(hasRust ? rustStdLibsFor(target) : []),
     ];
     // The addon runs embind-jsi, so Rust packages bind through the adapter React Native links.
     const extraSources = hasRust ? [`${resolveEmbindRustRoot()}/adapters/jsi.cpp`] : [];
     return { libs, linkArgs, extraSources };
 }
 
-function envOf(target) {
-    return Object.fromEntries(Object.entries(getData('env', target))
-        .map(([key, value]) => [key, typeof value === 'function' ? value(state, target) : value]));
+// A package publishes its addons in <package>-<platform>-<arch> by listing them as optional
+// dependencies, which is also how npm learns to install only the one for its machine.
+function listsAddonPackage(target) {
+    const { name, optionalDependencies = {} } = state.config.package ?? {};
+    return Boolean(name) && Object.hasOwn(optionalDependencies, `${name}-${target.platform}-${target.arch}`);
+}
+
+function addonPackagePattern(served) {
+    return served.some(listsAddonPackage) ? `${state.config.package.name}-{platform}-{arch}` : null;
+}
+
+// Each of those packages links its own addon, so a package that lists any links none. The ones it lists are
+// the platforms it publishes for.
+export function addonsInPackages() {
+    return state.targets.some(listsAddonPackage);
 }
 
 // One loader serves every addon of a build type, so each addon's env is keyed the way the loader
-// looks it up at runtime rather than taken from whichever arch happened to build last.
+// looks it up at runtime rather than taken from whichever arch happened to build last. With its addons in
+// packages, it knows the addons the package publishes.
 export function nodeLoaderConfig(target) {
     const served = state.targets.filter((t) => t.addonPattern && t.jsName === target.jsName);
+    const addonPackage = addonPackagePattern(served);
+    const loaded = addonPackage ? served.filter(listsAddonPackage) : served;
     return {
-        env: Object.fromEntries(served.map((t) => [`${t.platform}-${t.arch}`, envOf(t)])),
+        env: Object.fromEntries(loaded.map((t) => [`${t.platform}-${t.arch}`, getEnv(t)])),
         general: { name: state.config.general.name },
-        paths: { addon: target.addonPattern },
+        paths: { addon: target.addonPattern, ...(addonPackage ? { addonPackage } : {}) },
     };
 }
 
@@ -77,13 +102,20 @@ async function bundleLoader(target, napiRoot, loaderConfig) {
     const systemConfig = `export default ${JSON.stringify(loaderConfig)};`;
     const bundle = await rollup({
         input: `${napiRoot}/js/loader.js`,
-        plugins: [virtual({ 'crossbind/systemConfig': systemConfig }), nodeResolve(), commonjs()],
+        plugins: [
+            virtual({ 'crossbind/systemConfig': systemConfig }), scopedEmbind(`${resolveEmbindJsiRoot()}/js/embind.js`), nodeResolve(), commonjs(),
+        ],
         onwarn: suppressNodeBuiltinWarnings,
     });
     await bundle.write({ file: `${state.config.paths.build}/${target.jsName}`, format: 'cjs', exports: 'default' });
     await bundle.close();
 }
 
+// The loader alone, for a package whose platform packages link its addons.
+export function bundleNodeLoader(target) {
+    return bundleLoader(target, resolveEmbindNapiRoot(), nodeLoaderConfig(target));
+}
+
 // Links one Node-API addon from the project's archives and bundles the loader that picks the
 // addon matching the running process.
 export default async function buildNode(target, options = {}) {
@@ -127,6 +159,7 @@ export default async function buildNode(target, options = {}) {
 
     const platformPrefix = `Node-${buildType}`;
     logger.startStep(target, 'addon');
+    resetCMakeCacheForSource(`${build}/${platformPrefix}/${target.path}`, `${napiRoot}/cpp`, target);
     run(null, [
         'cmake', `${napiRoot}/cpp`,
         `-DCMAKE_BUILD_TYPE=${buildType}`,
@@ -136,7 +169,13 @@ export default async function buildNode(target, options = {}) {
         `-DCROSSBIND_LINK_ARGS=${linkArgs.join(';')}`,
         `-DCROSSBIND_LINK_DEPENDS=${libs.join(';')}`,
     ], platformPrefix, target);
-    run(null, ['cmake', '--build', '.', '-j', String(cpuCount)], platformPrefix, target);
+    run(null, ['cmake', '--build', '.', '-j', String(cpuCount)], platformPrefix, target, { exclusive: true });
+    if (target.platform === 'win32') {
+        // The mingw-w64 runtime and winpthreads in the addon ask for their notices in binary
+        // distributions. The windows image carries them; a host toolchain may not.
+        const notices = toolchainNoticesDir('win32');
+        run(null, ['sh', '-c', `if [ -d ${WINDOWS_IMAGE_NOTICES} ]; then mkdir -p ${notices} && cp ${WINDOWS_IMAGE_NOTICES}/* ${notices}/; fi`], null, target);
+    }
     fs.copyFileSync(`${build}/${platformPrefix}/${target.path}/${target.addonName}`, `${build}/${target.addonName}`);
     logger.doneStep(target, 'addon');
 

package/src/actions/buildTypes.js

@@ -9,7 +9,13 @@ import logger from '../utils/logger.js';
 // Package type publishing (opt-in: config `types: true`): one combined .d.ts over every
 // public header, written to <output>/types/index.d.ts, and package.json wired the way
 // hand-maintained typings already are - `types` plus a greedy `typesVersions` "*.h" map -
-// so a consumer's `import ... from '<pkg>/<any>.h'` resolves to the generated file.
+// so a consumer's `import ... from '<pkg>/<any>.h'` resolves to the generated file. The other
+// paths a package maps, such as its node/napi entry, stay.
+export function withPackageTypes(manifest, relative) {
+    const versions = manifest.typesVersions ?? {};
+    return { ...manifest, types: relative, typesVersions: { ...versions, '*': { ...versions['*'], '*.h': [relative] } } };
+}
+
 export default function buildTypes() {
     if (state.config.types !== true) return;
     const exts = state.config.ext.header.join(',');
@@ -25,7 +31,7 @@ export default function buildTypes() {
     const manifestFile = `${state.config.paths.project}/package.json`;
     const manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
     const relative = `./${path.relative(state.config.paths.project, dtsFile)}`;
-    const next = { ...manifest, types: relative, typesVersions: { '*': { '*.h': [relative] } } };
+    const next = withPackageTypes(manifest, relative);
     if (JSON.stringify({ t: next.types, v: next.typesVersions }) !== JSON.stringify({ t: manifest.types, v: manifest.typesVersions })) {
         fs.writeFileSync(manifestFile, `${JSON.stringify(next, null, 4)}\n`);
     }

package/src/actions/buildWasiCommand.js

@@ -7,18 +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.bundle === false) {
-        logger.info(`[${target.path}] wasi command skipped (export.bundle = false)`);
-        return false;
-    }
     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;
     }
 
@@ -56,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`;
@@ -75,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,
@@ -83,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]) => {