crossbind 2.0.0-beta.60 → 2.0.0-beta.62

package/src/utils/headerImports.js

@@ -0,0 +1,45 @@
+import fs from 'node:fs';
+import appSourceFiles from './appSources.js';
+
+// `import * as x` and `export *` take every name the header exports.
+export const ALL_NAMES = '*';
+
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+// The clause shapes are spelled out, so a match cannot run from one statement into the next.
+const HEADER_IMPORT = /\b(import|export)\s+(type\s+)?((?:[A-Za-z_$][\w$]*\s*,\s*)?(?:\{[^}]*\}|\*(?:\s*as\s+[A-Za-z_$][\w$]*)?)|[A-Za-z_$][\w$]*)\s*from\s*(['"])([^'"\n]+)\4/g;
+
+function listedNames(list) {
+    return list.replace(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, '').split(',')
+        .map((entry) => entry.trim())
+        .filter((entry) => entry && !/^type\s/.test(entry))
+        .map((entry) => entry.split(/\s+as\s+/)[0])
+        .filter((name) => name !== 'default' && IDENTIFIER.test(name));
+}
+
+// A specifier built at run time is not found.
+export function findHeaderImports(text, headerExtensions) {
+    const isHeader = new RegExp(`\\.(${headerExtensions.join('|')})$`);
+    return [...text.matchAll(HEADER_IMPORT)].flatMap(([, , type, clause, , specifier]) => {
+        if (type || !isHeader.test(specifier)) return [];
+        const list = clause.match(/\{([^}]*)\}/);
+        if (clause.replace(list?.[0] ?? '', '').includes('*')) return [{ specifier, names: ALL_NAMES }];
+        const names = listedNames(list?.[1] ?? '');
+        return names.length ? [{ specifier, names }] : [];
+    });
+}
+
+const scanned = new Map();
+
+// A source is read again only when its size or modification time changed.
+export function findHeaderImportsIn(projectDir, headerExtensions) {
+    const extensions = headerExtensions.join(',');
+    return appSourceFiles(projectDir).flatMap((importer) => {
+        const { mtimeMs, size } = fs.statSync(importer);
+        const cached = scanned.get(importer);
+        if (cached?.mtimeMs !== mtimeMs || cached.size !== size || cached.extensions !== extensions) {
+            const imports = findHeaderImports(fs.readFileSync(importer, 'utf8'), headerExtensions);
+            scanned.set(importer, { mtimeMs, size, extensions, imports });
+        }
+        return scanned.get(importer).imports.map((found) => ({ importer, ...found }));
+    });
+}

package/src/utils/inputStamp.js

@@ -21,6 +21,29 @@ export function collectInputFiles(roots, exts, extraFiles = []) {
     return [...files].filter((file) => fs.existsSync(file)).sort();
 }
 
+// A cargo target dir holds build-script output, which changes on every build.
+const RUST_EXCLUDED_DIRS = [...EXCLUDED_DIRS, 'target'];
+
+// An app-local .rs file reaches its generated bridge through #[path], so the bridge text stays
+// the same across a body edit: the sources themselves have to be stamped.
+export function collectRustSources(roots) {
+    const files = new Set();
+    [...new Set(roots)].forEach((root) => {
+        findFiles('**/*.rs', {
+            cwd: root,
+            ignore: RUST_EXCLUDED_DIRS.map((dir) => `**/${dir}/**`),
+        }).forEach((file) => files.add(file));
+    });
+    return [...files].sort();
+}
+
+export function collectRustBridgeFiles(cacheDir) {
+    return [
+        ...findFiles('rust-bridges/*/{Cargo.toml,src/lib.rs}', { cwd: cacheDir }),
+        ...findFiles('rust-crates/*.rs', { cwd: cacheDir }),
+    ].sort();
+}
+
 export function computeInputStamp(roots, exts, extraFiles, salt) {
     const lines = collectInputFiles(roots, exts, extraFiles).map((file) => `${file}:${getFileHash(file)}`);
     lines.push(salt);

package/src/utils/linkLayout.js

@@ -13,7 +13,9 @@ export function libNameOf(libPath) {
     return match ? match[1] : base;
 }
 
-export function buildLinkLibArgs(libs, { wholeArchiveAll = false, wholeArchiveNames = new Set(), wrapLast = true } = {}) {
+export function buildLinkLibArgs(libs, {
+    wholeArchiveAll = false, wholeArchiveNames = new Set(), wrapLast = true, forceLoad = false,
+} = {}) {
     const args = [];
     let wrapped = false;
     libs.forEach((lib, index) => {
@@ -21,6 +23,11 @@ export function buildLinkLibArgs(libs, { wholeArchiveAll = false, wholeArchiveNa
         // have no bridge (main() is the GC root), so they pass false.
         const isBridge = wrapLast && index === libs.length - 1;
         const wantWrap = wholeArchiveAll || isBridge || wholeArchiveNames.has(libNameOf(lib));
+        // Apple's ld64 has no --whole-archive groups; it keeps archives one at a time.
+        if (forceLoad) {
+            args.push(wantWrap ? `-Wl,-force_load,${lib}` : lib);
+            return;
+        }
         if (wantWrap !== wrapped) {
             args.push(wantWrap ? '-Wl,--whole-archive' : '-Wl,--no-whole-archive');
             wrapped = wantWrap;

package/src/utils/pullDockerImage.js

@@ -7,8 +7,11 @@ import { getContentHash } from './hash.js';
 const table = createRequire(import.meta.url)('../assets/toolchain-digests.json');
 const REGISTRY = table.registry;
 const IMAGE_VERSION = table.version;
+const OVERRIDE_KEYS = {
+    web: 'CROSSBIND_IMAGE_WEB', android: 'CROSSBIND_IMAGE_ANDROID', linux: 'CROSSBIND_IMAGE_LINUX', windows: 'CROSSBIND_IMAGE_WINDOWS',
+};
 const IMAGES = Object.fromEntries(
-    ['web', 'android'].map((role) => [
+    Object.keys(OVERRIDE_KEYS).map((role) => [
         role,
         {
             ref: `${REGISTRY}/${role}@${table.images[role].index}`,
@@ -17,11 +20,11 @@ const IMAGES = Object.fromEntries(
     ]),
 );
 
-const OVERRIDE_KEYS = { web: 'CROSSBIND_IMAGE_WEB', android: 'CROSSBIND_IMAGE_ANDROID' };
-
-// Which image a target compiles in: wasm and wasi share the web image, ios never reaches docker.
+// Which image a target compiles in: wasm and wasi share the web image, ios and darwin never reach docker.
 export function imageRoleFor(target) {
-    return target?.platform === 'android' ? 'android' : 'web';
+    if (target?.platform === 'android' || target?.platform === 'linux') return target.platform;
+    if (target?.platform === 'win32') return 'windows';
+    return 'web';
 }
 
 const warned = new Set();

package/src/utils/resolveCompanionPackage.js

@@ -0,0 +1,51 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import state from '../state/index.js';
+
+// The binding runtimes ship as their own packages and the ENGINE never depends on them: the
+// consumer declares one - directly, or transitively through a platform plugin - and the engine
+// only resolves it. pnpm keeps transitive deps unhoisted, so resolution may need to hop through
+// the declaring plugin; inside this monorepo the package sits next to the engine under core/.
+export default function createCompanionResolver({
+    pkg, anchors = [], siblingDir, siblingMarker, missingMessage,
+}) {
+    let cached = null;
+
+    const resolveFrom = (baseDir) => {
+        try {
+            const req = createRequire(path.join(baseDir, 'package.json'));
+            return path.dirname(fs.realpathSync(req.resolve(`${pkg}/package.json`)));
+        } catch (e) {
+            return null;
+        }
+    };
+
+    return function resolveCompanionRoot() {
+        if (cached) return cached;
+
+        const project = state.config?.paths?.project;
+        let root = project ? resolveFrom(project) : null;
+        if (!root && project) {
+            for (const anchor of anchors) {
+                try {
+                    const req = createRequire(path.join(project, 'package.json'));
+                    const anchorDir = path.dirname(fs.realpathSync(req.resolve(`${anchor}/package.json`)));
+                    root = resolveFrom(anchorDir);
+                    if (root) break;
+                } catch (e) { /* this plugin is not installed - try the next anchor */ }
+            }
+        }
+        if (!root) {
+            const here = path.dirname(fileURLToPath(import.meta.url));
+            const sibling = path.resolve(here, '../../..', siblingDir);
+            if (fs.existsSync(`${sibling}/${siblingMarker}`)) root = sibling;
+        }
+        if (!root) {
+            throw new Error(missingMessage);
+        }
+        cached = root;
+        return root;
+    };
+}

package/src/utils/resolveEmbindNapi.js

@@ -0,0 +1,22 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import createCompanionResolver from './resolveCompanionPackage.js';
+
+const PKG = '@crossbind/core-embind-napi';
+
+const resolveEmbindNapiRoot = createCompanionResolver({
+    pkg: PKG,
+    siblingDir: 'embind-napi',
+    siblingMarker: 'cpp/src/node_api_module.cpp',
+    missingMessage: `crossbind: native Node.js builds need ${PKG} - add it to your devDependencies.`,
+});
+
+export default resolveEmbindNapiRoot;
+
+// The embind runtime itself ships in @crossbind/core-embind-jsi, a dependency of the Node-API
+// package, so it resolves from there.
+export function resolveEmbindJsiRoot() {
+    const req = createRequire(path.join(resolveEmbindNapiRoot(), 'package.json'));
+    return path.dirname(fs.realpathSync(req.resolve('@crossbind/core-embind-jsi/package.json')));
+}

package/src/utils/resolveEmbindRust.js

@@ -1,60 +1,25 @@
 import fs from 'node:fs';
-import path from 'node:path';
-import { createRequire } from 'node:module';
-import { fileURLToPath } from 'node:url';
-import state from '../state/index.js';
+import createCompanionResolver from './resolveCompanionPackage.js';
 
-// The Rust producer crate + adapters ship in @crossbind/core-embind-rust. The ENGINE never
-// depends on it (same direction rule as core-embind-jsi): the consumer declares it - directly,
-// or transitively through a platform plugin - and the engine only resolves it. pnpm keeps
-// transitive deps unhoisted, so resolution may need to hop through the declaring plugin.
+// The Rust producer crate + adapters ship in @crossbind/core-embind-rust (same direction rule as
+// core-embind-jsi: the consumer declares it, the engine only resolves it).
 const PKG = '@crossbind/core-embind-rust';
-const PLUGIN_ANCHORS = [
-    '@crossbind/plugin-react-native',
-    '@crossbind/plugin-vite',
-    '@crossbind/plugin-rollup',
-    '@crossbind/plugin-metro',
-    '@crossbind/plugin-webpack',
-];
 
-let cached = null;
+const resolveEmbindRustRoot = createCompanionResolver({
+    pkg: PKG,
+    anchors: [
+        '@crossbind/plugin-react-native',
+        '@crossbind/plugin-vite',
+        '@crossbind/plugin-rollup',
+        '@crossbind/plugin-metro',
+        '@crossbind/plugin-webpack',
+    ],
+    siblingDir: 'embind-rust',
+    siblingMarker: 'crate/Cargo.toml',
+    missingMessage: `crossbind: Rust bindings need ${PKG} - add it to your (dev)dependencies.`,
+});
 
-export default function resolveEmbindRustRoot() {
-    if (cached) return cached;
-
-    const resolveFrom = (baseDir) => {
-        try {
-            const req = createRequire(path.join(baseDir, 'package.json'));
-            return path.dirname(fs.realpathSync(req.resolve(`${PKG}/package.json`)));
-        } catch (e) {
-            return null;
-        }
-    };
-
-    const project = state.config?.paths?.project;
-    let root = project ? resolveFrom(project) : null;
-    if (!root && project) {
-        for (const anchor of PLUGIN_ANCHORS) {
-            try {
-                const req = createRequire(path.join(project, 'package.json'));
-                const anchorDir = path.dirname(fs.realpathSync(req.resolve(`${anchor}/package.json`)));
-                root = resolveFrom(anchorDir);
-                if (root) break;
-            } catch (e) { /* this plugin is not installed - try the next anchor */ }
-        }
-    }
-    if (!root) {
-        // Monorepo layout: the package ships next to the engine.
-        const here = path.dirname(fileURLToPath(import.meta.url));
-        const sibling = path.resolve(here, '../../../embind-rust');
-        if (fs.existsSync(`${sibling}/crate/Cargo.toml`)) root = sibling;
-    }
-    if (!root) {
-        throw new Error(`crossbind: Rust bindings need ${PKG} - add it to your (dev)dependencies.`);
-    }
-    cached = root;
-    return root;
-}
+export default resolveEmbindRustRoot;
 
 // The package version, stamped into generated bridge manifests for debuggability.
 export function embindRustVersion() {

package/src/utils/runCargo.js

@@ -7,6 +7,7 @@ import getOsUserAndGroupId from './getOsUserAndGroupId.js';
 import replaceBasePathForDockerUtil, { DOCKER_BASE } from './replaceBasePathForDocker.js';
 import pullDockerImage, { getDockerImage, getDockerContainerName, imageRoleFor } from './pullDockerImage.js';
 import { DOCKER_RUN_SECURITY_ARGS } from './dockerSecurity.js';
+import { HOST_BUILT_PLATFORMS } from './targets.js';
 
 // Every cargo invocation crossbind makes goes through here.
 //
@@ -107,10 +108,10 @@ export function assertCleanConfigChain(home, cwd) {
     }
 }
 
-// iOS links with Xcode, which is in no image, so its Rust stays on the host - as does every build
-// under RUNNER=LOCAL.
+// Apple targets link with Xcode, which is in no image, so their Rust stays on the host - as does
+// every build under RUNNER=LOCAL.
 export function cargoRunner(target) {
-    if (target?.platform === 'ios') return 'LOCAL';
+    if (HOST_BUILT_PLATFORMS.includes(target?.platform)) return 'LOCAL';
     const runner = state.config?.system?.RUNNER;
     return runner === 'DOCKER_RUN' || runner === 'DOCKER_EXEC' ? runner : 'LOCAL';
 }