crossbind 0.0.1 → 2.0.0-beta.51

package/src/actions/createLib.js

@@ -0,0 +1,249 @@
+import os from 'node:os';
+import fs from 'node:fs';
+import replace from 'replace';
+import getData from './getData.js';
+import run from './run.js';
+import buildCargo from './buildCargo.js';
+import { cargoTripleFor } from '../utils/cargoTarget.js';
+import getCmakeParameters from './getCmakeParameters.js';
+import triggerExtensions from './extensions.js';
+import state from '../state/index.js';
+import logger from '../utils/logger.js';
+import { WASI_EMULATION_LIBS, WASI_LINK_LIBS, wasiCFlags, wasiCxxFlags } from '../utils/wasiToolchain.js';
+import { getFilesFingerprint, getContentHash } from '../utils/hash.js';
+
+const cpuCount = Math.max(1, os.cpus().length - 1);
+const sharedPlatforms = ['android'];
+
+export default function createLib(target, fileType, options = {}) {
+    if (!target || !options || typeof options !== 'object' || Array.isArray(options)) {
+        throw new Error('invalid target or options');
+    }
+
+    if (target.platform === 'ios' && process.platform !== 'darwin') {
+        return;
+    }
+
+    const buildType = target.buildType === 'release' ? 'Release' : 'Debug';
+    const platformPrefix = `${fileType ? `${fileType}-` : ''}${buildType}`;
+    const libdir = `${state.config.paths.build}/${platformPrefix}/prebuilt/${target.path}`;
+    const buildPath = `${state.config.paths.build}/${platformPrefix}/${target.path}`;
+    // wasi configure tool links need the runtime stubs; compiled below, referenced from LIBS.
+    const wasiStubObj = `${buildPath}/crossbind-wasi-stubs.o`;
+
+    // The lib dir is reused while the bridge list grows, so an early smaller nativeGlob build must not satisfy later sets: fingerprint the glob and miss on mismatch.
+    const fingerprintFile = `${libdir}/crossbind-nativeglob.fingerprint`;
+    const fingerprint = options.nativeGlob ? getFilesFingerprint(options.nativeGlob) : null;
+    const fingerprintChanged = fingerprint !== null
+        && (!fs.existsSync(fingerprintFile) || fs.readFileSync(fingerprintFile, { encoding: 'utf8' }) !== fingerprint);
+
+    // Config emccFlags feed compile-time state too (CROSSBIND_JSPI below), so a flag change must miss this cache.
+    const configEmccFlags = getData('binary', target)?.emccFlags || [];
+    const flagsFingerprintFile = `${libdir}/crossbind-emccflags.fingerprint`;
+    const flagsFingerprint = getContentHash(JSON.stringify(configEmccFlags));
+    const flagsChanged = !fs.existsSync(flagsFingerprintFile)
+        || fs.readFileSync(flagsFingerprintFile, { encoding: 'utf8' }) !== flagsFingerprint;
+
+    // Rust packages build with cargo on the host and stage the .a like any other prebuilt; the
+    // normal prebuilt-link machinery then links it for every platform (no SWIG bridge for Rust).
+    // Runs BEFORE the existence cache below: cargo is the incremental cache, and an existence
+    // skip would keep serving a stale staged .a after crate source edits.
+    if (state.config.export?.type === 'cargo') {
+        // Platforms with no cargo triple (wasi, ...) are skipped, so a plain `crossbind build`
+        // still completes every other platform instead of dying on the first unsupported one.
+        if (!cargoTripleFor(target)) {
+            logger.info(`[${target.path}] cargo package skipped (no cargo triple for this platform)`);
+            return false;
+        }
+        logger.startStep(target, fileType);
+        const changed = buildCargo(target, libdir);
+        if (fingerprint !== null) fs.writeFileSync(fingerprintFile, fingerprint);
+        fs.writeFileSync(flagsFingerprintFile, flagsFingerprint);
+        return changed;
+    }
+
+    if (!options.force && !fingerprintChanged && !flagsChanged && fs.existsSync(`${libdir}/lib`)) {
+        logger.cachedStep(target, fileType);
+        return false;
+    }
+
+    // Bridges guard _JSPI registrations behind CROSSBIND_JSPI (bridgeAsyncGuard); define it only when this target links with -sJSPI.
+    const isJspiTarget = target.platform === 'wasm' && configEmccFlags.includes('-sJSPI');
+    if (fileType === 'Bridge' && target.platform === 'wasm' && !isJspiTarget
+        && options.nativeGlob?.some((f) => fs.existsSync(f) && fs.readFileSync(f, { encoding: 'utf8' }).includes('emscripten::async()'))) {
+        logger.info(`[${target.path}] _JSPI bindings skipped: this target links without -sJSPI (add it to binary.emccFlags to enable them)`);
+    }
+
+    const buildEnv = { params: [] };
+    let buildParams;
+    const depPaths = state.config.allDependencyPaths[target.path];
+    if (state.config.build.withBuildConfig) {
+        const { getBuildParams, getExtraLibs } = state.config.build;
+        buildEnv.console = true;
+        const ext = sharedPlatforms.includes(target.platform) ? 'so' : 'a';
+        buildParams = getBuildParams ? getBuildParams(target, depPaths, ext, buildPath) : [];
+        if (state.config.build?.buildType !== 'configure') {
+            const cmakeBuildType = sharedPlatforms.includes(target.platform) ? 'SHARED' : 'STATIC';
+            // Upstream CMakeLists increasingly default BUILD_SHARED_LIBS=ON; on wasm that extra .so link fails under emsdk 6, so default to the platform's lib kind (recipe -D flags come later and can override).
+            buildParams.unshift(`-DBUILD_SHARED_LIBS=${cmakeBuildType === 'SHARED' ? 'ON' : 'OFF'}`);
+            buildParams.push(`-DCMAKE_PREFIX_PATH=${libdir}`, `-DCMAKE_FIND_ROOT_PATH=${libdir}`, `-DBUILD_TYPE=${cmakeBuildType}`);
+        }
+
+        const cFlags = Object.values(depPaths).filter(d => d.header).map((d) => `-I${d.header}`);
+        const ldFlags = Object.values(depPaths).filter(d => d.libPath).map((d) => `-L${d.libPath}`);
+        let dependLibs = '';
+        if (state.config.build?.buildType === 'configure') {
+            dependLibs = Object.keys(depPaths)
+                .filter(d => d && d !== 'cmake')
+                // A declared dep without a wasi archive (e.g. jpeg) would fail every configure probe.
+                .filter(d => target.platform !== 'wasi' || fs.existsSync(depPaths[d].lib))
+                .map((d) => `-l${d}`).join(' ');
+        }
+
+        const extraLibs = getExtraLibs ? getExtraLibs(target) : [];
+
+        triggerExtensions('createLib', 'setFlagWithBuildConfig', [buildEnv, cFlags, ldFlags]);
+        if (target.runtime === 'mt') {
+            cFlags.push('-pthread');
+            ldFlags.push('-pthread');
+        }
+
+        if (target.platform === 'wasm') {
+            cFlags.push('-msimd128');
+            ldFlags.push('-msimd128');
+        }
+
+        if (isJspiTarget) {
+            cFlags.push('-DCROSSBIND_JSPI');
+        }
+
+        if (target.platform === 'wasm' && target.arch === 'wasm64') {
+            cFlags.push('-sMEMORY64=1');
+            ldFlags.push('-sMEMORY64=1');
+        }
+
+        buildEnv.params.push('-e', `CFLAGS=${cFlags.join(' ')}`);
+        buildEnv.params.push('-e', `CXXFLAGS=${cFlags.join(' ')}`);
+        buildEnv.params.push('-e', `LDFLAGS=${ldFlags.join(' ')} ${extraLibs.join(' ')}`);
+        // Emulation archives must land in LIBS (after the objects), not LDFLAGS.
+        const wasiStubLib = state.config.build?.buildType === 'configure' ? `${wasiStubObj} ` : '';
+        const wasiLibs = target.platform === 'wasi' ? ` ${wasiStubLib}${WASI_EMULATION_LIBS.join(' ')}` : '';
+        buildEnv.params.push('-e', `LIBS=${dependLibs} ${extraLibs.join(' ')}${wasiLibs}`);
+
+        let configBuildEnv = state.config.build.env;
+        if (configBuildEnv && typeof configBuildEnv === 'function') {
+            configBuildEnv = configBuildEnv(target);
+        }
+        configBuildEnv?.forEach((e) => {
+            buildEnv.params.push('-e', e);
+        });
+    } else {
+        buildParams = getCmakeParameters(target, options);
+
+        triggerExtensions('createLib', 'setFlagWithoutBuildConfig', [buildEnv]);
+
+        if (target.runtime === 'mt') {
+            buildEnv.params.push('-e', `CFLAGS=-pthread`);
+            buildEnv.params.push('-e', `CXXFLAGS=-pthread`);
+            buildEnv.params.push('-e', `LDFLAGS=-pthread`);
+        }
+
+        if (target.platform === 'wasm') {
+            buildEnv.params.push('-e', `CFLAGS=-msimd128`);
+            buildEnv.params.push('-e', `CXXFLAGS=-msimd128`);
+            buildEnv.params.push('-e', `LDFLAGS=-msimd128`);
+        }
+
+        if (target.platform === 'wasm' && target.arch === 'wasm64') {
+            buildEnv.params.push('-e', `CFLAGS=-sMEMORY64=1`);
+            buildEnv.params.push('-e', `CXXFLAGS=-sMEMORY64=1`);
+            buildEnv.params.push('-e', `LDFLAGS=-sMEMORY64=1`);
+        }
+
+        if (isJspiTarget) {
+            buildEnv.params.push('-e', `CFLAGS=-DCROSSBIND_JSPI`);
+            buildEnv.params.push('-e', `CXXFLAGS=-DCROSSBIND_JSPI`);
+        }
+    }
+
+    logger.startStep(target, fileType);
+    const t0 = performance.now();
+    const cmakeDir = state.config.build.withBuildConfig ? `${state.config.paths.build}/source` : state.config.paths.cmakeDir;
+
+    if (state.config.build?.beforeRun) {
+        const dataList = state.config.build?.beforeRun(cmakeDir);
+        dataList.forEach((data) => {
+            run(data.program, data.parameters || [], platformPrefix, target, buildEnv);
+        });
+    }
+
+    // stubs.c lives outside the docker mount (paths.cli); stage it into the build tree.
+    const stageWasiStubs = () => {
+        const staged = `${buildPath}/crossbind-wasi-stubs.c`;
+        fs.mkdirSync(buildPath, { recursive: true });
+        fs.copyFileSync(`${state.config.paths.cli}/assets/wasi-runtime/stubs.c`, staged);
+        run(null, [
+            'wasi-clang', ...wasiCFlags(), '-c', staged,
+            '-o', wasiStubObj,
+        ], platformPrefix, target, { console: buildEnv.console });
+    };
+
+    if (!options.bypassCmake) {
+        if (state.config.build?.buildType === 'configure') {
+            fs.cpSync(cmakeDir, buildPath, { recursive: true });
+            if (state.config.build?.sourceReplaceList) {
+                state.config.build.sourceReplaceList(target, depPaths)?.forEach(({ regex, replacement, paths }) => {
+                    replace({
+                        regex, replacement, paths: paths.map((p) => `${buildPath}/${p}`), recursive: false, silent: true,
+                    });
+                });
+            }
+            if (target.platform === 'wasi') {
+                // LIBS references the stub object before the first configure link probe.
+                stageWasiStubs();
+            }
+            run(null, [
+                './configure',
+                ...buildParams,
+                `--prefix=${libdir}`,
+            ], platformPrefix, target, buildEnv);
+        } else {
+            if (target.platform === 'wasi') {
+                // Upstream exe links (BUILD_APPS etc.) need the stubs + wasm-EH tail on CMAKE_EXE_LINKER_FLAGS so try_compile probes link the same way.
+                stageWasiStubs();
+                buildParams.push(`-DCMAKE_EXE_LINKER_FLAGS=${[...wasiCxxFlags(), wasiStubObj, ...WASI_LINK_LIBS].join(' ')}`);
+            }
+            run(null, [
+                target.platform === 'ios' && state.config.build?.useIOSCMake ? 'ios-cmake' : 'cmake', cmakeDir,
+                `-DCMAKE_BUILD_TYPE=${buildType}`,
+                `-DCMAKE_INSTALL_PREFIX=${libdir}`,
+                ...buildParams,
+            ], platformPrefix, target, buildEnv);
+        }
+    }
+    const t1 = performance.now();
+    if (target.platform === 'ios' && state.config.build?.buildType !== 'configure') {
+        const iOSCMakeBuilder = state.config.build?.useIOSCMake ? 'ios-cmake' : 'cmake';
+        run(null, [iOSCMakeBuilder, '--build', '.', '-j', cpuCount, '--config', buildType, '--target', 'install'], platformPrefix, target, { console: buildEnv.console });
+    } else {
+        // Some upstream makefiles race when one -j invocation carries multiple goals (openssl's
+        // install builds apps twice); recipes can split phases via build.makePhases.
+        const makePhases = state.config.build?.makePhases || [['install']];
+        makePhases.forEach((phase) => {
+            run(null, ['make', `-j${cpuCount}`, ...phase], platformPrefix, target, { console: buildEnv.console });
+        });
+    }
+    const t2 = performance.now();
+    const cmakeMs = Math.round(t1 - t0);
+    const buildMs = Math.round(t2 - t1);
+    const detail = `cmake ${cmakeMs < 1000 ? `${cmakeMs}ms` : `${(cmakeMs / 1000).toFixed(1)}s`}, make ${buildMs < 1000 ? `${buildMs}ms` : `${(buildMs / 1000).toFixed(1)}s`}, j${cpuCount}`;
+    logger.doneStep(target, fileType, detail);
+
+    fs.mkdirSync(libdir, { recursive: true });
+    if (fingerprint !== null) {
+        fs.writeFileSync(fingerprintFile, fingerprint);
+    }
+    fs.writeFileSync(flagsFingerprintFile, flagsFingerprint);
+    // Callers can force the final link when a lib actually rebuilt.
+    return true;
+}

