crossbind 0.0.1 → 2.0.0-beta.50

package/src/integration/getDependFilePath.js

@@ -0,0 +1,132 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import state from '../state/index.js';
+
+const LAYOUT = { header: 'include', module: 'swig', source: '' };
+
+let extRegexCache = { key: null, header: null, module: null };
+function getExtRegex() {
+    const { header, module } = state.config.ext;
+    const key = `${header.join(',')}|${module.join(',')}`;
+    if (extRegexCache.key !== key) {
+        extRegexCache = {
+            key,
+            header: new RegExp(`\\.(${header.join('|')})$`),
+            module: new RegExp(`\\.(${module.join('|')})$`),
+        };
+    }
+    return extRegexCache;
+}
+
+const existsCache = new Map();
+function existsCached(p) {
+    if (existsCache.has(p)) return existsCache.get(p);
+    const result = fs.existsSync(p);
+    existsCache.set(p, result);
+    return result;
+}
+
+function getAlias(pkg) {
+    const a = pkg.general.alias;
+    if (!a) return null;
+    if (typeof a !== 'object' || !a.package) {
+        throw new Error(
+            `Invalid alias for package "${pkg.package.name}": expected { package, lib? }.`,
+        );
+    }
+    return {
+        package: a.package,
+        lib: a.lib ?? a.package.replace(/[^a-zA-Z0-9]/g, ''),
+    };
+}
+
+function getMatchingPackages(source) {
+    const matches = [];
+    for (const pkg of state.config.allDependencies) {
+        const alias = getAlias(pkg);
+        const prefixes = [pkg.package.name];
+        if (alias) prefixes.push(alias.package);
+
+        for (const prefix of prefixes) {
+            if (source === prefix || source.startsWith(`${prefix}/`)) {
+                matches.push({
+                    pkg,
+                    alias,
+                    relativePath: source.slice(prefix.length + 1),
+                });
+                break;
+            }
+        }
+    }
+    return matches;
+}
+
+function getLayoutSubdir(source) {
+    const ext = getExtRegex();
+    if (ext.header.test(source)) return LAYOUT.header;
+    if (ext.module.test(source)) return LAYOUT.module;
+    return LAYOUT.source;
+}
+
+function getFolderCandidates(pkg, alias) {
+    const candidates = [];
+    if (alias) candidates.push(alias.lib);
+    candidates.push(pkg.general.name, pkg.package.name, '');
+    return [...new Set(candidates)];
+}
+
+export default function getDependFilePath(source, target) {
+    // `cargo:<crate>` imports (the node:/npm: convention for a non-npm store) resolve to a
+    // generated marker .rs; the transformer turns it into the crate-import bridge (no surface
+    // file, no package). The scheme is unambiguous, so npm names never collide and an
+    // undeclared crate is a hard, actionable error instead of a silent npm fallthrough.
+    if (source.startsWith('cargo:')) {
+        const crateName = source.slice('cargo:'.length);
+        const cargoDeps = state.config.cargoDependencies ?? {};
+        if (!Object.hasOwn(cargoDeps, crateName)) {
+            throw new Error(`crossbind: '${source}' is not declared - add '${crateName}' to cargoDependencies in crossbind.config.`);
+        }
+        const marker = path.join(state.config.paths.cache, 'rust-crates', `${crateName}.rs`);
+        if (!fs.existsSync(marker)) {
+            fs.mkdirSync(path.dirname(marker), { recursive: true });
+            fs.writeFileSync(marker, `// crossbind cargo crate import marker: ${crateName}\n`);
+        }
+        existsCache.set(marker, true);
+        return marker;
+    }
+
+    const matches = getMatchingPackages(source);
+    if (matches.length === 0) return null;
+
+    const subdir = getLayoutSubdir(source);
+    const tried = [];
+
+    for (const { pkg, alias, relativePath } of matches) {
+        // A cargo package's bare import resolves to its crate root source; the bundler
+        // transformer then turns that .rs into the generated JS proxy module (Rust's .h analog).
+        if (pkg.export?.type === 'cargo' && relativePath === '') {
+            const libRs = path.resolve(pkg.paths.project, pkg.export.crate ?? 'crate', 'src/lib.rs');
+            if (existsCached(libRs)) return libRs;
+        }
+        const prebuiltRoot = `${pkg.paths.output}/prebuilt/${target.path}`;
+        // Skip packages that don't produce artifacts for this target — multiple
+        // packages may share the same alias (one per platform), so this filters
+        // out the wrong-platform matches without needing explicit metadata.
+        if (!existsCached(prebuiltRoot)) continue;
+
+        const baseDir = subdir ? `${prebuiltRoot}/${subdir}` : prebuiltRoot;
+        for (const candidate of getFolderCandidates(pkg, alias)) {
+            const fullPath = candidate
+                ? `${baseDir}/${candidate}/${relativePath}`
+                : `${baseDir}/${relativePath}`;
+            tried.push(fullPath);
+            if (existsCached(fullPath)) return fullPath;
+        }
+    }
+
+    const matchNames = matches.map((m) => m.pkg.package.name).join(', ');
+    throw new Error(
+        `Could not resolve "${source}" in package(s) [${matchNames}] for target "${target.path}". Tried:\n`
+        + tried.map((t) => `  - ${t}`).join('\n'),
+    );
+}

