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

package/src/bin.js

@@ -9,12 +9,15 @@ import createBridgeFile from './actions/createInterface.js';
 import createLib from './actions/createLib.js';
 import buildWasm from './actions/buildWasm.js';
 import buildWasiCommand from './actions/buildWasiCommand.js';
+import buildNode, { publishNodeData } from './actions/buildNode.js';
 import buildExternal from './actions/buildExternal.js';
 import buildPackageTypes from './actions/buildTypes.js';
 import buildLib from './actions/buildLib.js';
 import buildDependencies from './actions/buildDependencies.js';
 import runCrossbindApp from './actions/run.js';
-import { getFilteredBuildTargets } from './actions/target.js';
+import { getBuildTargets, getFilteredBuildTargets } from './actions/target.js';
+import { OPT_IN_PLATFORMS } from './utils/targets.js';
+import resolveEmbindNapiRoot, { resolveEmbindJsiRoot } from './utils/resolveEmbindNapi.js';
 
 import writeJson from './utils/writeJson.js';
 import flattenConfigForTable from './utils/flattenConfigForTable.js';
@@ -77,7 +80,7 @@ program.command('build')
             targetParams.buildType = ['release'];
         }
 
-        targetParams.platform = targetParams.platform || platforms;
+        targetParams.platform = targetParams.platform || platforms.filter((item) => !OPT_IN_PLATFORMS.includes(item));
         targetParams.arch = targetParams.arch || archs;
         targetParams.runtime = targetParams.runtime || runtimes;
         targetParams.buildType = targetParams.buildType || buildTypes;
@@ -162,7 +165,7 @@ program.command('clean-deps')
     });
 
 // A container belongs to one image: the web container carries no NDK, and android runs a forced platform.