package/src/actions/createXCFramework.js

@@ -0,0 +1,82 @@
+import fs from 'node:fs';
+import upath from 'upath';
+import { execFileSync } from 'node:child_process';
+import state from '../state/index.js';
+import logger from '../utils/logger.js';
+import { getTargetParams, getFilteredBuildTargets } from './target.js';
+
+const iOSDevPath = '/Applications/Xcode.app/Contents/Developer';
+const iosBinPath = `${iOSDevPath}/Toolchains/XcodeDefault.xctoolchain/usr/bin`;
+const iosRanLibBin = `${iosBinPath}/ranlib`;
+
+function runQuiet(bin, params, options) {
+    try {
+        execFileSync(bin, params, { ...options, stdio: ['ignore', 'pipe', 'pipe'] });
+    } catch (e) {
+        if (e.stdout?.length) process.stderr.write(e.stdout);
+        if (e.stderr?.length) process.stderr.write(e.stderr);
+        throw e;
+    }
+}
+
+export default function createXCFramework(overrideConfig = null) {
+    if (process.platform !== 'darwin') {
+        logger.info('XCFramework not created because platform is not darwin.');
+        return;
+    }
+
+    const output = overrideConfig?.paths?.output || state.config.paths.output;
+    const projectPath = overrideConfig?.paths?.project || state.config.paths.project;
+    const libName = overrideConfig?.export?.libName || state.config.export.libName;
+
+    const options = { cwd: projectPath };
+
+    const relativeOutput = upath.relative(projectPath, output);
+
+    const targetParams = overrideConfig?.targetParams || getTargetParams();
+    const buildTargets = getFilteredBuildTargets(targetParams, { platform: 'ios', runtime: 'mt', buildType: (targetParams.buildType && targetParams.buildType.length > 0) ? targetParams.buildType[0] : 'release' });
+
+    if (buildTargets.some(t => !fs.existsSync(`${output}/prebuilt/${t.path}/lib`))) {
+        logger.info('XCFramework not created because some of the build targets are not built.');
+        return;
+    }
+
+    const targets = {};
+    buildTargets.forEach((target) => {
+        const p = `${target.platform}-${target.runtime}-${target.buildType}`;
+        if (!targets[p]) {
+            targets[p] = {};
+        }
+        targets[p][target.arch] = target;
+    });
+
+    libName.forEach((fileName) => {
+        Object.values(targets).forEach((a) => {
+            const targets = Object.values(a);
+            // const targetName = `${fileName}-${targets[0].runtime}-${targets[0].buildType}.xcframework`;
+            const targetName = `${fileName}.xcframework`;
+            const targetPath = `${projectPath}/${targetName}`;
+            // Always recreate: the xcframework wraps the freshly built static libs which contain
+            // the user's bridge bindings. If we keep a stale xcframework around, the linker
+            // (via the podspec's vendored_frameworks + force_load) will pull in old bindings
+            // and runtime calls like `Module.<UserClass>` resolve to undefined. xcodebuild
+            // -create-xcframework refuses to overwrite, so delete first.
+            if (fs.existsSync(targetPath)) {
+                fs.rmSync(targetPath, { recursive: true, force: true });
+            }
+            const taskLabel = `xcframework ${targetName}`;
+            logger.startTask(taskLabel);
+            const params = ['-create-xcframework'];
+            targets.forEach((target) => {
+                runQuiet(iosRanLibBin, [`${relativeOutput}/prebuilt/${target.path}/lib/lib${fileName}.a`], options);
+                params.push(
+                    '-library', `${relativeOutput}/prebuilt/${target.path}/lib/lib${fileName}.a`,
+                    '-headers', `${relativeOutput}/prebuilt/${target.path}/include`,
+                );
+            });
+            params.push('-output', targetName);
+            runQuiet('xcodebuild', params, options);
+            logger.doneTask(taskLabel);
+        });
+    });
+}