package/src/runtime/wasiRun.mjs

@@ -0,0 +1,118 @@
+// Runtime behind the generated `<tool>-wasi` shims in -bin packages. Everything resolves
+// from crossbind's own sources of truth at call time: the target matrix (utils/targets.js)
+// and the package's crossbind.config.js graph (data/env targetSpecs) - no baked paths.
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { TARGETS, targetPathOf, filterTargetSpecs } from '../utils/targets.js';
+
+const DATA_ROOT = '/data';
+const FORWARDED_ENV = /^(GDAL_|PROJ_|CPL_|OGR_|VSI|CURL_|SSL_)/;
+
+function walkConfigGraph(config) {
+    const nodes = [];
+    const seen = new Set();
+    const visit = (node) => {
+        if (!node?.general?.name || seen.has(node.general.name)) return;
+        seen.add(node.general.name);
+        nodes.push(node);
+        (node.dependencies ?? []).forEach(visit);
+    };
+    visit(config);
+    return nodes;
+}
+
+function prebuiltOf(node, targetPath) {
+    const nodeDir = dirname(fileURLToPath(node.paths.config));
+    return join(nodeDir, node.paths?.output ?? 'dist', 'prebuilt', targetPath);
+}
+
+// Blocks layer onto each other: a wasi-only env block adds to the platform-agnostic one
+// instead of replacing it, which a plain Object.assign of the blocks would do.
+export function mergeSpecs(targetSpecs, target) {
+    const matched = filterTargetSpecs(targetSpecs, target);
+    return {
+        ...Object.assign({}, ...matched),
+        data: Object.assign({}, ...matched.map((s) => s.data ?? {})),
+        env: Object.assign({}, ...matched.map((s) => s.env ?? {})),
+    };
+}
+
+export async function run(stubUrl, tool) {
+    const pkgDir = join(dirname(fileURLToPath(stubUrl)), '..');
+
+    const probe = spawnSync('wasmtime', ['--version'], { stdio: 'ignore' });
+    if (probe.error) {
+        console.error(`${tool}-wasi: wasmtime not found on PATH - install it first (https://wasmtime.dev or \`brew install wasmtime\`).`);
+        process.exit(127);
+    }
+
+    const config = (await import(pathToFileURL(join(pkgDir, 'crossbind.config.js')).href)).default;
+    const wasiTargets = TARGETS.filter((candidate) => candidate.platform === 'wasi');
+    const target = wasiTargets.find((candidate) => existsSync(join(pkgDir, config.paths?.output ?? 'dist', 'prebuilt', targetPathOf(candidate))))
+        ?? wasiTargets[0];
+    const targetPath = targetPathOf(target);
+    const own = prebuiltOf(config, targetPath);
+
+    // Three states from the single-source bin map (recipe-derived crossbind-bin.json).
+    const binJson = join(own, 'crossbind-bin.json');
+    if (!existsSync(binJson)) {
+        console.error(`${tool}-wasi: no prebuilt found under ${own} - build it first: pnpm --dir ${pkgDir} build`);
+        process.exit(1);
+    }
+    const tools = JSON.parse(readFileSync(binJson, 'utf8')).tools ?? {};
+    if (!(tool in tools)) {
+        console.error(`${tool}-wasi: '${tool}' is not in this package's tool map.`);
+        console.error(`known tools: ${Object.keys(tools).join(', ') || '(none)'}`);
+        process.exit(1);
+    }
+    // multicall-entry tools live inside the single kind:"binary" host; its dispatcher reads argv[1].
+    const isMulticall = tools[tool].kind === 'multicall-entry';
+    const hostTool = Object.keys(tools).find((name) => tools[name].kind === 'binary');
+    const wasmFile = join(own, 'bin', isMulticall ? hostTool : tool);
+    if (!existsSync(wasmFile)) {
+        const shipped = Object.entries(tools).filter(([, entry]) => entry.publish).map(([name]) => name);
+        console.error(`${tool}-wasi: '${tool}' is known but not part of this install.`);
+        console.error(`the npm build ships: ${shipped.join(', ') || '(none)'}`);
+        console.error(`to get the full set, build from source: pnpm --dir ${pkgDir} build  (needs docker or a wasi-sdk)`);
+        process.exit(1);
+    }
+
+    // Declared data/env from the config graph - the same targetSpecs the build consumes.
+    const mounts = [];
+    const mounted = new Set();
+    const guestEnv = {};
+    for (const node of walkConfigGraph(config)) {
+        const prebuilt = prebuiltOf(node, targetPath);
+        const specs = mergeSpecs(node.targetSpecs, target);
+        for (const [source, name] of Object.entries(specs.data ?? {})) {
+            const hostDir = join(prebuilt, source);
+            if (mounted.has(name) || !existsSync(hostDir)) continue;
+            mounted.add(name);
+            mounts.push(`--dir=${hostDir}::${DATA_ROOT}/${name}`);
+        }
+        for (const [key, value] of Object.entries(specs.env ?? {})) {
+            // Function-valued env entries need CLI state (wasm loaders evaluate them); skip here.
+            if (typeof value === 'function' || key in process.env || key in guestEnv) continue;
+            guestEnv[key] = String(value).replaceAll('_CROSSBIND_DATA_PATH_', DATA_ROOT);
+        }
+    }
+    for (const [key, value] of Object.entries(process.env)) {
+        if (FORWARDED_ENV.test(key)) guestEnv[key] = value;
+    }
+
+    // Only the host cwd is preopened; absolute host paths stay invisible by design.
+    const args = [
+        'run',
+        '-S', 'inherit-network=y', '-S', 'allow-ip-name-lookup=y', '-S', 'tcp=y',
+        '--dir=.',
+        ...mounts,
+        ...Object.entries(guestEnv).flatMap(([key, value]) => ['--env', `${key}=${value}`]),
+        wasmFile,
+        ...(isMulticall ? [tool] : []),
+        ...process.argv.slice(2),
+    ];
+    const result = spawnSync('wasmtime', args, { stdio: 'inherit' });
+    process.exit(result.status ?? 1);
+}

