crossbind 0.0.1 → 2.0.0-beta.50

package/src/actions/buildDependencies.js

@@ -0,0 +1,157 @@
+import fs from 'node:fs';
+import state, { setAllDependecyPaths } from '../state/index.js';
+import loadConfig from '../state/loadConfig.js';
+import loadJson from '../utils/loadJson.js';
+import writeJson from '../utils/writeJson.js';
+import logger from '../utils/logger.js';
+import { getBuildTargets } from './target.js';
+import buildExternal from './buildExternal.js';
+import buildLib from './buildLib.js';
+import createXCFramework from './createXCFramework.js';
+import { mergeBuildOverride, getOverrideKey } from '../utils/overrideDependency.js';
+import {
+    isCached, getRebuildDeps, orderByDependencies, computeDependenciesStamp,
+} from '../utils/dependencyRebuild.js';
+import withDirLock from '../utils/dirLock.js';
+import { prepareRustSysroot } from '../utils/rustSysroot.js';
+
+export default async function buildDependencies({ targetParams, rebuildOption }) {
+    // Before the early returns below: this is the one async step every build path awaits, and the
+    // sync cargo work downstream reads what it resolves. A project with nothing to rebuild still
+    // needs its sysroot.
+    await prepareRustSysroot(getBuildTargets(targetParams));
+    await buildMissingCargoDependencies(getBuildTargets(targetParams), targetParams);
+
+    const rebuildDeps = getRebuildDeps(state.config.allDependencies, rebuildOption);
+    if (rebuildDeps.length === 0) return;
+
+    const targets = getBuildTargets(targetParams);
+    if (targets.length === 0) return;
+    const hasIos = targets.some((t) => t.platform === 'ios');
+
+    const appConfig = state.config;
+    const ordered = orderByDependencies(rebuildDeps);
+
+    for (const dep of ordered) {
+        const name = dep.general.name;
+        const depsDir = `${appConfig.paths.cache}/deps/${name}`;
+        const key = getOverrideKey(dep);
+
+        const isUsable = await withDirLock(`${depsDir}.lock`, async () => {
+            if (isCached(depsDir, targets, key, dep, hasIos)) {
+                logger.info(`crossbind: dependency "${name}" rebuild up to date (cached).`);
+                return true;
+            }
+            return rebuildDependency({
+                dep, name, depsDir, key, targetParams, hasIos, appConfig,
+            });
+        });
+        if (!isUsable) continue;
+
+        dep.paths.output = `${depsDir}/dist`;
+        if (hasIos) dep.paths.project = depsDir;
+        setAllDependecyPaths();
+    }
+}
+
+// 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
+// recipe, and a cargo package carries none - so an app with a plugin used to need a manual
+// 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;
+    const appConfig = state.config;
+    const missing = (appConfig.allDependencies ?? []).filter((dep) => dep !== appConfig
+        && dep.export?.type === 'cargo'
+        && targets.some((target) => !dep.functions.isEnabled(target)));
+
+    for (const dep of missing) {
+        const name = dep.general.name;
+        // isEnabled reads the filesystem on every call, so a build that lands while this one waits
+        // for the lock is picked up without any state to refresh.
+        await withDirLock(`${dep.paths.output}.autobuild.lock`, async () => {
+            if (targets.every((target) => dep.functions.isEnabled(target))) return;
+            logger.info(`crossbind: building cargo dependency "${name}" - it has no prebuilt for this target yet…`);
+            const scoped = await loadConfig(dep.paths.project);
+            const prev = state.config;
+            state.config = scoped;
+            try {
+                buildLib(targetParams);
+            } finally {
+                state.config = prev;
+            }
+        });
+    }
+
+    // The build above is the fix; this is the guard behind it. assertDependsBuilt only runs while
+    // the cmake link is being configured, so a cached native build skips the check and a missing
+    // cargo dependency reaches the app anyway - measured on wasm as a clean BUILD=0 whose module
+    // then failed 22 of 43 conformance features at init. Here the answer is known either way.
+    const unresolved = missing.filter((dep) => targets.some((target) => !dep.functions.isEnabled(target)));
+    if (unresolved.length > 0) {
+        const names = unresolved.map((dep) => `"${dep.general.name}"`).join(', ');
+        throw new Error(`crossbind: cargo ${unresolved.length > 1 ? 'dependencies' : 'dependency'} ${names} still `
+            + `${unresolved.length > 1 ? 'have' : 'has'} no prebuilt for ${targets.map((t) => t.path).join(', ')} `
+            + 'after building. Linking without it produces a module that builds clean and dies at init.');
+    }
+}
+
+async function rebuildDependency({
+    dep, name, depsDir, key, targetParams, hasIos, appConfig,
+}) {
+    const scoped = await loadConfig(dep.paths.project);
+    if (!scoped.build?.withBuildConfig) {
+        logger.info(`crossbind: dependency "${name}" has no source build recipe (crossbind.build); using prebuilt.`);
+        return false;
+    }
+
+    const override = dep.overrideBuild;
+    if (override) {
+        scoped.build = mergeBuildOverride(scoped.build, override);
+        if (override.nativeVersion) {
+            scoped.package = { ...scoped.package, nativeVersion: override.nativeVersion };
+        }
+        if (override.targetSpecs) scoped.targetSpecs = [...(scoped.targetSpecs || []), ...override.targetSpecs];
+        if (override.export) scoped.export = { ...scoped.export, ...override.export };
+    }
+
+    // All build I/O must stay under the app base (Docker mount) — never the dep's own node_modules.
+    // output = depsDir/dist (libs) and project = depsDir (xcframework) mirror a normal package layout
+    // so createXCFramework's project->output relative path resolves; paths.project stays the dep pkg
+    // dir for the recipe's copyToSource asset reads.
+    scoped.paths.base = appConfig.paths.base;
+    scoped.paths.output = `${depsDir}/dist`;
+    scoped.paths.build = `${depsDir}/build`;
+    scoped.paths.cache = depsDir;
+    scoped.allDependencyPaths = appConfig.allDependencyPaths;
+
+    const stale = loadJson(`${depsDir}/.crossbind-rebuild.json`)?.key !== key;
+    if (stale) fs.rmSync(depsDir, { recursive: true, force: true });
+    fs.mkdirSync(depsDir, { recursive: true });
+
+    logger.info(`crossbind: rebuilding dependency "${name}" from source (v${scoped.package.nativeVersion})…`);
+    const prev = state.config;
+    state.config = scoped;
+    try {
+        await buildExternal(targetParams, { skipXcframework: hasIos });
+        if (hasIos) {
+            createXCFramework({
+                paths: { project: depsDir, output: `${depsDir}/dist` },
+                export: { libName: dep.export.libName },
+                targetParams,
+            });
+        }
+    } finally {
+        state.config = prev;
+    }
+
+    writeJson(`${depsDir}/.crossbind-rebuild.json`, { key });
+    return true;
+}
+
+export function getDependenciesStamp() {
+    return computeDependenciesStamp(state.config.allDependencies, state.config.paths.cache);
+}