package/src/actions/extensions.js

@@ -0,0 +1,7 @@
+import state from '../state/index.js';
+
+export default function triggerExtensions(fileName, hook, params = []) {
+    state.config.extensions?.forEach(e => {
+        e?.[fileName]?.[hook](state, ...params);
+    });
+}

package/src/actions/getAllBridges.js

@@ -0,0 +1,20 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import findFiles from '../utils/findFiles.js';
+import state from '../state/index.js';
+
+export default function getAllBridges(log = console.log) {
+    return findFiles(`${state.config.paths.build}/bridge/*.i.cpp`).filter((bridge) => {
+        // The .source sidecar records the header this bridge was generated from. When that
+        // header is gone, the stale .i.cpp would #include a missing file and break the native
+        // build - the same failure a deleted .rs used to cause. Bridges without a sidecar
+        // predate it and are left alone.
+        const sidecar = `${bridge}.source`;
+        if (!fs.existsSync(sidecar)) return true;
+        const source = fs.readFileSync(sidecar, 'utf8').trim();
+        if (!source || fs.existsSync(source)) return true;
+        [bridge, `${bridge}.exports.json`, sidecar].forEach((f) => fs.rmSync(f, { force: true }));
+        log(`crossbind: pruned stale bridge '${path.basename(bridge)}' - its header is gone`);
+        return false;
+    });
+}