package/src/state/calculateDependencyParameters.js

@@ -0,0 +1,97 @@
+import fs from 'node:fs';
+import logger from '../utils/logger.js';
+
+export default function calculateDependencyParameters(config) {
+    const sourceFilter = (d) => d === config || d.export.type === 'source';
+    let headerPathWithDepends = [];
+    setPath(headerPathWithDepends, config, 'header', sourceFilter);
+    headerPathWithDepends = [...new Set(headerPathWithDepends)].join(';');
+
+    const headerGlob = [];
+    headerPathWithDepends.split(';').forEach((h) => {
+        config.ext.header.forEach((ext) => {
+            headerGlob.push(`${h}/*.${ext}`);
+        });
+    });
+
+    let nativePathWithDepends = [];
+    setPath(nativePathWithDepends, config, 'native', sourceFilter);
+    nativePathWithDepends = [...new Set(nativePathWithDepends)].join(';');
+
+    const nativeGlob = [];
+    nativePathWithDepends.split(';').forEach((h) => {
+        config.ext.source.forEach((ext) => {
+            nativeGlob.push(`${h}/*.${ext}`);
+        });
+    });
+
+    // Cargo packages expose the same generated dist/prebuilt CMakeLists as cmake packages, so
+    // they join the cmake depends graph (this is how their .a reaches the android link).
+    const cmakeFilter = (d) => d !== config && (d.export.type === 'cmake' || d.export.type === 'cargo') && d.paths.cmake !== config.paths.cliCMakeListsTxt;
+    let cmakeDepends = [];
+    setPath(cmakeDepends, config, 'this', cmakeFilter);
+    cmakeDepends = [...new Set(cmakeDepends)];
+
+    const getCmakeDepends = (target, variants = []) => {
+        return cmakeDepends.filter(d => d.functions.isEnabled(target, variants));
+    };
+
+    // A dependency that resolves to no prebuilt for this target drops out of the link list.
+    // For platform-split packages (a port's -android / -ios sibling) that is normal - only one
+    // of them serves any given build. A cargo package has no such split: one package carries
+    // every target, so a missing one means its artifacts were never built, and linking without
+    // it produces a binary that builds clean and dies at init.
+    const assertDependsBuilt = (target, variants) => {
+        cmakeDepends.filter((d) => !d.functions.isEnabled(target, variants)).forEach((d) => {
+            if (d.export.type === 'cargo') {
+                throw new Error(`crossbind: dependency "${d.general.name}" has no prebuilt for ${target.path} `
+                    + `(looked in ${d.paths.cmakeDir}). Build it for this target before building the app.`);
+            }
+            if (!fs.existsSync(d.paths.cmakeDir)) {
+                logger.info(`crossbind: dependency "${d.general.name}" has no prebuilt artifacts at all `
+                    + `(${d.paths.cmakeDir} missing) - excluded from the ${target.platform} link.`);
+            }
+        });
+    };
+
+    const getCmakeDependsPathAndName = (target, variants = []) => {
+        assertDependsBuilt(target, variants);
+        const pathsOfCmakeDepends = [];
+        const nameOfCmakeDepends = [];
+        getCmakeDepends(target, variants).forEach((d) => {
+            const dependPath = d.paths.cmakeDir;
+            if (!pathsOfCmakeDepends.includes(dependPath)) {
+                pathsOfCmakeDepends.push(dependPath);
+                nameOfCmakeDepends.push(d.general.name);
+            }
+        });
+        return {
+            pathsOfCmakeDepends: pathsOfCmakeDepends,
+            nameOfCmakeDepends: nameOfCmakeDepends,
+        };
+    }
+
+    return {
+        nativeGlob,
+        headerGlob,
+        headerPathWithDepends,
+        getCmakeDepends,
+        getCmakeDependsPathAndName,
+    };
+}
+
+function setPath(arr, dependency, type, filter = () => { }) {
+    if (filter(dependency)) {
+        if (type === 'this') {
+            arr.push(dependency);
+        } else if (Array.isArray(dependency.paths[type])) {
+            arr.push(...dependency.paths[type]);
+        } else {
+            arr.push(dependency.paths[type]);
+        }
+    }
+
+    dependency.dependencies.forEach((dep) => {
+        setPath(arr, dep, type, filter);
+    });
+}

