crossbind 2.0.0-beta.60 → 2.0.0-beta.63

package/src/utils/appRustCrates.js

@@ -4,7 +4,7 @@ import { cargoTripleFor } from './cargoTarget.js';
 import { isMtWasm, assertMtRustToolchain, cargoTargetDirFor, cargoBuildInvocation } from './rustMt.js';
 import runCargo from './runCargo.js';
 import { sysrootFor } from './rustSysroot.js';
-import { relPath } from './rustBridgeGen.js';
+import { keepSymbolName, relPath } from './rustBridgeGen.js';
 import writeIfChanged from './writeIfChanged.js';
 
 const SUPER = '_app_super';
@@ -36,6 +36,8 @@ export default function buildAppRustCrates(target, cacheDir, cargoDependencies =
             // perfectly live bridge.
             stale = !fs.existsSync(path.resolve(path.dirname(libRs), pathMod[1]));
         } else if (cargoDependencies && name.startsWith('crate_')) {
+            // One bridge per crate; a `crate_<crate>__<module>` left by an older build would
+            // register the crate's types a second time.
             stale = !Object.keys(cargoDependencies)
                 .some((c) => `crate_${c.replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase()}` === name);
         }
@@ -54,6 +56,13 @@ export default function buildAppRustCrates(target, cacheDir, cargoDependencies =
     if (isMt && !sysroot) assertMtRustToolchain();
 
     const superDir = `${root}/${SUPER}`;
+    // A link that cannot load the super whole pins its keep symbol, which reaches each bridge's; one object per
+    // bridge, so that symbol brings the bridge's registrations. A bridge an older crossbind wrote has none.
+    const hasKeepSymbol = (c) => {
+        const libRs = `${root}/${c}/src/lib.rs`;
+        return fs.existsSync(libRs) && fs.readFileSync(libRs, 'utf8').includes(`fn ${keepSymbolName(`${c}_crossbind_app`)}(`);
+    };
+    const kept = crates.filter(hasKeepSymbol);
     const manifest = [
         '# Generated by crossbind - do not edit. Bundles every app-local Rust surface.',
         '[package]',
@@ -71,6 +80,7 @@ export default function buildAppRustCrates(target, cacheDir, cargoDependencies =
         '[profile.release]',
         'panic = "abort"',
         '',
+        ...crates.flatMap((c) => [`[profile.release.package.${c.replaceAll('_', '-')}-crossbind-app]`, 'codegen-units = 1', '']),
         '[workspace]',
         '',
     ].join('\n');
@@ -79,6 +89,12 @@ export default function buildAppRustCrates(target, cacheDir, cargoDependencies =
         '// its init-array registrations) into this single staticlib.',
         ...crates.map((c) => `use ${c}_crossbind_app as _;`),
         '',
+        '#[no_mangle]',
+        `pub extern "C" fn ${keepSymbolName('crossbind_app_super')}() {`,
+        `    let keep: [extern "C" fn(); ${kept.length}] = [${kept.map((c) => `${c}_crossbind_app::${keepSymbolName(`${c}_crossbind_app`)}`).join(', ')}];`,
+        '    std::hint::black_box(keep);',
+        '}',
+        '',
     ].join('\n');
     writeIfChanged(`${superDir}/Cargo.toml`, manifest);
     writeIfChanged(`${superDir}/src/lib.rs`, lib);

package/src/utils/appSources.js

@@ -0,0 +1,112 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+const SOURCE_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.mts', '.cts', '.vue', '.svelte', '.html', '.astro', '.mdx']);
+// Skip root outputs, while allowing source folders named e.g. src/build or src/android.
+const ROOT_OUTPUTS = new Set(['dist', 'build', 'ios', 'android', 'Pods', 'target']);
+const IMPORT = /\b(?:from|import\s*\(?|require\s*\()\s*(['"])([^'"\n]+)\1/g;
+const packageName = (specifier) => specifier.startsWith('@') ? specifier.split('/').slice(0, 2).join('/') : specifier.split('/')[0];
+
+function sourceFile(file) {
+    const candidates = [file, ...[...SOURCE_EXTENSIONS].map((ext) => `${file}${ext}`), ...[...SOURCE_EXTENSIONS].map((ext) => path.join(file, `index${ext}`))];
+    return candidates.find((candidate) => {
+        if (!SOURCE_EXTENSIONS.has(path.extname(candidate))) return false;
+        try { return fs.statSync(candidate, { throwIfNoEntry: false })?.isFile(); } catch { return false; }
+    });
+}
+
+// require.resolve selects CommonJS conditions. Also read runtime export branches: a bundler may
+// choose an import/browser entry whose header imports are absent from the CommonJS entry.
+function dependencySources(specifier, importer) {
+    const name = packageName(specifier);
+    const subpath = specifier.slice(name.length);
+    for (let dir = path.dirname(importer); ; dir = path.dirname(dir)) {
+        const root = path.join(dir, 'node_modules', name);
+        const manifest = path.join(root, 'package.json');
+        if (fs.existsSync(manifest)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(manifest, 'utf8'));
+                let entry = pkg.exports;
+                let wildcard;
+                if (entry && typeof entry === 'object' && !Array.isArray(entry) && Object.keys(entry).some((key) => key.startsWith('.'))) {
+                    const key = `.${subpath}`;
+                    entry = entry[key];
+                    if (entry === undefined) {
+                        for (const pattern of Object.keys(pkg.exports).filter((key) => key.includes('*')).sort((a, b) => b.length - a.length)) {
+                            const [before, after] = pattern.split('*');
+                            if (key.startsWith(before) && key.endsWith(after) && key.length >= before.length + after.length) {
+                                wildcard = key.slice(before.length, key.length - after.length);
+                                entry = pkg.exports[pattern];
+                                break;
+                            }
+                        }
+                    }
+                } else if (subpath) entry = undefined;
+                const targets = (value) => typeof value === 'string' ? [value]
+                    : Array.isArray(value) ? value.flatMap(targets)
+                    : value && typeof value === 'object' ? Object.entries(value).filter(([condition]) => condition !== 'types').flatMap(([, branch]) => targets(branch)) : [];
+                const entries = pkg.exports ? targets(entry)
+                    : subpath ? [`.${subpath}`] : [pkg.module, typeof pkg.browser === 'string' ? pkg.browser : null, pkg.main ?? 'index.js'];
+                return entries.filter(Boolean).flatMap((target) => {
+                    const file = path.resolve(root, wildcard === undefined ? target : target.replaceAll('*', wildcard));
+                    if (path.relative(root, file).startsWith('..')) return [];
+                    return sourceFile(file) ?? [];
+                });
+            } catch { return []; }
+        }
+        if (path.dirname(dir) === dir) return [];
+    }
+}
+
+// Own sources and the dependency modules they reach. Follow imports rather than walking every installed package.
+export default function appSourceFiles(projectDir) {
+    const files = [];
+    const walk = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.name.startsWith('.') || entry.name === 'node_modules' || (dir === projectDir && ROOT_OUTPUTS.has(entry.name))) continue;
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) walk(full);
+            else if (entry.isFile() && SOURCE_EXTENSIONS.has(path.extname(entry.name))) files.push(full);
+        }
+    };
+    if (projectDir && fs.existsSync(projectDir)) walk(projectDir);
+    let dependencies = {};
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(projectDir, 'package.json'), 'utf8'));
+        dependencies = { ...pkg.dependencies, ...pkg.optionalDependencies, ...pkg.peerDependencies };
+    } catch { /* A source-only project has no package manifest. */ }
+    const ownFiles = new Set(files);
+    const visited = new Set(files.map((file) => fs.realpathSync(file)));
+    for (let i = 0; i < files.length; i += 1) {
+        const importer = files[i];
+        const require = createRequire(importer);
+        const text = fs.readFileSync(importer, 'utf8');
+        for (const [, , specifier] of text.matchAll(IMPORT)) {
+            const relative = specifier.startsWith('.');
+            if (!relative && ownFiles.has(importer) && !Object.hasOwn(dependencies, packageName(specifier))) continue;
+            const resolvedFiles = relative ? [] : dependencySources(specifier, importer);
+            try { resolvedFiles.push(require.resolve(specifier)); } catch {
+                if (relative) resolvedFiles.push(sourceFile(path.resolve(path.dirname(importer), specifier)));
+            }
+            for (const resolved of resolvedFiles) {
+                if (!resolved || !SOURCE_EXTENSIONS.has(path.extname(resolved)) || !fs.existsSync(resolved)) continue;
+                const real = fs.realpathSync(resolved);
+                if (visited.has(real)) continue;
+                visited.add(real);
+                files.push(resolved);
+            }
+        }
+    }
+    return files;
+}
+
+// Whether a changed file is one of those sources.
+export function isAppSource(projectDir, file) {
+    const relative = path.relative(projectDir, file);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) return false;
+    const parts = relative.split(path.sep);
+    return SOURCE_EXTENSIONS.has(path.extname(file))
+        && parts.every((part) => !part.startsWith('.'))
+        && !ROOT_OUTPUTS.has(parts[0]);
+}