-const IMAGE_ROLES = ['web', 'android'];
+const IMAGE_ROLES = ['web', 'android', 'linux', 'windows'];
 const dockerContainerName = (role) => {
     if (!IMAGE_ROLES.includes(role)) {
         console.error(`crossbind: unknown image "${role}" - expected one of ${IMAGE_ROLES.join(', ')}.`);
@@ -322,7 +325,8 @@ function run(programName, params) {
 async function build(targetParams, rebuildOption) {
     await buildDependencies({ targetParams, rebuildOption });
     buildLib(targetParams);
-    createWasmJs(targetParams);
+    await createWasmJs(targetParams);
+    await createNodeAddons(targetParams);
     await createWasiCommands(targetParams);
     buildPackageTypes();
 }
@@ -348,14 +352,7 @@ async function createWasiCommands(targetParams) {
     }
 }
 
-async function createWasmJs(targetParams) {
-    if (state.config.export.bundle === false) {
-        return;
-    }
-    const targets = getFilteredBuildTargets(targetParams, { platform: 'wasm' });
-    if (targets.length === 0) {
-        return;
-    }
+function createBridges() {
     let headers = [];
     state.config.paths.header.forEach((headerPath) => {
         headers.push(findFiles('**/*.h', { cwd: headerPath }));
@@ -367,12 +364,61 @@ async function createWasmJs(targetParams) {
         const bridgePath = createBridgeFile(header);
         bridges.push(bridgePath);
     });
+    return bridges;
+}
 
+async function createNodeAddons(targetParams) {
+    if (state.config.export.bundle === false) {
+        return;
+    }
+    const targets = getBuildTargets(targetParams)
+        .filter((target) => target.runtimeEnv === 'node' && target.platform !== 'wasm');
+    if (targets.length === 0) {
+        return;
+    }
+    // The bridges compile against the embind runtime, which speaks JSI.
+    const headerDirs = [
+        `${resolveEmbindJsiRoot()}/cpp/src`,
+        `${resolveEmbindNapiRoot()}/third_party/node-api-jsi/jsi`,
+    ];
+    const opt = {
+        buildSource: false,
+        nativeGlob: [
+            `${state.config.paths.cli}/assets/cpp-runtime/commonBridges.cpp`,
+            ...createBridges(),
+        ],
+        headerDirs,
+        inputs: headerDirs.flatMap((dir) => findFiles('**/*.h', { cwd: dir })),
+    };
+
+    for (const target of targets) {
+        const distComplete = fs.existsSync(`${state.config.paths.output}/${target.addonName}`)
+            && fs.existsSync(`${state.config.paths.output}/${target.jsName}`);
+        createLib(target, 'Bridge', opt);
+        const built = await buildNode(target, { force: !distComplete });
+        publishNodeData(target, { refresh: built });
+        if (!built) {
+            continue;
+        }
+        fs.mkdirSync(state.config.paths.output, { recursive: true });
+        fs.copyFileSync(`${state.config.paths.build}/${target.addonName}`, `${state.config.paths.output}/${target.addonName}`);
+        fs.copyFileSync(`${state.config.paths.build}/${target.jsName}`, `${state.config.paths.output}/${target.jsName}`);
+    }
+}
+
+async function createWasmJs(targetParams) {
+    if (state.config.export.bundle === false) {
+        return;
+    }
+    const targets = getFilteredBuildTargets(targetParams, { platform: 'wasm' });
+    if (targets.length === 0) {
+        return;
+    }
     const opt = {
         buildSource: false,
         nativeGlob: [
             `${state.config.paths.cli}/assets/cpp-runtime/commonBridges.cpp`,
-            ...bridges,
+            ...createBridges(),
         ],
     };
 

package/src/index.js

@@ -15,5 +15,7 @@ export { default as getDependFilePath } from './integration/getDependFilePath.js
 export { default as buildDependencies, getDependenciesStamp } from './actions/buildDependencies.js';
 export { default as findFiles } from './utils/findFiles.js';
 export { getContentHash, getFileHash } from './utils/hash.js';
-export { collectInputFiles, computeInputStamp } from './utils/inputStamp.js';
+export {
+    collectInputFiles, collectRustBridgeFiles, collectRustSources, computeInputStamp,
+} from './utils/inputStamp.js';
 export { default as buildAppRustCrates } from './utils/appRustCrates.js';

package/src/integration/getCrossbindScript.js

@@ -4,6 +4,7 @@ import getData from '../actions/getData.js';
 import loadJson from '../utils/loadJson.js';
 import state from '../state/index.js';
 import { parseSurface, createRustBridgeCrate, createCrateImportBridge } from '../utils/rustBridgeGen.js';
+import { parseCargoMarkerName } from '../utils/cargoImport.js';
 
 export default function getCrossbindScript(target, bridgePath) {
     if (!bridgePath) {
@@ -25,25 +26,21 @@ export function getRustJsScript(target, rsFile) {
 
     // Marker under <cache>/rust-crates/: a direct crate import - the model comes from the
     // upstream crate's own source, and the bridge is synthesized against the cargo dependency.
-    const crateName = path.basename(rsReal, '.rs');
+    const { crateName, modulePath } = parseCargoMarkerName(path.basename(rsReal, '.rs'));
     const cargoDeps = state.config.cargoDependencies ?? {};
     if (Object.hasOwn(cargoDeps, crateName)
         && path.dirname(rsReal) === fs.realpathSync(path.join(state.config.paths.cache, 'rust-crates'))) {
-        const { model, namePrefix } = createCrateImportBridge({
+        const { exports } = createCrateImportBridge({
             crateName,
+            modulePath,
             spec: cargoDeps[crateName],
             cacheDir: state.config.paths.cache,
             dtsMode: state.config.dts,
             log: () => {},
         });
-        // A crate import registers its public names prefixed (two crates may export the same
-        // name), so the proxy exports the clean name and reads the prefixed one off the module.
-        return buildScript(target, [
-            ...model.classes.map((c) => c.name),
-            ...model.enums.map((e) => e.name),
-            ...model.freeFns.map((f) => f.jsName),
-            ...(model.consts ?? []).map((c) => c.name),
-        ].map((name) => ({ local: name, wire: `${namePrefix}${name}` })));
+        // A crate registers its public names under per-crate names (two crates may export the
+        // same name), so the proxy exports the clean name and reads the registered one off the module.
+        return buildScript(target, exports);
     }
 
     const pkg = state.config.allDependencies.find((d) => d.export?.type === 'cargo'
@@ -65,6 +62,7 @@ export function getRustJsScript(target, rsFile) {
     }
     const symbols = [
         ...model.classes.map((c) => c.name),
+        ...(model.streams ?? []).map((s) => s.name),
         ...model.enums.map((e) => e.name),
         ...(model.freeFns ?? []).map((f) => f.jsName),
         // `pub const`/`pub static` register as module constants, so the proxy exports them too.

package/src/integration/getDependFilePath.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import state from '../state/index.js';
+import { parseCargoImport, writeCargoMarker } from '../utils/cargoImport.js';
 
 const LAYOUT = { header: 'include', module: 'swig', source: '' };
 
@@ -76,21 +77,17 @@ function getFolderCandidates(pkg, alias) {
 }
 
 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.
+    // `cargo:<crate>[/<module>...]` 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 cargoImport = parseCargoImport(source);
         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`);
+        if (!Object.hasOwn(cargoDeps, cargoImport.crateName)) {
+            throw new Error(`crossbind: '${source}' is not declared - add '${cargoImport.crateName}' to cargoDependencies in crossbind.config.`);
         }
+        const marker = writeCargoMarker(state.config.paths.cache, cargoImport);
         existsCache.set(marker, true);
         return marker;
     }

package/src/state/index.js

@@ -1,8 +1,7 @@
-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 { TARGETS, targetPathOf, nodeAddonNamesOf } from '../utils/targets.js';
+import { findCargoModuleImportsIn, writeCargoMarker } from '../utils/cargoImport.js';
 import loadConfig from './loadConfig.js';
 
 const cacheDir = `${process.cwd()}/.crossbind`;
@@ -34,6 +33,8 @@ async function initProcessState() {
         DOCKER_REGISTRY_MIRROR: 'CROSSBIND_REGISTRY_MIRROR',
         DOCKER_IMAGE_WEB: 'CROSSBIND_IMAGE_WEB',
         DOCKER_IMAGE_ANDROID: 'CROSSBIND_IMAGE_ANDROID',
+        DOCKER_IMAGE_LINUX: 'CROSSBIND_IMAGE_LINUX',
+        DOCKER_IMAGE_WINDOWS: 'CROSSBIND_IMAGE_WINDOWS',
     }).forEach(([key, envKey]) => {
         if (state.config.system[key] && !process.env[envKey]) {
             process.env[envKey] = state.config.system[key];
@@ -54,21 +55,23 @@ async function initProcessState() {
             // A wasi build is a single command module - no JS glue, no preload.
             target.wasmName = `${state.config.general.name}-${target.path}.wasm`;
         }
+        if (target.runtimeEnv === 'node' && target.platform !== 'wasm') {
+            Object.assign(target, nodeAddonNamesOf(target, state.config.general.name));
+        }
     });
 
     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.
+    // 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. Bare crates come from the config, module imports from the app's own sources.
     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`);
-        }
-    }
+    const crateNames = Object.keys(cargoDeps);
+    const moduleImports = crateNames.length && state.config.paths.project
+        ? findCargoModuleImportsIn(state.config.paths.project).filter((i) => Object.hasOwn(cargoDeps, i.crateName))
+        : [];
+    [...crateNames.map((crateName) => ({ crateName, modulePath: [] })), ...moduleImports]
+        .forEach((cargoImport) => writeCargoMarker(state.config.paths.cache, cargoImport));
 
     if (state.config.build?.setState) {
         state.config.build.setState(state);

package/src/state/loadConfig.js

@@ -126,6 +126,9 @@ export function getFilledConfig(config, options = { isDepend: false }) {
     if (typeof newConfig.types !== 'boolean') {
         throw new Error(`crossbind: "types" must be true or false (got '${newConfig.types}').`);
     }
+    if (newConfig.targetSpecs.some((t) => Array.isArray(t?.specs?.cmake))) {
+        throw new Error('crossbind: "targetSpecs[].specs.cmake" must be an object such as { compileOptions: [\'-O3\'] } (got an array). CMake configure flags (-D...) belong in a recipe\'s getBuildParams.');
+    }
 
     if (newConfig.paths.config && !newConfig.paths.project) {
         newConfig.paths.project = getParentPath(newConfig.paths.config);

package/src/utils/appRustCrates.js

@@ -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);
         }

package/src/utils/appSources.js

@@ -0,0 +1,21 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const SOURCE_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.vue', '.svelte']);
+// Native projects and build outputs: large, and never the app's JavaScript.
+const SKIPPED_DIRECTORIES = new Set(['node_modules', 'dist', 'build', 'ios', 'android', 'Pods', 'target']);
+
+// The app's own JavaScript and TypeScript sources, whose import statements say what the app uses.
+export default function appSourceFiles(projectDir) {
+    const files = [];
+    const walk = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.name.startsWith('.') || SKIPPED_DIRECTORIES.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);
+        }
+    };
+    walk(projectDir);
+    return files;
+}

package/src/utils/cargoImport.js

@@ -0,0 +1,44 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import appSourceFiles from './appSources.js';
+
+const PREFIX = 'cargo:';
+const RUST_IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const MODULE_IMPORT = /['"`]cargo:([A-Za-z0-9_-]+)((?:\/[A-Za-z_][A-Za-z0-9_]*)+)['"`]/g;
+
+export function parseCargoImport(source) {
+    const [crateName, ...modulePath] = source.slice(PREFIX.length).split('/');
+    const bad = modulePath.find((segment) => !RUST_IDENT.test(segment));
+    if (bad !== undefined) {
+        throw new Error(`crossbind: '${source}' - '${bad}' is not a Rust module name; write the path as cargo:<crate>/<module>/<submodule>.`);
+    }
+    return { crateName, modulePath };
+}
+
+// The marker's file name carries the module path after dots, which crate and module names cannot contain.
+export function cargoMarkerName({ crateName, modulePath }) {
+    return [crateName, ...modulePath].join('.');
+}
+
+export function parseCargoMarkerName(name) {
+    const [crateName, ...modulePath] = name.split('.');
+    return { crateName, modulePath };
+}
+
+export function writeCargoMarker(cacheDir, cargoImport) {
+    const marker = path.join(cacheDir, 'rust-crates', `${cargoMarkerName(cargoImport)}.rs`);
+    if (!fs.existsSync(marker)) {
+        fs.mkdirSync(path.dirname(marker), { recursive: true });
+        fs.writeFileSync(marker, `// crossbind cargo crate import marker: ${[cargoImport.crateName, ...cargoImport.modulePath].join('/')}\n`);
+    }
+    return marker;
+}
+
+// A specifier built at run time is not found.
+export function findCargoModuleImports(text) {
+    return [...text.matchAll(MODULE_IMPORT)].map((m) => ({ crateName: m[1], modulePath: m[2].slice(1).split('/') }));
+}
+
+export function findCargoModuleImportsIn(projectDir) {
+    return appSourceFiles(projectDir).flatMap((file) => findCargoModuleImports(fs.readFileSync(file, 'utf8')));
+}

package/src/utils/cargoTarget.js

@@ -9,6 +9,8 @@ export function cargoTripleFor(target) {
             return target.arch === 'iphonesimulator' ? 'aarch64-apple-ios-sim' : 'aarch64-apple-ios';
         case 'android':
             return target.arch === 'x86_64' ? 'x86_64-linux-android' : 'aarch64-linux-android';
+        case 'darwin':
+            return target.arch === 'x64' ? 'x86_64-apple-darwin' : 'aarch64-apple-darwin';
         default:
             return null; // wasi (no rust wasip3 target yet) and anything else: unsupported
     }

package/src/utils/cppDts.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { stripComments } from './swigInterface.js';
 import writeIfChanged from './writeIfChanged.js';
 
 // Best-effort .d.ts for `.h` imports, the C++ analog of the Rust emitDts: parse the
@@ -41,16 +42,7 @@ function tsType(raw, classNames, { isReturn = false } = {}) {
 function parseArgs(rawArgs, classNames) {
     const trimmed = rawArgs.trim();
     if (trimmed === '' || trimmed === 'void') return [];
-    const parts = [];
-    let depth = 0;
-    let current = '';
-    for (const ch of trimmed) {
-        if (ch === '<' || ch === '(') depth += 1;
-        if (ch === '>' || ch === ')') depth -= 1;
-        if (ch === ',' && depth === 0) { parts.push(current); current = ''; } else current += ch;
-    }
-    parts.push(current);
-    return parts.map((part, i) => {
+    return splitTopLevel(trimmed).map((part, i) => {
         const noDefault = part.split('=')[0].trim();
         // Declaration-style unnamed parameter: the whole token is a type.
         const unnamed = tsType(noDefault, classNames);
@@ -81,36 +73,86 @@ function bodyStatements(body) {
     return statements.map((s) => s.trim()).filter(Boolean);
 }
 
+// Splits at commas outside <>, (), [] and {}.
+function splitTopLevel(text) {
+    const parts = [];
+    let depth = 0;
+    let current = '';
+    for (const ch of text) {
+        if ('<([{'.includes(ch)) depth += 1;
+        if ('>)]}'.includes(ch)) depth -= 1;
+        if (ch === ',' && depth === 0) { parts.push(current); current = ''; } else current += ch;
+    }
+    return [...parts, current];
+}
+
+// Value-semantics fields only: these are the types embind's .property can expose
+// without ownership questions (and the worker clone can carry).
+const FIELD_TYPES = new Set(['number', 'boolean', 'string']);
+
+// `int x, *p, y = 2;` declares the int fields x and y and the pointer p. The types cover the value fields: pointers,
+// arrays, bit-fields and references are left out.
+const FIRST_DECLARATOR = /^([\s\S]*?)([*&\s]*)\b([A-Za-z_]\w*)\s*((?:\[[^\]]*\])*|:\s*\w+)$/;
+const NEXT_DECLARATOR = /^([*&\s]*)([A-Za-z_]\w*)\s*((?:\[[^\]]*\])*|:\s*\w+)$/;
+
+function valueField(typeText, classNames) {
+    const type = tsType(typeText.replace(/\b(?:const|volatile)\b/g, '').replace(/\s+/g, ' ').trim(), classNames);
+    return FIELD_TYPES.has(type) ? { type } : null;
+}
+
+function declaredFields(statement, classNames) {
+    const [first, ...rest] = splitTopLevel(statement).map((part) => part.split('=')[0].trim());
+    const head = first.match(FIRST_DECLARATOR);
+    if (!head || !head[1].trim()) return [];
+    const value = valueField(head[1], classNames);
+    const declarators = [head.slice(2), ...rest.map((part) => part.match(NEXT_DECLARATOR)?.slice(1) ?? null)];
+    return declarators.flatMap((declarator) => {
+        if (!value || !declarator || declarator[2] || /[*&]/.test(declarator[0])) return [];
+        return [{ name: declarator[1], ...value }];
+    });
+}
+
+// `struct Name {`, `class Name : Base {` and `typedef struct [Tag] { ... } Alias, *Pointer;`, unions too.
+// A class takes its tag, or its first typedef name when it has none, and keeps its other typedef names:
+// SWIG registers a typedef'd struct under the typedef name.
+const CLASS_HEAD = /\b(typedef\s+)?(class|struct|union)\b\s*([A-Za-z_]\w*)?\s*(?::[^{;]*)?\{/g;
+
+function closingBrace(text, from) {
+    let depth = 1;
+    let i = from;
+    while (i < text.length && depth > 0) {
+        if (text[i] === '{') depth += 1;
+        if (text[i] === '}') depth -= 1;
+        i += 1;
+    }
+    return i;
+}
+
+function typedefNamesAfter(text, from) {
+    const tail = text.slice(from).match(/^([^;{}]*);/);
+    return tail ? tail[1].split(',').map((part) => part.trim()).filter((part) => /^[A-Za-z_]\w*$/.test(part)) : [];
+}
+
 export function parseCppSurface(source, log = console.log) {
-    const clean = source
-        .replace(/\/\*[\s\S]*?\*\//g, ' ')
-        .replace(/\/\/[^\n]*/g, ' ')
-        .replace(/^[ \t]*#[^\n]*$/gm, ' ');
+    const clean = stripComments(source).replace(/^[ \t]*#[^\n]*$/gm, ' ');
 
     const classes = [];
     const classNames = new Set();
-    const classRe = /\b(class|struct)\s+([A-Za-z_]\w*)\s*(?::[^{]*)?\{/g;
     const found = [];
-    let m = classRe.exec(clean);
-    while (m) {
-        let depth = 1;
-        let i = classRe.lastIndex;
-        while (i < clean.length && depth > 0) {
-            if (clean[i] === '{') depth += 1;
-            if (clean[i] === '}') depth -= 1;
-            i += 1;
-        }
-        found.push({ kind: m[1], name: m[2], body: clean.slice(classRe.lastIndex, i - 1) });
-        classNames.add(m[2]);
-        m = classRe.exec(clean);
+    for (const m of clean.matchAll(CLASS_HEAD)) {
+        const [head, typedefKeyword, kind, tag] = m;
+        const bodyStart = m.index + head.length;
+        const end = closingBrace(clean, bodyStart);
+        const names = typedefKeyword ? typedefNamesAfter(clean, end) : [];
+        const name = tag ?? names[0];
+        if (!name) continue;
+        found.push({ kind, name, aliases: names.filter((alias) => alias !== name), body: clean.slice(bodyStart, end - 1) });
+        classNames.add(name);
+        names.forEach((alias) => classNames.add(alias));
     }
 
-    // Value-semantics fields only: these are the types embind's .property can expose
-    // without ownership questions (and the worker clone can carry).
-    const FIELD_TYPES = new Set(['number', 'boolean', 'string']);
-
     for (const cls of found) {
-        let access = cls.kind === 'struct' ? 'public' : 'private';
+        let access = cls.kind === 'class' ? 'private' : 'public';
         let ctor = null;
         const methods = [];
         const fields = [];
@@ -122,14 +164,8 @@ export function parseCppSurface(source, log = console.log) {
 
             const sig = statement.match(/^(static\s+)?(?:explicit\s+)?([\w:<>,\s*&]*?)\s*\b([A-Za-z_]\w*)\s*\(([\s\S]*)\)$/);
             if (!sig) {
-                const decl = statement.split('=')[0].trim();
-                const field = !statement.includes('(') && !/^(static|using|typedef|friend|enum)\b/.test(decl)
-                    ? decl.match(/^(.*?)\b([A-Za-z_]\w*)$/s)
-                    : null;
-                if (field) {
-                    const type = tsType(field[1], classNames);
-                    // A reference member has no address a pointer to member could name, and a pointer member is memory.
-                    if (type !== null && FIELD_TYPES.has(type) && !/[&*]/.test(field[1])) fields.push({ name: field[2], type });
+                if (!statement.includes('(') && !/^(static|using|typedef|friend|enum)\b/.test(statement)) {
+                    fields.push(...declaredFields(statement, classNames));
                 }
                 continue;
             }
@@ -142,7 +178,7 @@ export function parseCppSurface(source, log = console.log) {
             if (ret === null) { log(`crossbind: dts: skipped ${cls.name}::${name} (unsupported return type '${retRaw.trim()}')`); continue; }
             methods.push({ name, isStatic: Boolean(staticKw), args, ret });
         }
-        classes.push({ name: cls.name, ctor, methods, fields });
+        classes.push({ name: cls.name, aliases: cls.aliases, ctor, methods, fields });
     }
     return { classes };
 }

package/src/utils/embindArgumentGuards.js

@@ -0,0 +1,45 @@
+// A release build of embind passes whatever JavaScript hands an integer or enum parameter straight to
+// the wire, where anything that is not a number becomes 0: an enum member given to an `int` parameter,
+// a Number given to an enum parameter, a one-letter string given to a `char`. The call then runs with 0
+// and reports no error. These rewrites convert what has one meaning and throw a TypeError for the rest,
+// as embind's assertion builds do.
+
+const GUARDS = [
+    {
+        registration: '_embind_register_integer',
+        from: 'toWireType:(destructors,value)=>value,readValueFromPointer:integerReadValueFromPointer(',
+        to: 'toWireType:(destructors,value)=>{'
+            + 'if(typeof value=="number"||typeof value=="boolean"||typeof value=="bigint")return value;'
+            + 'if(typeof value=="string"&&size==1&&value.length==1)return value.charCodeAt(0);'
+            + 'if(value!==null&&typeof value=="object"&&typeof value.value=="number")return value.value;'
+            + 'throw new TypeError(name+" takes a number, got "+(typeof value=="string"?JSON.stringify(value):value===null?"null":typeof value))'
+            + '},readValueFromPointer:integerReadValueFromPointer(',
+    },
+    {
+        registration: '_embind_register_enum',
+        from: 'toWireType:(destructors,c)=>c.value,',
+        to: 'toWireType:(destructors,c)=>{'
+            + 'if(typeof c=="number")return c;'
+            + 'if(c!==null&&typeof c=="object"&&typeof c.value=="number")return c.value;'
+            + 'throw new TypeError(name+" takes a member of the enum or its number, got "+(typeof c=="string"?JSON.stringify(c):c===null?"null":typeof c))'
+            + '},',
+    },
+];
+
+// The release glue spells the bigint conversion `typeof value=="number"`, the debug glue `typeof value == 'number'`.
+const BIGINT_FROM_NUMBER = /if\s*\(\s*typeof value\s*==\s*["']number["']\s*\)\s*\{\s*value\s*=\s*BigInt\(value\)\s*;?\s*\}/g;
+const SAFE_BIGINT_FROM_NUMBER = 'if(typeof value=="number"){if(!Number.isSafeInteger(value))throw new TypeError("a 64-bit integer parameter takes a BigInt or a safe integer Number, got "+value);value=BigInt(value)}';
+
+// Returns the rewritten glue and whether a bigint registration kept a conversion this rewrite does not recognise.
+export function guardBigIntArguments(glue) {
+    const text = glue.replace(BIGINT_FROM_NUMBER, SAFE_BIGINT_FROM_NUMBER);
+    return { text, missed: text.includes('_embind_register_bigint') && !text.includes('Number.isSafeInteger(value)') };
+}
+
+// Returns the rewritten glue and the registrations whose code no longer looks the way these rewrites expect.
+export function guardEmbindArguments(glue) {
+    const missed = GUARDS.filter(({ registration, from, to }) => glue.includes(`${registration}=`) && !glue.includes(from) && !glue.includes(to))
+        .map(({ registration }) => registration);
+    const text = GUARDS.reduce((current, { from, to }) => current.split(from).join(to), glue);
+    return { text, missed };
+}

package/src/utils/embindRsFingerprint.js

@@ -0,0 +1,26 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getContentHash, getFileHash } from './hash.js';
+import { collectRustSources } from './inputStamp.js';
+import resolveEmbindRustRoot from './resolveEmbindRust.js';
+
+// Every cargo staticlib bundles the embind-rs it was built from. An archive from another one links stale glue, and next
+// to an archive built after it every embind_rs symbol is defined twice, so a prebuilt records the one it came from.
+export const EMBIND_RS_FINGERPRINT_FILE = 'crossbind-embind-rs.fingerprint';
+
+// Paths count relative to the crate, so an archive built from the same embind-rs elsewhere matches.
+export function getEmbindRsFingerprint() {
+    const crate = `${resolveEmbindRustRoot()}/crate`;
+    const files = [...collectRustSources([crate]), `${crate}/Cargo.toml`];
+    return getContentHash(files.map((file) => `${path.relative(crate, file)}:${getFileHash(file)}`).sort().join('\n'));
+}
+
+export function isEmbindRsFingerprintStale(prebuiltDir, fingerprint) {
+    const file = `${prebuiltDir}/${EMBIND_RS_FINGERPRINT_FILE}`;
+    return !fs.existsSync(file) || fs.readFileSync(file, { encoding: 'utf8' }) !== fingerprint;
+}
+
+export function writeEmbindRsFingerprint(prebuiltDir, fingerprint) {
+    fs.mkdirSync(prebuiltDir, { recursive: true });
+    fs.writeFileSync(`${prebuiltDir}/${EMBIND_RS_FINGERPRINT_FILE}`, fingerprint);
+}