package/src/state/index.js

@@ -0,0 +1,128 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import loadJson from '../utils/loadJson.js';
+import writeJson from '../utils/writeJson.js';
+import { TARGETS, targetPathOf } from '../utils/targets.js';
+import loadConfig from './loadConfig.js';
+
+const cacheDir = `${process.cwd()}/.crossbind`;
+
+const state = {
+    targets: TARGETS.map((target) => ({ ...target })),
+    config: null,
+    cache: {
+        hashes: {},
+        interfaces: {},
+        bridges: {},
+    },
+};
+
+await initProcessState();
+
+async function initProcessState() {
+    state.cache = loadCacheState();
+    state.config = await loadConfig();
+    // Recipes read the wasi-sdk location from the environment (lazily, in
+    // getBuildParams); mirror the system-config value there so both sources
+    // behave the same.
+    if (state.config.system.WASI_SDK_PATH && !process.env.CROSSBIND_WASI_SDK_PATH) {
+        process.env.CROSSBIND_WASI_SDK_PATH = state.config.system.WASI_SDK_PATH;
+    }
+    // Same idea for the docker image overrides: pullDockerImage.js resolves them from the
+    // environment alone, so it stays free of a state import (and of the cycle that would create).
+    Object.entries({
+        DOCKER_REGISTRY_MIRROR: 'CROSSBIND_REGISTRY_MIRROR',
+        DOCKER_IMAGE_WEB: 'CROSSBIND_IMAGE_WEB',
+        DOCKER_IMAGE_ANDROID: 'CROSSBIND_IMAGE_ANDROID',
+    }).forEach(([key, envKey]) => {
+        if (state.config.system[key] && !process.env[envKey]) {
+            process.env[envKey] = state.config.system[key];
+        }
+    });
+
+    state.targets.forEach((target) => {
+        target.path = targetPathOf(target);
+        target.releasePath = targetPathOf({ ...target, buildType: 'release' });
+        if (target.runtimeEnv && target.platform === 'wasm') {
+            target.rawJsName = `${state.config.general.name}-${target.path}.${target.runtimeEnv}.js`;
+            target.jsName = `${state.config.general.name}-${target.path}.${target.runtimeEnv}.js`;
+            target.wasmName = `${state.config.general.name}-${target.path}.${target.runtimeEnv}.wasm`;
+            target.dataName = `${state.config.general.name}-${target.path}.${target.runtimeEnv}.data`;
+            target.dataTxtName = `${state.config.general.name}-${target.path}.${target.runtimeEnv}.data.txt`;
+        }
+        if (target.platform === 'wasi') {
+            // A wasi build is a single command module - no JS glue, no preload.
+            target.wasmName = `${state.config.general.name}-${target.path}.wasm`;
+        }
+    });
+
+    setAllDependecyPaths();
+
+    // Bare cargo-crate import markers must exist BEFORE any bundler starts: metro resolves
+    // against its startup file map, so a marker first created mid-resolution is invisible
+    // to that very build.
+    const cargoDeps = state.config.cargoDependencies ?? {};
+    for (const name of Object.keys(cargoDeps)) {
+        const marker = `${state.config.paths.cache}/rust-crates/${name}.rs`;
+        if (!fs.existsSync(marker)) {
+            fs.mkdirSync(path.dirname(marker), { recursive: true });
+            fs.writeFileSync(marker, `// crossbind cargo crate import marker: ${name}\n`);
+        }
+    }
+
+    if (state.config.build?.setState) {
+        state.config.build.setState(state);
+    }
+}
+
+function loadCacheState() {
+    const stateFilePath = `${cacheDir}/cache.json`;
+    return loadJson(stateFilePath) || state.cache;
+}
+
+export function setAllDependecyPaths() {
+    state.config.allDependencyPaths = {};
+    state.targets.forEach((target) => {
+        state.config.allDependencyPaths[target.path] = { cmake: {} };
+        state.config.allDependencies.forEach((d) => {
+            state.config.allDependencyPaths[target.path].cmake[d.general.name] = `${d.paths.output}/prebuilt`;
+            d.export.libName.forEach((name) => {
+                state.config.allDependencyPaths[target.path][name] = {
+                    root: `${d.paths.output}/prebuilt/${target.path}`,
+                };
+                const entryArray = d?.targetSpecs?.filter(t => (
+                    (!t.platform || t.platform === target.platform)
+                    && (!t.arch || t.arch === target.arch)
+                    && (!t.runtime || t.runtime === target.runtime)
+                    && (!t.buildType || t.buildType === target.buildType)
+                )).map(t => t?.specs);
+                const platformConfig = Object.assign({}, ...entryArray);
+                const isDynamicLib = target.platform === 'android' && platformConfig.libType !== 'static';
+                const dep = state.config.allDependencyPaths[target.path][name];
+                if (target.platform === 'ios') {
+                    let xcRoot;
+                    if (target.arch === 'iphoneos') {
+                        xcRoot = `${d.paths.project}/${name}.xcframework/ios-arm64`;
+                    } else if (target.arch === 'iphonesimulator') {
+                        xcRoot = `${d.paths.project}/${name}.xcframework/ios-arm64-simulator`;
+                    }
+                    dep.header = `${xcRoot}/Headers`;
+                    dep.libPath = xcRoot;
+                    dep.lib = `${dep.libPath}/lib${name}.a`;
+                    dep.bin = `${dep.root}/bin`;
+                } else {
+                    dep.header = `${dep.root}/include`;
+                    dep.libPath = `${dep.root}/lib`;
+                    dep.lib = `${dep.libPath}/lib${name}.${isDynamicLib ? 'so' : 'a'}`;
+                    dep.bin = `${dep.root}/bin`;
+                }
+            });
+        });
+    });
+}
+
+export function saveCache() {
+    writeJson(`${cacheDir}/cache.json`, state.cache);
+}
+
+export default state;