package/src/actions/getCmakeParameters.js

@@ -0,0 +1,66 @@
+import fs from 'node:fs';
+import state from '../state/index.js';
+import getData from './getData.js';
+
+export default function getCmakeParameters(target, options = {}) {
+    if (!options || typeof options !== 'object' || Array.isArray(options)) {
+        throw new Error('invalid options');
+    }
+
+    const params = [];
+    // if (isBuildBridge) params.push('-DBUILD_BRIDGE=TRUE');
+
+    const dependParams = state.config.dependencyParameters;
+    const externalNativeGlob = [
+        ...(options.nativeGlob || []),
+    ];
+    const externalBridgeGlob = [
+        `${state.config.paths.cli}/assets/cpp-runtime/commonBridges.cpp`,
+        ...(options.bridgeGlob || []),
+    ];
+    const nativeGlob = [
+        `${state.config.paths.cli}/assets/cpp-runtime/crossbindEmptySource.cpp`,
+        ...(dependParams.nativeGlob || []),
+    ];
+    const headerGlob = [
+        ...(dependParams.headerGlob || []),
+        ...(options.headerGlob || []),
+    ];
+
+    const headerDirs = [
+        dependParams.headerPathWithDepends,
+        ...(options.headerDirs || []),
+    ];
+
+    const sharedPlatforms = ['android'];
+    const buildType = sharedPlatforms.includes(target.platform) ? 'SHARED' : 'STATIC';
+    const otherBuildType = buildType === 'STATIC' ? 'SHARED' : 'STATIC';
+
+    const cmakeCompileOptions = [...new Set(getData('cmake', target)?.compileOptions || [])];
+
+    params.push(...[
+        `-DPROJECT_NAME=${options.name || state.config.general.name}`,
+        // `-DPACKAGE_NAME_SUFFIX=${target.platform === 'ios' ? `-${target.runtime}-${target.buildType}` : ''}`,
+        `-DPROJECT_TARGET_PLATFORM=${target.platform}`,
+        `-DPROJECT_TARGET_ARCH=${target.arch}`,
+        `-DPROJECT_TARGET_RUNTIME=${target.runtime}`,
+        `-DPROJECT_TARGET_HOST=${target.platform}-${target.arch}-${target.runtime}-${target.buildType}`,
+        `-DPROJECT_TARGET_HOST_RELEASE=${target.platform}-${target.arch}-${target.runtime}-release`,
+        `-DBASE_DIR=${state.config.paths.project}`,
+        `-DEXTERNAL_NATIVE_GLOB=${externalNativeGlob.join(';')}`,
+        `-DEXTERNAL_BRIDGE_GLOB=${externalBridgeGlob.join(';')}`,
+        `-DNATIVE_GLOB=${nativeGlob.join(';')}`,
+        `-DHEADER_GLOB=${headerGlob.join(';')}`,
+        `-DHEADER_DIR=${headerDirs.join(';')}`,
+        `-DDEPENDS_CMAKE_PATHS=${dependParams.getCmakeDependsPathAndName(target).pathsOfCmakeDepends.join(';')}`,
+        `-DDEPENDS_CMAKE_NAMES=${dependParams.getCmakeDependsPathAndName(target).nameOfCmakeDepends.join(';')}`,
+        `-DBRIDGE_DIR=${state.config.paths.build}/bridge`,
+        `-DBUILD_TYPE=${buildType}`,
+        `-DBUILD_${otherBuildType}_LIBS=OFF`,
+        `-DCOMPILE_OPTIONS=${cmakeCompileOptions.join(';')}`,
+        // '-DCMAKE_CXX_COMPILER_LAUNCHER=ccache',
+        ...(options.buildSource !== false ? ['-DBUILD_SOURCE=TRUE'] : []),
+    ]);
+
+    return params;
+}