package/src/utils/archiveFlags.js

@@ -0,0 +1,12 @@
+// Every archive linked into one wasm module must agree on exception handling, SIMD, threads and
+// 64-bit memory, or wasm-ld refuses it. Port recipes, the app's own libraries and Conan packages all
+// take their flags from here.
+export const WASM_EXCEPTION_FLAGS = ['-fwasm-exceptions'];
+
+export function targetArchiveFlags(target) {
+    return [
+        ...(target.runtime === 'mt' ? ['-pthread'] : []),
+        ...(target.platform === 'wasm' ? ['-msimd128'] : []),
+        ...(target.platform === 'wasm' && target.arch === 'wasm64' ? ['-sMEMORY64=1'] : []),
+    ];
+}

package/src/utils/boundHeaders.js

@@ -0,0 +1,79 @@
+// Headers of dependencies that a build binds whole (export.bindings.headers), the way an app's
+// `import * as x from '<pkg>/<header>'` would: a package that ships prebuilt bindings has no app
+// importing them. An entry is a header path, or a package name standing for every header the package
+// lists in export.publicHeaders.
+
+import { releaseTargetOf } from './targets.js';
+
+const isName = (entry) => typeof entry === 'string' && entry.length > 0;
+
+function publicHeadersOf(packageName, dependencies) {
+    const owner = dependencies.find((d) => [d.package?.name, d.general?.alias?.package].includes(packageName)
+        && d.export?.publicHeaders?.length);
+    if (!owner) {
+        throw new Error(`crossbind: export.bindings.headers names ${packageName}, but no dependency of that name lists export.publicHeaders.`);
+    }
+    return owner.export.publicHeaders.map((header) => `${packageName}/${header}`);
+}
+
+export function boundHeaderSpecifiers({ export: exportConfig, ext, allDependencies }) {
+    const entries = exportConfig.bindings?.headers ?? [];
+    if (!Array.isArray(entries) || !entries.every(isName)) {
+        throw new Error('crossbind: export.bindings.headers must list header paths or package names.');
+    }
+    const isHeader = new RegExp(`\\.(${ext.header.join('|')})$`);
+    return [...new Set(entries.flatMap((entry) => (isHeader.test(entry) ? [entry] : publicHeadersOf(entry, allDependencies))))];
+}
+
+// The bridges come from one target's headers and macros. A linux target goes first, since every host
+// builds one, so a package comes out the same on any machine.
+const BRIDGE_PLATFORM_ORDER = ['linux', 'linuxmusl', 'win32', 'darwin'];
+const bridgeRank = ({ platform }) => {
+    const rank = BRIDGE_PLATFORM_ORDER.indexOf(platform);
+    return rank < 0 ? BRIDGE_PLATFORM_ORDER.length : rank;
+};
+export const bridgeTargetOrder = (targets) => [...targets].sort((a, b) => bridgeRank(a) - bridgeRank(b));
+
+// A macOS host without Docker builds no linux addon, so the targets of the runtime environment it does not
+// build are candidates too: a linux package installed beside it gives the same bridges a linux build made.
+export const bridgeTargets = (buildTargets, allTargets) => bridgeTargetOrder([
+    ...buildTargets,
+    ...allTargets.filter((target) => target.platform !== 'wasm' && !buildTargets.includes(target)
+        && buildTargets.some((built) => built.runtimeEnv === target.runtimeEnv)),
+]);
+
+// A Node build reads the app's headers for the first of its own targets, in its release form, since Conan
+// packages are staged for release targets only.
+export const nodeBridgeTarget = (targets) => releaseTargetOf(bridgeTargetOrder(targets)[0]);
+
+function resolveOrNull(resolve, specifier, target) {
+    try {
+        return resolve(specifier, target);
+    } catch {
+        return null;
+    }
+}
+
+// A desktop build has no target that every platform package covers, so each header resolves under
+// the first target whose dependency ships it.
+export function resolveBoundHeaders(specifiers, targets, resolve) {
+    return specifiers.map((specifier) => {
+        const target = targets.find((t) => resolveOrNull(resolve, specifier, t));
+        if (!target) {
+            throw new Error(`crossbind: export.bindings.headers: no dependency ships ${specifier} for ${targets.map((t) => t.path).join(', ')}.`);
+        }
+        return { specifier, file: resolve(specifier, target), target };
+    });
+}
+
+const OBJECT_LIKE_RENAME = /^\s*#\s*define\s+([A-Za-z_]\w*)\s+([A-Za-z_]\w*)\s*$/gm;
+const localOf = (name) => (typeof name === 'string' ? name : name.local);
+
+// A header that renames a bound function with an object-like macro (GNU libiconv binds libiconv_open as iconv_open)
+// is called by the macro's name, so the entry exports that name too.
+export function headerAliases(headerText, names) {
+    const bound = new Set(names.map(localOf));
+    return [...headerText.matchAll(OBJECT_LIKE_RENAME)]
+        .filter(([, local, wire]) => bound.has(wire) && !bound.has(local))
+        .map(([, local, wire]) => ({ local, wire }));
+}