package/src/actions/buildExternal.js

@@ -0,0 +1,57 @@
+import fs from 'node:fs';
+import replace from 'replace';
+import downloadAndExtractFile from '../utils/downloadAndExtractFile.js';
+import { getBuildTargets } from './target.js';
+import state from '../state/index.js';
+import buildLib from './buildLib.js';
+import buildBinTools from './buildBinTools.js';
+
+export default async function buildExternal(targetParams, options = {}) {
+    const version = state.config.package.nativeVersion;
+    if (!version) {
+        throw new Error(`crossbind: "${state.config.general?.name}" has a crossbind.build recipe but no "nativeVersion" in package.json — cannot build from source.`);
+    }
+
+    const { getURL, sha256, replaceList, copyToSource, copyToDist } = state.config.build;
+    const isNewlyCreated = await downloadAndExtractFile(getURL(version), state.config.paths.build, sha256);
+    const sourcePath = `${state.config.paths.build}/source`;
+    if (isNewlyCreated && replaceList) {
+        replaceList.forEach(({ regex, replacement, paths }) => {
+            replace({
+                regex, replacement, paths: paths.map((p) => `${sourcePath}/${p}`), recursive: false, silent: true,
+            });
+        });
+    }
+
+    if (isNewlyCreated && copyToSource) {
+        Object.entries(copyToSource).forEach(([key, value]) => {
+            fs.copyFileSync(`${state.config.paths.project}/${key}`, `${sourcePath}/${value}`);
+        });
+    }
+
+    buildLib(targetParams, options);
+
+    if (state.config.build.bin) {
+        await buildBinTools(targetParams);
+    }
+
+    if (copyToDist) {
+        const targets = getBuildTargets(targetParams);
+        Object.entries(copyToDist).forEach(([key, value]) => {
+            const values = [];
+            if (Array.isArray(value)) {
+                values.push(...value);
+            } else {
+                values.push(value);
+            }
+            values.forEach(v => {
+                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);
+                    }
+                });
+            });
+        });
+    }
+}