package/src/actions/getData.js

@@ -0,0 +1,46 @@
+import fs from 'node:fs';
+import state from '../state/index.js';
+import { getFilteredTargetSpec, getBuildTargets } from './target.js';
+
+function getRecursiveData(obj, config, dependency, field, target) {
+    const entryArray = getFilteredTargetSpec(dependency?.targetSpecs, target).map(s => s[field]);
+    const entries = Object.assign({}, ...entryArray);
+    Object.entries(entries).forEach(([dKey, value]) => {
+        if (field === 'data') {
+            let key;
+            if (fs.existsSync(`${dependency.paths.output}/prebuilt/${target.path}`)) {
+                key = `${dependency.paths.output}/prebuilt/${target.path}/${dKey}`;
+            } else {
+                const releaseTarget = getBuildTargets({
+                    platform: [target.platform], arch: [target.arch], runtime: [target.runtime],
+                    runtimeEnv: [target.runtimeEnv], buildType: ['release']
+                })?.[0];
+                if (releaseTarget) {
+                    key = `${dependency.paths.output}/prebuilt/${releaseTarget.path}/${dKey}`;
+                } else {
+                    throw new Error('Data not found');
+                }
+            }
+            obj[key] = value;
+        } else {
+            if (typeof value === 'object' && Array.isArray(value)) {
+                obj[dKey] = [...(obj[dKey] || []), ...value];
+            } else if (typeof value === 'object') {
+                obj[dKey] = { ...(obj[dKey] || {}), ...value };
+            } else {
+                obj[dKey] = value;
+            }
+        }
+    });
+
+    dependency.dependencies.forEach((dep) => {
+        getRecursiveData(obj, config, dep, field, target);
+    });
+}
+
+export default function getData(field, target) {
+    const output = {};
+    getRecursiveData(output, state.config, state.config, field, target);
+
+    return output;
+}

package/src/actions/getDependLibs.js

@@ -0,0 +1,25 @@
+import findFiles from '../utils/findFiles.js';
+import state from '../state/index.js';
+import { getFilteredTargetSpec } from './target.js';
+
+export default function getDependLibs(target) {
+    let dependLibs = [
+        ...findFiles(`${state.config.paths.build}/Source-Release/${target.path}/dependencies/**/*.a`, { cwd: state.config.paths.project }),
+    ];
+    state.config.dependencyParameters.getCmakeDepends(target).forEach((d) => {
+        if (d.export.libName) {
+            const ignoreLibNames = getFilteredTargetSpec(d?.targetSpecs, target).map(s => s.ignoreLibName).flat();
+            d.export.libName.forEach((fileName) => {
+                if (ignoreLibNames?.includes(fileName)) return;
+                let libPaths = findFiles(`${d.paths.output}/prebuilt/${target.path}/lib/lib${fileName}.a`, { cwd: d.paths.project });
+                if (libPaths.length === 0) {
+                    libPaths = findFiles(`${d.paths.output}/prebuilt/${target.releasePath}/lib/lib${fileName}.a`, { cwd: d.paths.project });
+                }
+                dependLibs.push(...libPaths);
+            });
+        }
+    });
+
+    dependLibs = [...new Set(dependLibs)];
+    return dependLibs;
+}