package/src/actions/buildJs.js

@@ -0,0 +1,93 @@
+
+
+import { rollup } from 'rollup';
+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';
+
+const SUPPRESSED_WARN_CODES = new Set([
+    'MISSING_GLOBAL_NAME',
+    'MISSING_NODE_BUILTINS',
+    'MIXED_EXPORTS',
+]);
+
+function suppressNodeBuiltinWarnings(warning, defaultHandler) {
+    if (SUPPRESSED_WARN_CODES.has(warning.code)) return;
+    if (warning.code === 'UNRESOLVED_IMPORT' && /^node:/.test(warning.exporter || warning.source || warning.id || '')) return;
+    defaultHandler(warning);
+}
+
+const nodeLibs = {
+    fs: 'export default {};', 'node:fs': 'export default {};',
+    path: 'export default {};', 'node:path': 'export default {};',
+    crypto: 'export default {};', 'node:crypto': 'export default {};',
+    buffer: 'export default {};', 'node:buffer': 'export default {};',
+    stream: 'export default {};', 'node:stream': 'export default {};',
+    string_decoder: 'export default {};', 'node:string_decoder': 'export default {};',
+    util: 'export default {};', 'node:util': 'export default {};',
+    os: 'export default {};', 'node:os': 'export default {};',
+    'node:module': 'export default {};',
+    'node:worker_threads': 'export default {};',
+    ws: 'export default {};',
+};
+
+const options = {
+    browser: {
+        plugins: [virtual(nodeLibs), nodeResolve(), commonjs({ transformMixedEsModules: true, ignoreTryCatch: 'remove' })],
+        output: {
+            format: 'umd',
+            name: 'initNative',
+        },
+    },
+    node: {
+        plugins: [nodeResolve(), commonjs()],
+        output: {
+            format: 'umd',
+            name: 'initNative',
+        },
+    },
+};
+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 systemConfig = `export default {
+        env: ${env},
+        useWorker: !!globalThis.Worker,
+        general: {
+            name: '${state.config.general.name}',
+        },
+        fs: {
+            opfs: ${target.runtime === 'mt'},
+        },
+        paths: {
+            wasm: '${target.wasmName}',
+            data: '${target.dataTxtName}',
+            worker: '${target.rawJsName}',
+            js: '${target.jsName}',
+        }
+    }`;
+
+    // fs.renameSync(input, `${input}.raw.js`);
+    const option = options[target.runtimeEnv];
+    option.plugins = [virtual({
+        'crossbind/systemConfig': systemConfig,
+        'crossbind/module': `export { default } from '${state.config.paths.build}/${target.rawJsName}';`,
+    }), ...option.plugins];
+    option.input = entryJS;
+    option.output.file = `${state.config.paths.build}/${target.jsName}`;
+    option.onwarn = suppressNodeBuiltinWarnings;
+    const bundle = await rollup(option);
+    await bundle.write(option.output);
+    // fs.rmSync(`${input}.raw.js`, { force: true });
+}