package/src/actions/isSourceNewer.js

@@ -0,0 +1,35 @@
+import fs from 'node:fs';
+import p from 'node:path';
+import state from '../state/index.js';
+
+function newestMtimeInDir(dir) {
+    let newest = 0;
+    if (!fs.existsSync(dir)) return newest;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = p.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            const m = newestMtimeInDir(full);
+            if (m > newest) newest = m;
+        } else if (entry.isFile()) {
+            const m = fs.statSync(full).mtimeMs;
+            if (m > newest) newest = m;
+        }
+    }
+    return newest;
+}
+
+// "Did any native source change after this artifact was produced?" - artifact is a file
+// (bundler plugins: the built js) or a directory (CLI lib cache: the staged prebuilt dir).
+export function isNativeSourceNewerThan(artifactPath) {
+    if (!fs.existsSync(artifactPath)) return false;
+    const stat = fs.statSync(artifactPath);
+    const artifactMtime = stat.isDirectory() ? newestMtimeInDir(artifactPath) : stat.mtimeMs;
+    for (const dir of state.config.paths.native) {
+        if (newestMtimeInDir(dir) > artifactMtime) return true;
+    }
+    return false;
+}
+
+export default function isSourceNewer(target) {
+    return isNativeSourceNewerThan(`${state.config.paths.build}/${target.jsName}`);
+}