package/src/actions/buildLib.js

@@ -0,0 +1,115 @@
+import fs from 'node:fs';
+import createLib from './createLib.js';
+import { isNativeSourceNewerThan } from './isSourceNewer.js';
+import createXCFramework from './createXCFramework.js';
+import { getBuildTargets, getFilteredTargetSpec } from './target.js';
+import state from '../state/index.js';
+import logger from '../utils/logger.js';
+import findFiles from '../utils/findFiles.js';
+
+export default function buildLib(targetParams, options = {}) {
+    let isChanged = false;
+    const targets = getBuildTargets(targetParams);
+    if (targets.length === 0) {
+        console.error('No targets found for the given parameters.', targetParams);
+        throw new Error('No targets found for the given parameters.');
+    }
+
+    targets.forEach((target) => {
+        // Cargo re-enters the build unconditionally: cargo is the incremental cache, and the
+        // existence-only skip below would keep serving a stale staged staticlib after source edits.
+        const isCargo = state.config.export?.type === 'cargo';
+        if (isCargo || !fs.existsSync(`${state.config.paths.output}/prebuilt/${target.path}/lib`)) {
+            createLib(target, 'Source', { buildSource: true });
+
+            const modules = [];
+            state.config.paths.module.forEach((modulePath) => {
+                modules.push(...findFiles('**/*.i', { cwd: modulePath }));
+                modules.push(...findFiles('*.i', { cwd: modulePath }));
+            });
+            if (modules.length > 0) {
+                fs.mkdirSync(`${state.config.paths.output}/prebuilt/${target.path}/swig`, { recursive: true });
+            }
+            modules.forEach((modulePath) => {
+                const fileName = modulePath.split('/').at(-1);
+                fs.copyFileSync(modulePath, `${state.config.paths.output}/prebuilt/${target.path}/swig/${fileName}`);
+            });
+            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');
+        }
+    });
+
+    if (isChanged && fs.existsSync(`${state.config.paths.build}/Source-Release/prebuilt`)) {
+        fs.cpSync(`${state.config.paths.build}/Source-Release/prebuilt`, `${state.config.paths.output}/prebuilt`, { recursive: true, dereference: true });
+    }
+    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 (!options.skipXcframework) {
+        createXCFramework();
+
+        const iosTargets = getBuildTargets({ platform: ['ios'], arch: ['iphoneos'], runtime: ['mt'], buildType: ['release'] });
+        const podSpecs = findFiles('*.podspec', { cwd: state.config.paths.project });
+        if (podSpecs.length === 0 && targets.length > 0) {
+            const iosTarget = iosTargets[0];
+            const resources = getFilteredTargetSpec(state.config.targetSpecs, iosTarget).map(s => s.data).filter(s => s).map(d => Object.keys(d)).flat();
+            const uniqueResources = [...new Set(resources)].map(r => `dist/prebuilt/${iosTarget.path}/${r}`);
+            const xcFrameworks = [];
+            xcFrameworks.push(...state.config.export.libName.map((l) => `${l}.xcframework`));
+            if (!xcFrameworks.some(f => !fs.existsSync(`${state.config.paths.project}/${f}`))) {
+                xcFrameworks.push(...state.config.dependencies.map((d) => d.export.libName.map((l) => `${l}.xcframework`)).flat());
+                // Cargo producers register through an init-array constructor that nothing references,
+                // so the linker would dead-strip it. Generated bridges pin their keep symbol with -u
+                // (NEVER force_load: every Rust staticlib bundles libstd, and fully loading two of
+                // them duplicates thousands of std symbols); manual-bindings crates have no keep
+                // symbol and fall back to force_load - safe only while they are the single loaded
+                // Rust archive in the app.
+                let ldFlags = '';
+                if (state.config.export?.type === 'cargo') {
+                    const crateLibRs = `${state.config.paths.project}/${state.config.export.crate ?? 'crate'}/src/lib.rs`.replace('/./', '/');
+                    const isManual = fs.existsSync(crateLibRs) && fs.readFileSync(crateLibRs, 'utf8').includes('bindings!');
+                    const flags = state.config.export.libName.map((l) => (isManual
+                        ? `-force_load $(PODS_XCFRAMEWORKS_BUILD_DIR)/${state.config.general.name}/lib${l}.a`
+                        : `-Wl,-u,_crossbind_keep_${l}`)).join(' ');
+                    ldFlags = `, 'OTHER_LDFLAGS' => '${flags}'`;
+                }
+                const distPodSpecContent = fs.readFileSync(`${state.config.paths.cli}/assets/packaging/crossbind-package.podspec`, { encoding: 'utf8', flag: 'r' })
+                    // module_name must be a valid C99 identifier (pod names may carry dashes).
+                    .replace('___PROJECT_MODULE_NAME___', state.config.general.name.replace(/[^a-zA-Z0-9_]/g, '_'))
+                    .replaceAll('___PROJECT_NAME___', state.config.general.name)
+                    .replace('___PROJECT_FRAMEWORKS___', xcFrameworks.map(f => `'${f}'`).join(', '))
+                    .replace('___PROJECT_RESOURCES___', JSON.stringify(uniqueResources))
+                    .replace('___PROJECT_LDFLAGS___', ldFlags);
+                fs.writeFileSync(`${state.config.paths.project}/${state.config.general.name}.podspec`, distPodSpecContent);
+            }
+        }
+    }
+
+    if (fs.existsSync(`${state.config.paths.output}/prebuilt`)) {
+        // A partial build (e.g. `crossbind build -p wasm`) must not clobber the other platforms'
+        // entries: consumers resolve this CMakeLists for ios/android too, and a target missing
+        // from the list silently drops the dependency's include dirs and libs. Advertise every
+        // target already present in dist alongside the ones just built.
+        const distTargets = fs.readdirSync(`${state.config.paths.output}/prebuilt`, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && fs.existsSync(`${state.config.paths.output}/prebuilt/${e.name}/lib`))
+            .map((e) => e.name);
+        const hostTargets = [...new Set([...distTargets, ...targets.map((t) => t.path)])];
+        const distCmakeContent = fs.readFileSync(`${state.config.paths.cli}/assets/cmake/dist.cmake`, { encoding: 'utf8', flag: 'r' })
+            .replace('___PROJECT_NAME___', state.config.general.name)
+            .replace('___PROJECT_HOST___', hostTargets.join(';'))
+            .replace('___PROJECT_LIBS___', state.config.export.libName.join(';'))
+            .replace('___PROJECT_WHOLE_ARCHIVE___', (() => {
+                if (state.config.export?.type !== 'cargo') return '';
+                const crateLibRs = `${state.config.paths.project}/${state.config.export.crate ?? 'crate'}/src/lib.rs`.replace('/./', '/');
+                const isManual = fs.existsSync(crateLibRs) && fs.readFileSync(crateLibRs, 'utf8').includes('bindings!');
+                return isManual ? 'FORCE' : 'KEEP';
+            })());
+        fs.writeFileSync(`${state.config.paths.output}/prebuilt/CMakeLists.txt`, distCmakeContent);
+    }
+}

package/src/actions/buildTypes.js

@@ -0,0 +1,33 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import state from '../state/index.js';
+import findFiles from '../utils/findFiles.js';
+import writeIfChanged from '../utils/writeIfChanged.js';
+import { parseCppSurface, emitCppDts } from '../utils/cppDts.js';
+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.
+export default function buildTypes() {
+    if (state.config.types !== true) return;
+    const exts = state.config.ext.header.join(',');
+    const headers = [...new Set(state.config.paths.header.flatMap((dir) => findFiles(`${dir}/**/*.{${exts}}`)))].sort();
+    if (headers.length === 0) return;
+
+    const combined = headers.map((h) => fs.readFileSync(h, 'utf8')).join('\n');
+    const model = parseCppSurface(combined, (m) => logger.info(m));
+    const names = model.classes.map((c) => c.name);
+    const dtsFile = `${state.config.paths.output}/types/index.d.ts`;
+    writeIfChanged(dtsFile, emitCppDts(model, names, state.config.dts));
+
+    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] } } };
+    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`);
+    }
+    logger.info(`crossbind: package types -> ${relative} (${names.length} classes from ${headers.length} headers)`);
+}

package/src/actions/buildWasiCommand.js

@@ -0,0 +1,101 @@
+import fs from 'node:fs';
+import run from './run.js';
+import getDependLibs from './getDependLibs.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';
+import { wasiCxxFlags, WASI_LINK_LIBS } from '../utils/wasiToolchain.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.
+export default async function buildWasiCommand(target, options = {}) {
+    const isProd = target.buildType === 'release';
+    const buildType = isProd ? 'Release' : 'Debug';
+
+    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)`);
+        return false;
+    }
+
+    const sourceLibCandidates = [
+        `${state.config.paths.build}/Source-${buildType}/${target.path}/lib${state.config.general.name}.a`,
+        `${state.config.paths.output}/prebuilt/${target.path}/lib/lib${state.config.general.name}.a`,
+    ];
+    const libs = [
+        ...getDependLibs(target),
+        sourceLibCandidates.find((lib) => fs.existsSync(lib)) ?? sourceLibCandidates[0],
+    ];
+
+    const binary = getData('binary', target);
+    const wasiFlags = binary?.wasiFlags || [];
+
+    const wholeArchiveAll = state.config.export.wholeArchive === true;
+    const wholeArchiveNames = new Set();
+    state.config.dependencyParameters.getCmakeDepends(target).forEach((dep) => {
+        if (dep.export.wholeArchive === true) {
+            (dep.export.libName || []).forEach((name) => wholeArchiveNames.add(name));
+        }
+    });
+    // crt1 references main only weakly: the source archive must be force-included.
+    const linkLibs = buildLinkLibArgs(libs, { wholeArchiveAll, wholeArchiveNames });
+
+    const stubs = `${state.config.paths.cli}/assets/wasi-runtime/stubs.c`;
+    const linkFingerprintFile = `${state.config.paths.build}/${target.wasmName}.fingerprint`;
+    const linkFingerprint = getContentHash(JSON.stringify({
+        linkLayout: 'wasi-v2',
+        wasiFlags,
+        wholeArchiveAll,
+        wholeArchiveNames: [...wholeArchiveNames].sort(),
+        libs: libs.map((lib) => {
+            const stat = fs.existsSync(lib) ? fs.statSync(lib) : null;
+            return { lib, size: stat ? stat.size : null, mtimeMs: stat ? stat.mtimeMs : null };
+        }),
+        data: getData('data', target),
+        runtime: getFilesFingerprint([stubs]),
+    }));
+    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');
+        return false;
+    }
+
+    logger.startStep(target, 'wasi command');
+    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`;
+    fs.mkdirSync(state.config.paths.build, { recursive: true });
+    fs.copyFileSync(stubs, stagedStubs);
+    run(null, [
+        'wasi-clang++',
+        stagedStubs,
+        ...wasiCxxFlags(),
+        ...(isProd ? ['-O3'] : ['-O0']),
+        ...wasiFlags,
+        ...linkLibs,
+        ...WASI_LINK_LIBS,
+        '-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`);
+
+    // Dep data lands as a real folder next to the artifact for --dir preopens.
+    Object.entries(getData('data', target)).forEach(([key, value]) => {
+        if (fs.existsSync(key)) {
+            const dataPath = `${state.config.paths.build}/data/${value}`;
+            if (!fs.existsSync(dataPath)) {
+                fs.mkdirSync(dataPath, { recursive: true });
+                fs.cpSync(key, dataPath, { recursive: true });
+            }
+        }
+    });
+
+    fs.writeFileSync(linkFingerprintFile, linkFingerprint);
+    return true;
+}