crossbind 2.0.0-beta.58 → 2.0.0-beta.62

package/src/utils/rustBridgeGen.js

@@ -4,6 +4,7 @@ import { pathToFileURL } from 'node:url';
 import resolveEmbindRustRoot, { embindRustVersion } from './resolveEmbindRust.js';
 import runCargo, { toHostPath } from './runCargo.js';
 import writeIfChanged from './writeIfChanged.js';
+import { cargoMarkerName, parseCargoMarkerName } from './cargoImport.js';
 
 // Generates the embind bridge for a cargo package as a COMPANION CRATE, the Rust analog of the
 // C++ .i.cpp bridges: the user's crate stays plain Rust (no embind-rs dependency, no macro line)
@@ -25,7 +26,9 @@ import writeIfChanged from './writeIfChanged.js';
 //   i64 / u64 cross as JS BigInt, the narrower integers and f32 as numbers, char as a
 //   one-character string; Result<T, E> in any return above throws in JS on Err
 //   (E: Display); Option<Self> factories return JS null; Option<i32/f64/bool/String> works in
-//   params (undefined/null -> None) and returns (None -> null); other Option shapes skip
+//   params (undefined/null -> None) and returns (None -> null), Option<i64/u64> and
+//   Option<&[u8]/&[f64]> in params only; other Option shapes skip; a NonZero integer param
+//   crosses as its integer (and Option<NonZero..> where that Option does), 0 throws
 //   vectors come from crossbind.config.mjs: export.bindings.vectors = [{ of: 'i32', name: '..' }]
 // Anything outside this surface is skipped WITH a log line - never silently.
 
@@ -33,10 +36,31 @@ const PRIMITIVES = new Set(['i32', 'i64', 'u64', 'f64', 'bool', 'String', '()',
     'i8', 'i16', 'u8', 'u16', 'u32', 'f32', 'usize', 'isize', 'char']);
 const PARAM_ONLY = new Set(['&str', '&String']);
 const OPTION_INNERS = new Set(['i32', 'f64', 'bool', 'String']);
-const OPTION_PARAM_RE = /^Option<(i32|f64|bool|String|&str)>$/;
+const OPTION_PARAM_RE = /^Option<(i32|f64|bool|String|&str|i64|u64)>$/;
 const OPTION_CLASS_REF_RE = /^Option<&(\w+)>$/;
-const OPTIONAL_REG = { i32: 'register_optional_i32', f64: 'register_optional_f64', bool: 'register_optional_bool', String: 'register_optional_string' };
+const OPTIONAL_REG = {
+    i32: 'register_optional_i32', f64: 'register_optional_f64', bool: 'register_optional_bool', String: 'register_optional_string',
+    i64: 'register_optional_bigint::<i64>', u64: 'register_optional_bigint::<u64>',
+};
+// A 64-bit optional crosses as a BigInt or null, an optional typed array as the view or null.
+const OPTION_BIGINT_RE = /^Option<(i64|u64)>$/;
+const OPTION_VIEW_RE = /^Option<&\[(u8|f64)\]>$/;
+// A NonZero parameter crosses as its integer, inside Option wherever that integer's Option does;
+// the shim turns 0 into a JS error before the call.
+const NON_ZERO = {
+    NonZeroU8: 'u8', NonZeroU16: 'u16', NonZeroU32: 'u32', NonZeroU64: 'u64', NonZeroUsize: 'usize',
+    NonZeroI8: 'i8', NonZeroI16: 'i16', NonZeroI32: 'i32', NonZeroI64: 'i64', NonZeroIsize: 'isize',
+};
+const nonZeroBase = (ty) => NON_ZERO[ty] ?? null;
+const optionNonZero = (ty) => {
+    const inner = String(ty).match(/^Option<(NonZero\w+)>$/)?.[1];
+    const base = NON_ZERO[inner];
+    return base && OPTION_PARAM_RE.test(`Option<${base}>`) ? { inner, base } : null;
+};
 const VECTOR_ITEM_TYPES = new Set(['i32', 'f64', 'bool']);
+// The native adapter calls an invoker with at most 8 integer slots: a constructor spends one on the
+// baked function, a method two (the function and `this`), so constructors go one argument further.
+const MAX_CTOR_ARGS = 7;
 // serde_json::Value params/returns cross as a deep JSON copy (adapter-side codec, canonical
 // token 'Json'); the bare `Value` spelling counts only when the file imports serde_json.
 const JSON_TY = 'Json';
@@ -60,18 +84,26 @@ function closureShape(ty) {
 // structs that derive Serialize/Deserialize. The canonical token keeps the Rust spelling, so the
 // shim can name the exact type it converts to.
 const COLLECTION_RE = /^(?:Vec<.+>|\[.+;\s*\d+\]|&\[.+\]|\(.+,.*\)|(?:std::collections::)?(?:HashMap|BTreeMap|HashSet|BTreeSet)<.+>)$/;
-// `&[u8]` / `Vec<u8>` and `&[f64]` / `Vec<f64>` are typed arrays on the JS side.
+// `&[u8]` / `Vec<u8>` and `&[f64]` / `Vec<f64>` are typed arrays on the JS side. A parameter
+// takes the `arg` wire, which reads the view without an emval handle.
 const TYPED_ARRAYS = {
-    'Vec<u8>': { wrapper: 'JsBytes', owned: 'Vec<u8>', slice: false },
-    '&[u8]': { wrapper: 'JsBytes', owned: 'Vec<u8>', slice: true },
-    'Vec<f64>': { wrapper: 'JsF64s', owned: 'Vec<f64>', slice: false },
-    '&[f64]': { wrapper: 'JsF64s', owned: 'Vec<f64>', slice: true },
+    'Vec<u8>': { wrapper: 'JsBytes', arg: 'JsBytesArg', owned: 'Vec<u8>', slice: false },
+    '&[u8]': { wrapper: 'JsBytes', arg: 'JsBytesArg', owned: 'Vec<u8>', slice: true },
+    'Vec<f64>': { wrapper: 'JsF64s', arg: 'JsF64sArg', owned: 'Vec<f64>', slice: false },
+    '&[f64]': { wrapper: 'JsF64s', arg: 'JsF64sArg', owned: 'Vec<f64>', slice: true },
 };
 const typedArrayOf = (ty) => TYPED_ARRAYS[String(ty).replace(/\s+/g, '')] ?? null;
 
+// serde carries fixed arrays of up to 32 items, and only a literal length says how long one is:
+// any other array would leave the generated bridge uncompilable.
+const SERDE_MAX_ARRAY = 32;
+const arraysCarry = (text) => [...text.matchAll(/;\s*([^\]]*?)\s*\]/g)]
+    .every((m) => /^\d+$/.test(m[1]) && Number(m[1]) <= SERDE_MAX_ARRAY);
+
 const isCollection = (ty) => {
     if (typedArrayOf(ty)) return false;
     const text = String(ty).trim();
+    if (!arraysCarry(text)) return false;
     if (COLLECTION_RE.test(text)) return true;
     // An optional collection rides the same wire: JSON writes None as null.
     const inner = text.match(/^Option<(.+)>$/)?.[1];
@@ -116,6 +148,12 @@ const matchJsTok = (ty, ctx) => {
     return m[1];
 };
 const FN_SIG_RE = /^pub (?:const )?fn (\w+)\s*\(([^)]*)\)\s*(?:->\s*([\w:<>(),& ]+?))?\s*\{/;
+// embind-rs registers constants of these types only (its ConstantValue impls and constant_str).
+const CONSTANT_TYPES = new Set(['i32', 'f64', 'bool', '&str']);
+// A Rust integer literal: decimal, hex, octal or binary, with `_` separators.
+const intLiteral = (text) => (text.startsWith('-') ? -1 : 1) * Number(text.replace(/^-/, '').replaceAll('_', ''));
+// `name: Type`; a `mut` binding stays inside the function and changes nothing that crosses.
+const PARAM_RE = /^(?:mut\s+)?(\w+)\s*:\s*(&\s*(?:str|String)|Option\s*<\s*(?:i32|f64|bool|String|i64|u64|NonZero\w+|&\s*\w+|&\s*\[\s*(?:u8|f64)\s*\])\s*>|Vec\s*<[^;]+>|\[[^\]]+;\s*\d+\]|&\s*\[[^\]]+\]|\([^)]*,[^)]*\)|(?:std\s*::\s*collections\s*::\s*)?(?:HashMap|BTreeMap|HashSet|BTreeSet)\s*<[^>]+>|serde_json\s*::\s*Value|(?:std\s*::\s*sync\s*::\s*)?Arc\s*<\s*\w+\s*>|embind_rs\s*::\s*Js(?:Value|Function)|&\s*\w+|[\w()]+)$/;
 
 // The parameter list is read by counting parentheses, because a closure parameter carries its
 // own: `f: impl Fn(i32) -> i32` would end the list early for a regex.
@@ -252,12 +290,17 @@ export function createRustBridgeCrate({ rsFile, cacheDir, projectPath, vectors =
 }
 
 // Direct CRATE import (`import { X } from 'cargo:uuid'` with top-level `cargoDependencies`
-// declaring `uuid`): no surface file and no package - the bridge is generated from the
-// upstream crate's OWN multi-file source. cargo metadata (which fetches on first run) locates
-// the source and the resolved feature set; the bridge crate is a normal rlib under
-// rust-bridges/, so the app super-staticlib flow links it like any app-local surface.
+// declaring `uuid`, or `cargo:<crate>/<module>` for one public module): no surface file and no
+// package - the bridge is generated from the upstream crate's OWN multi-file source. cargo
+// metadata (which fetches on first run) locates the source and the resolved feature set; the
+// bridge crate is a normal rlib under rust-bridges/, so the app super-staticlib flow links it
+// like any app-local surface. Every import of one crate shares that bridge, so an item reached
+// through the root and through a module registers once and is the same JS class for both.
+const crateSourceCache = new Map();
 const crateModelCache = new Map();
-export function createCrateImportBridge({ crateName, spec, cacheDir, dtsMode = 'sync', log = console.log }) {
+export function createCrateImportBridge({ crateName, modulePath = [], spec, cacheDir, dtsMode = 'sync', log = console.log }) {
+    const importName = [crateName, ...modulePath].join('/');
+    const crateIdent = crateName.replaceAll('-', '_');
     const stem = `crate_${crateName.replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase()}`;
     const dir = `${cacheDir}/rust-bridges/${stem}`;
     const depLine = String(spec).trim().startsWith('{') ? `${crateName} = ${spec}` : `${crateName} = "${spec}"`;
@@ -295,49 +338,183 @@ export function createCrateImportBridge({ crateName, spec, cacheDir, dtsMode = '
     // cargo metadata needs a resolvable lib target before the real bridge exists.
     if (!fs.existsSync(`${dir}/src/lib.rs`)) writeIfChanged(`${dir}/src/lib.rs`, '// crossbind placeholder\n');
 
-    const cacheKey = `${dir}|${depLine}`;
-    let model = crateModelCache.get(cacheKey);
-    if (!model) {
-        let meta;
+    const { srcDir, features } = crateSource({ dir, depLine, crateName, importName });
+    const ownKey = modulePath.join('::');
+    const imports = [];
+    for (const importPath of crateImports(cacheDir, crateName, modulePath)) {
+        const key = importPath.join('::');
+        const cacheKey = `${srcDir}|${features.join(',')}|${key}`;
         try {
-            const probe = runCargo(['metadata', '--format-version', '1', '--manifest-path', `${dir}/Cargo.toml`], {
-                capture: true, maxBuffer: 128 * 1024 * 1024,
-            });
-            if (probe.status !== 0) throw new Error(String(probe.stderr ?? '').trim() || `exit code ${probe.status}`);
-            meta = JSON.parse(probe.stdout);
+            if (!crateModelCache.has(cacheKey)) {
+                const model = parseCrateSurface({ srcDir, features, modulePath: importPath, log });
+                // Always audible (the transformer silences routine skip-noise): an empty surface
+                // means the import binds NOTHING - generic/re-export-style crates need an app-local .rs.
+                if (key === ownKey && !model.classes.length && !model.enums.length && !model.freeFns.length) {
+                    const source = modulePath.length ? `module ${modulePath.join('::')}` : 'its lib.rs';
+                    console.warn(`crossbind: crate import '${importName}' has no bindable surface (${source} defines no in-grammar types) - write an app-local surface .rs over it instead`);
+                }
+                crateModelCache.set(cacheKey, model);
+            }
+            imports.push({ modulePath: importPath, model: crateModelCache.get(cacheKey) });
         } catch (e) {
-            throw new Error(`crossbind: crate import '${crateName}': cargo metadata failed (${e.message})`, { cause: e });
-        }
-        const pkg = meta.packages.find((p) => p.name === crateName);
-        if (!pkg) throw new Error(`crossbind: crate import '${crateName}': crate not found in the cargo dependency graph`);
-        const features = meta.resolve?.nodes?.find((n) => n.id === pkg.id)?.features ?? [];
-        const srcDir = path.join(path.dirname(toHostPath(pkg.manifest_path)), 'src');
-        model = parseCrateSurface({ srcDir, features, log });
-        // Always audible (the transformer silences routine skip-noise): an empty surface means
-        // the import will bind NOTHING - generic/re-export-style crates need an app-local .rs.
-        if (!model.classes.length && !model.enums.length && !model.freeFns.length) {
-            console.warn(`crossbind: crate import '${crateName}' has no bindable surface (its lib.rs defines no in-grammar types) - write an app-local surface .rs over it instead`);
+            if (key === ownKey) throw e;
+            log(`crossbind: crate import '${[crateName, ...importPath].join('/')}' left out of the ${crateName} bridge (${e.message})`);
         }
-        crateModelCache.set(cacheKey, model);
     }
+    const shared = mergeCrateImports(crateIdent, crateName, imports, log);
 
     const jsonDeps = ['serde', 'serde_json'].filter((dep) => dep !== crateName).map((dep) => `${dep} = "1"`);
-    writeIfChanged(`${dir}/Cargo.toml`, manifestWith(model.usesJson ? jsonDeps : []));
-    // Two crates can export the same type name (semver::Version and uuid::Version both do), so a
-    // crate import registers under `<crate>_<Name>` and the proxy module re-exports the clean name.
-    const namePrefix = `${crateName.replaceAll('-', '_')}_`;
-    const bridge = emitBridge(model, { userCrate: crateName.replaceAll('-', '_'), vectors: [], log, namePrefix });
-    writeIfChanged(`${dir}/src/lib.rs`, bridge);
-    // Editor types for the `cargo:<crate>` import: an ambient module the app's tsconfig
-    // includes (e.g. "include": ["**/*", ".crossbind/rust-crates/types/**/*.d.ts"]). The scheme
-    // keeps the module name unique, so npm packages/@types of the same name never clash.
-    const dtsBody = emitDts(model, [], dtsMode).split('\n').map((l) => (l ? `    ${l}` : l)).join('\n');
-    writeIfChanged(`${cacheDir}/rust-crates/types/${crateName}.d.ts`, `declare module 'cargo:${crateName}' {\n${dtsBody}\n}\n`);
+    writeIfChanged(`${dir}/Cargo.toml`, manifestWith(shared.model.usesJson ? jsonDeps : []));
+    writeIfChanged(`${dir}/src/lib.rs`, emitBridge(shared.model, {
+        userCrate: crateIdent, vectors: [], log, rustPaths: shared.rustPaths, wireNames: shared.wireNames,
+    }));
+    for (const { modulePath: importPath } of imports) {
+        writeImportDts({ cacheDir, crateName, modulePath: importPath, shared, dtsMode });
+    }
+    return {
+        bridgeDir: dir,
+        crateName: `${stem}_crossbind_app`,
+        model: imports.find((i) => i.modulePath.join('::') === ownKey).model,
+        exports: shared.exports.get(ownKey),
+    };
+}
+
+// cargo metadata locates the crate's source and the feature set it resolves to (fetching the crate
+// on first use); both hold for every import of the crate.
+function crateSource({ dir, depLine, crateName, importName }) {
+    const cacheKey = `${dir}|${depLine}`;
+    if (crateSourceCache.has(cacheKey)) return crateSourceCache.get(cacheKey);
+    let meta;
+    try {
+        const probe = runCargo(['metadata', '--format-version', '1', '--manifest-path', `${dir}/Cargo.toml`], {
+            capture: true, maxBuffer: 128 * 1024 * 1024,
+        });
+        if (probe.status !== 0) throw new Error(String(probe.stderr ?? '').trim() || `exit code ${probe.status}`);
+        meta = JSON.parse(probe.stdout);
+    } catch (e) {
+        throw new Error(`crossbind: crate import '${importName}': cargo metadata failed (${e.message})`, { cause: e });
+    }
+    const pkg = meta.packages.find((p) => p.name === crateName);
+    if (!pkg) throw new Error(`crossbind: crate import '${importName}': crate not found in the cargo dependency graph`);
+    const source = {
+        features: meta.resolve?.nodes?.find((n) => n.id === pkg.id)?.features ?? [],
+        srcDir: path.join(path.dirname(toHostPath(pkg.manifest_path)), 'src'),
+    };
+    crateSourceCache.set(cacheKey, source);
+    return source;
+}
+
+// The imports a crate's bridge serves: the root, the import at hand and every module import a
+// marker names. Markers outlive a removed import, so the caller leaves out one that no longer
+// resolves instead of failing the others.
+function crateImports(cacheDir, crateName, modulePath) {
+    const dir = `${cacheDir}/rust-crates`;
+    const keys = new Set(['', modulePath.join('::')]);
+    for (const file of fs.existsSync(dir) ? fs.readdirSync(dir) : []) {
+        if (!file.endsWith('.rs')) continue;
+        const marker = parseCargoMarkerName(file.slice(0, -'.rs'.length));
+        if (marker.crateName === crateName) keys.add(marker.modulePath.join('::'));
+    }
+    return [...keys].sort().map((key) => (key ? key.split('::') : []));
+}
+
+const unionByName = (a, b) => [...a, ...b.filter((x) => !a.some((y) => y.name === x.name))];
+
+// The same struct read through two imports: each may have bound members the other could not type
+// (a return type only the other import collects), so the bridge takes both.
+function mergeClass(a, b) {
     return {
-        bridgeDir: dir, crateName: `${stem}_crossbind_app`, model, namePrefix,
+        ...a,
+        ctor: a.ctor ?? b.ctor,
+        factories: unionByName(a.factories, b.factories),
+        statics: unionByName(a.statics ?? [], b.statics ?? []),
+        methods: unionByName(a.methods, b.methods),
+        fields: unionByName(a.fields ?? [], b.fields ?? []),
+        hasDefault: a.hasDefault || b.hasDefault,
+        clonable: a.clonable || b.clonable,
+        hasDisplay: a.hasDisplay || b.hasDisplay,
+        shared: a.shared || b.shared,
     };
 }
 
+// One model for every import of a crate. An item registers once, under a name taken from the
+// module that defines it, so the root and a module import reach the same JS class; Rust names it
+// by the path of the first import that reaches it (items of a private module are reachable only
+// through their re-export). Each import keeps the list of names its JS module exports.
+function mergeCrateImports(crateIdent, crateName, imports, log) {
+    const exported = ['classes', 'streams', 'enums', 'freeFns', 'consts'];
+    const lists = [...exported, 'valueObjects', 'newtypes', 'jsonTypes'];
+    const model = { usesJson: false, sharedOf: [], ...Object.fromEntries(lists.map((list) => [list, []])) };
+    const rustPaths = new Map();
+    const wireNames = new Map();
+    const homes = new Map();
+    const exports = new Map();
+    const names = new Map();
+    for (const { modulePath, model: part } of imports) {
+        const key = modulePath.join('::');
+        const access = [crateIdent, ...modulePath].join('::');
+        const own = [];
+        const itemNames = new Set();
+        for (const list of lists) {
+            for (const item of part[list]) {
+                const home = part.definedIn?.get(item.name) ?? key;
+                if (homes.has(item.name) && homes.get(item.name) !== home) {
+                    log(`crossbind: rust bridge: cargo:${[crateName, ...modulePath].join('/')} ${item.name} skipped (another import of ${crateName} binds a different ${item.name})`);
+                    continue;
+                }
+                const registered = list === 'freeFns' ? item.jsName : item.name;
+                if (!homes.has(item.name)) {
+                    homes.set(item.name, home);
+                    rustPaths.set(item.name, `${access}::${item.name}`);
+                    wireNames.set(registered, `${[crateIdent, ...(home ? home.split('::') : [])].join('__')}_${registered}`);
+                    model[list] = [...model[list], item];
+                } else if (list === 'classes') {
+                    model.classes = model.classes.map((c) => (c.name === item.name ? mergeClass(c, item) : c));
+                }
+                itemNames.add(item.name);
+                if (exported.includes(list)) own.push({ local: registered, wire: wireNames.get(registered) });
+            }
+        }
+        model.usesJson ||= part.usesJson;
+        model.sharedOf = [...new Set([...model.sharedOf, ...part.sharedOf])];
+        exports.set(key, own);
+        names.set(key, itemNames);
+    }
+    return { model, rustPaths, wireNames, exports, names };
+}
+
+// Editor types for one `cargo:` import: an ambient module the app's tsconfig includes (e.g.
+// "include": ["**/*", ".crossbind/rust-crates/types/**/*.d.ts"]); the scheme keeps the module
+// name unique, so npm packages/@types of the same name never clash. An import declares its own
+// items as the shared bridge binds them and imports a type it names from the import exporting it.
+function writeImportDts({ cacheDir, crateName, modulePath, shared, dtsMode }) {
+    const key = modulePath.join('::');
+    const mine = shared.names.get(key);
+    const pick = (list) => list.filter((item) => mine.has(item.name));
+    const body = emitDts({
+        ...shared.model,
+        classes: pick(shared.model.classes),
+        streams: pick(shared.model.streams),
+        enums: pick(shared.model.enums),
+        freeFns: pick(shared.model.freeFns),
+        consts: pick(shared.model.consts),
+        valueObjects: pick(shared.model.valueObjects),
+        newtypes: pick(shared.model.newtypes),
+        jsonTypes: pick(shared.model.jsonTypes),
+    }, [], dtsMode);
+    const borrowed = new Map();
+    for (const type of [...shared.model.classes, ...shared.model.enums, ...shared.model.valueObjects]) {
+        if (mine.has(type.name) || !new RegExp(`\\b${type.name}\\b`).test(body)) continue;
+        const from = [...shared.names].find(([other, set]) => other !== key && set.has(type.name))?.[0] ?? '';
+        borrowed.set(from, [...(borrowed.get(from) ?? []), type.name]);
+    }
+    const imports = [...borrowed].map(([from, types]) => (
+        `import type { ${types.join(', ')} } from 'cargo:${[crateName, ...(from ? from.split('::') : [])].join('/')}';`));
+    const text = [...imports, body].join('\n').split('\n').map((l) => (l ? `    ${l}` : l)).join('\n');
+    writeIfChanged(`${cacheDir}/rust-crates/types/${cargoMarkerName({ crateName, modulePath })}.d.ts`,
+        `declare module 'cargo:${[crateName, ...modulePath].join('/')}' {\n${text}\n}\n`);
+}
+
 // The embind-rs runtime crate ships inside @crossbind/core-embind-rust; the consumer (a plugin
 // or the package itself) declares that dependency and resolveEmbindRust finds it.
 function resolveEmbindRsDir() {
@@ -370,31 +547,60 @@ export function parseSurface(src, log) {
     return finalizeModel(acc, log);
 }
 
-// Parses an UPSTREAM crate for a direct crate import (`import .. from '<crate>'`): exported
-// types come from lib.rs; inherent impls and `impl Display` are collected across the crate's
-// `mod`-declared files, following the resolved feature set for cfg-gated modules.
-export function parseCrateSurface({ srcDir, features = [], log = console.log }) {
+// Parses an UPSTREAM crate for a direct crate import (`import .. from 'cargo:<crate>'`):
+// exported types come from lib.rs, or from the imported module (`cargo:<crate>/<module>`);
+// inherent impls and `impl Display` are collected across the crate's `mod`-declared files,
+// following the resolved feature set for cfg-gated modules.
+export function parseCrateSurface({ srcDir, features = [], modulePath = [], log = console.log }) {
     const acc = newAcc();
     const enabled = new Set(features);
     const seen = new Set();
+    const imported = modulePath.join('::');
     const walk = (file, modPath) => {
-        if (seen.has(file) || !fs.existsSync(file)) return;
+        if (!file || seen.has(file) || !fs.existsSync(file)) return;
         seen.add(file);
-        // Root and glob-re-exported modules collect their pub types; other modules only
-        // contribute impls (plus types individually re-exported by name).
-        const collectTypes = modPath.length === 0 || acc.globModules.has(modPath.join('::'));
-        const mods = scanSource(fs.readFileSync(file, 'utf8'), acc, { collectTypes, log });
-        const childBase = file.endsWith('lib.rs') || file.endsWith('mod.rs') ? path.dirname(file) : file.slice(0, -3);
+        // The imported module and its glob-re-exported modules collect their pub types; other
+        // modules only contribute impls (plus types individually re-exported by name).
+        const here = modPath.join('::');
+        const collectTypes = here === imported || acc.globModules.has(here);
+        const mods = scanSource(fs.readFileSync(file, 'utf8'), acc, { collectTypes, modPath, enabled, log });
         for (const m of mods) {
-            if (!cfgEnabled(m.cfg, enabled)) continue;
-            walk(path.join(childBase, `${m.name}.rs`), [...modPath, m.name]);
-            walk(path.join(childBase, m.name, 'mod.rs'), [...modPath, m.name]);
+            if (cfgEnabled(m.cfg, enabled)) walk(modFile(file, m.name), [...modPath, m.name]);
         }
     };
-    walk(path.join(srcDir, 'lib.rs'), []);
+    const lib = path.join(srcDir, 'lib.rs');
+    // The imported module is read first, so its types are known wherever their impls live.
+    if (modulePath.length) walk(findModule(lib, modulePath, enabled, srcDir), modulePath);
+    walk(lib, []);
     return finalizeModel(acc, log);
 }
 
+// `mod name;` lives in name.rs or name/mod.rs: beside lib.rs and mod.rs, else in the directory
+// named after the declaring file.
+function modFile(file, name) {
+    const base = file.endsWith('lib.rs') || file.endsWith('mod.rs') ? path.dirname(file) : file.slice(0, -3);
+    return [path.join(base, `${name}.rs`), path.join(base, name, 'mod.rs')].find((f) => fs.existsSync(f));
+}
+
+// Follows the `mod` declarations from lib.rs down to the imported module, which has to be public
+// at every step (the bridge names it by path from outside the crate).
+function findModule(lib, modulePath, enabled, srcDir) {
+    const where = modulePath.join('::');
+    let file = lib;
+    for (const name of modulePath) {
+        const decl = fs.existsSync(file)
+            ? scanSource(fs.readFileSync(file, 'utf8'), newAcc(), { collectTypes: false, log: () => {} })
+                .find((m) => m.name === name && cfgEnabled(m.cfg, enabled))
+            : undefined;
+        file = decl && modFile(file, name);
+        if (!file) {
+            throw new Error(`crossbind: rust bridge: module '${where}' not found in ${srcDir} - a module behind a cargo feature needs that feature in cargoDependencies, and inline mod { } blocks are not read`);
+        }
+        if (!decl.isPub) throw new Error(`crossbind: rust bridge: module '${where}' in ${srcDir} is private to the crate`);
+    }
+    return file;
+}
+
 function newAcc() {
     return {
         enums: [],        // { name, variants: [{ name, value }] }
@@ -406,41 +612,80 @@ function newAcc() {
         freeFns: [],      // { name, jsName, args, ret, throws }
         displayNames: new Set(),
         wantedTypes: new Set(),  // type names re-exported from lib.rs (`pub use ..::{X}`)
+        wantedFns: new Map(),    // fn name -> module path it is re-exported from (`pub use ..::m::{f}`)
         globModules: new Set(),  // module paths glob-re-exported from lib.rs (`pub use ..::m::*`)
+        traitImpls: new Map(),   // type name -> traits it implements by hand (`impl Default for X`)
+        definedIn: new Map(),    // item name -> path of the module that defines it
+        genericStructs: new Map(), // name -> { generics, definedIn } of `pub struct X<..>`
+        genericImpls: new Map(),   // name -> [{ header, fns }] of `impl<..> X<..>` blocks
+        streamTraits: new Map(),   // name -> { trait: 'Write' | 'Read', header } of its std::io impl
+        pending: [],               // fn signatures in source order, typed once every type is known
+        structModules: new Map(),  // struct name -> modules that declare one, pub or not
     };
 }
 
-// `#[cfg(..)]` on a `mod` line: null = ungated; no feature tokens = never enabled (so
-// cfg(test) / cfg(target_os = ..) modules are skipped).
+// A name several modules declare (regex's `Regex` in both `regex::string` and `regex::bytes`)
+// takes the impls of the module that defined the bound struct only.
+function implOfBound(acc, item) {
+    return (acc.structModules.get(item.className)?.size ?? 0) <= 1 || acc.definedIn.get(item.className) === item.module;
+}
+
+// What a signature may lean on, as of the file it was read in.
+function scanFlags(acc, collectTypes) {
+    return { allowJson: collectTypes, hasSerdeUse: acc.hasSerdeUse, hasArcUse: acc.hasArcUse, hasEmbindUse: acc.hasEmbindUse };
+}
+
+// The `#[cfg(..)]` predicate on an item (stacked ones combine as all(..)), or null when ungated.
 function cfgOf(attrs) {
-    const cfg = attrs.find((a) => a.startsWith('#[cfg('));
-    if (!cfg) return null;
-    const features = [...cfg.matchAll(/feature\s*=\s*"([^"]+)"/g)].map((m) => m[1]);
-    return { features, any: /cfg\(any/.test(cfg) };
+    const predicates = attrs.map((a) => a.match(/^#\[cfg\(([\s\S]*)\)\]$/)?.[1]).filter(Boolean);
+    if (!predicates.length) return null;
+    return predicates.length === 1 ? predicates[0] : `all(${predicates.join(', ')})`;
+}
+
+// A cfg predicate against the enabled cargo features: true, false, or null when it depends on
+// the target (or on test/debug settings), which one generated bridge cannot know.
+function cfgValue(predicate, enabled) {
+    const text = predicate.trim();
+    const feature = text.match(/^feature\s*=\s*"([^"]+)"$/);
+    if (feature) return enabled.has(feature[1]);
+    const call = text.match(/^(any|all|not)\s*\(([\s\S]*)\)$/);
+    if (!call) return null;
+    const values = splitTopLevel(call[2]).map((p) => p.trim()).filter(Boolean).map((p) => cfgValue(p, enabled));
+    if (call[1] === 'not') return values[0] === null ? null : !values[0];
+    if (call[1] === 'any') return values.includes(true) ? true : values.every((v) => v === false) ? false : null;
+    return values.includes(false) ? false : values.every((v) => v === true) ? true : null;
 }
 
+// Only what every target compiles is bound: an item a target might lack would break its build.
 function cfgEnabled(cfg, enabled) {
-    if (cfg === null) return true;
-    if (cfg.features.length === 0) return false;
-    return cfg.any ? cfg.features.some((f) => enabled.has(f)) : cfg.features.every((f) => enabled.has(f));
+    return cfg === null || cfgValue(cfg, enabled) === true;
 }
 
 // Scans ONE source file into the accumulator; returns the `mod name;` declarations found.
-// collectTypes: types and free fns register only from the crate root (lib.rs) - module files
-// contribute impls (methods, factories, Display) for already-known types.
-function scanSource(src, acc, { collectTypes, log }) {
+// collectTypes: types and free fns register only from the imported root (lib.rs, or the module
+// of a module import) - other files contribute impls (methods, factories, Display) for
+// already-known types. modPath places the file in the crate, for relative `pub use` paths.
+function scanSource(src, acc, { collectTypes, log, modPath = [], enabled = new Set() }) {
     const { enums, valueObjects, newtypes, jsonTypes, consts, classes, freeFns, displayNames, wantedTypes } = acc;
     acc.hasSerdeUse ||= /\buse\s+serde_json\b/.test(src);
     acc.hasArcUse ||= /\buse\s+std::sync::(?:Arc\b|\{[^}]*\bArc\b)/.test(src);
     acc.hasEmbindUse ||= /\buse\s+embind_rs::/.test(src);
+    const here = modPath.join('::');
     const mods = [];
-    // Strip line comments; join multi-line `pub fn` signatures (to their brace) and multi-line
-    // `pub use` re-export lists (to their semicolon).
-    const rawLines = src.split('\n').map((l) => l.replace(/\/\/.*$/, ''));
+    const reexportedFrom = new Set();
+    // Strip line comments; join multi-line `pub fn` signatures (to their brace), multi-line
+    // `pub use` re-export lists (to their semicolon) and multi-line attributes (to their bracket).
+    const rawLines = src.split('\n').map(stripLineComment);
     const lines = [];
+    const unclosed = (line) => (line.match(/\[/g) ?? []).length > (line.match(/\]/g) ?? []).length;
     for (let i = 0; i < rawLines.length; i += 1) {
         let line = rawLines[i];
-        if (/\bpub (?:const )?fn\b/.test(line)) {
+        if (/^\s*#!?\[/.test(line)) {
+            while (unclosed(line) && i + 1 < rawLines.length) {
+                i += 1;
+                line = `${line} ${rawLines[i].trim()}`;
+            }
+        } else if (/\bpub (?:const )?fn\b/.test(line)) {
             while (!line.includes('{') && !line.includes(';') && i + 1 < rawLines.length) {
                 i += 1;
                 line = `${line} ${rawLines[i].trim()}`;
@@ -460,28 +705,44 @@ function scanSource(src, acc, { collectTypes, log }) {
         if (t.startsWith('#[') || t.startsWith('#![')) { attrs.push(t); continue; }
         if (t === '') continue;
 
+        // An item behind a cfg this build leaves off, or one only some targets compile, is not
+        // there to bind. A `mod` keeps its cfg: the walk and the module lookup decide on it.
+        if (!cfgEnabled(cfgOf(attrs), enabled) && !/^(?:pub(?:\([^)]*\))?\s+)?mod\s/.test(t)) {
+            if (!(t.endsWith(';') && !t.includes('{'))) i = skipBlock(lines, i);
+            attrs = [];
+            continue;
+        }
+
         // Crate-root re-exports make module-defined types part of the surface: capitalized
         // leaves of `pub use ..::{X, Y};` are collected when the defining module is scanned.
         if (collectTypes && t.startsWith('pub use ')) {
             // Named re-exports mark module types as surface; glob re-exports mark their whole
             // module as root-like (its pub types are collected when the walk reaches it).
             const body = t.replace(/^pub use\s+/, '').replace(/;.*$/, '').trim();
+            // `crate::` paths start at the crate root; the others at the module being scanned.
+            const resolve = (p) => (p.startsWith('crate::') ? p.slice('crate::'.length) : [...modPath, p.replace(/^self::/, '')].join('::'));
             const items = [];
-            const braced = body.match(/^(?:crate::|self::)?(?:([\w:]+)::)?\{(.*)\}$/);
+            const braced = body.match(/^((?:crate::|self::)?(?:[\w:]+::)?)\{(.*)\}$/);
             if (braced) {
-                const prefix = braced[1] ? `${braced[1]}::` : '';
                 braced[2].split(',').map((s) => s.trim()).filter(Boolean)
-                    .forEach((s) => items.push(prefix + s.replace(/^(?:crate::|self::)/, '')));
+                    .forEach((s) => items.push(resolve(`${braced[1]}${s}`)));
             } else {
-                items.push(body.replace(/^(?:crate::|self::)/, ''));
+                items.push(resolve(body));
             }
             for (const item of items) {
+                // The module an item comes from is walked even when its `mod` line is out of
+                // sight, declared inside a macro (argon2-rust declares its modules that way).
+                const rel = !here ? item : item.startsWith(`${here}::`) ? item.slice(here.length + 2) : '';
+                if (rel.includes('::')) reexportedFrom.add(rel.split('::')[0]);
                 if (item.endsWith('::*')) {
                     acc.globModules.add(item.slice(0, -3));
-                } else {
-                    const leaf = (item.split('::').pop() ?? '').replace(/\s+as\s+\w+$/, '');
-                    if (/^[A-Z]\w*$/.test(leaf)) wantedTypes.add(leaf);
+                    continue;
                 }
+                // A renamed re-export exists here only under its new name.
+                if (/\s+as\s+\w+$/.test(item)) continue;
+                const leaf = item.split('::').pop() ?? '';
+                if (/^[A-Z]\w*$/.test(leaf)) wantedTypes.add(leaf);
+                else acc.wantedFns.set(leaf, item.split('::').slice(0, -1).join('::'));
             }
             attrs = [];
             continue;
@@ -489,32 +750,58 @@ function scanSource(src, acc, { collectTypes, log }) {
 
         let enumM = t.match(/^pub enum (\w+)/);
         if (enumM && !collectTypes && !wantedTypes.has(enumM[1])) enumM = null;
+        const anyStruct = t.match(/^(?:pub(?:\([^)]*\))?\s+)?struct (\w+)/);
+        if (anyStruct) acc.structModules.set(anyStruct[1], new Set([...(acc.structModules.get(anyStruct[1]) ?? []), here]));
         let structM = t.match(/^pub struct (\w+)/);
         if (structM && !collectTypes && !wantedTypes.has(structM[1])) structM = null;
+        const genericStructM = structM && t.match(/^pub struct \w+\s*<(.*)>/);
         const modM = t.match(/^(?:pub(?:\([^)]*\))?\s+)?mod (\w+)\s*([;{])/);
         // `pub const NAME: T = value;` (and `pub static`) - a value, not a getter, in JS.
         const constM = collectTypes ? t.match(/^pub (?:const|static) (\w+)\s*:\s*([\w()&' ]+?)\s*=\s*(.+?);$/) : null;
         const displayM = t.match(/^impl (?:[\w:]+::)?Display for (\w+)/);
         const traitImplM = !displayM && /^impl\b[^{]*\bfor\b/.test(t);
         const implM = displayM || traitImplM ? null : t.match(/^impl (\w+)\s*\{/);
-        const freeFnM = collectTypes && !enumM && !structM && !modM && !displayM && !traitImplM && !implM
+        const otherImplM = !displayM && !traitImplM && !implM && /^(?:unsafe\s+)?impl\b/.test(t);
+        const fnSig = !enumM && !structM && !modM && !displayM && !traitImplM && !implM && !otherImplM
             ? matchFnSignature(t) : null;
+        // A free fn binds from the imported root, or from the module the root re-exports it from.
+        const freeFnM = fnSig && (collectTypes || acc.wantedFns.get(fnSig[1]) === here) ? fnSig : null;
 
         if (enumM) {
             const derive = attrs.find((a) => a.startsWith('#[derive')) ?? '';
 
             const variants = [];
             let idx = 0;
+            let variantAttrs = [];
+            // A variant only some targets compile shifts the implicit discriminants after it.
+            let shifted = false;
+            let targetDependent = false;
             for (i += 1; i < lines.length && !/^\}/.test(lines[i].trim()); i += 1) {
-                const v = lines[i].trim().match(/^(\w+)(?:\s*=\s*(-?\d+))?\s*,?$/);
-                if (v) { variants.push({ name: v[1], value: v[2] !== undefined ? Number(v[2]) : idx }); idx = variants.at(-1).value + 1; }
+                const line = lines[i].trim();
+                if (line.startsWith('#[')) { variantAttrs.push(line); continue; }
+                const v = line.match(/^(\w+)(?:\s*=\s*(-?(?:0x[\da-fA-F_]+|0o[0-7_]+|0b[01_]+|\d[\d_]*)))?\s*,?$/);
+                const cfg = cfgOf(variantAttrs);
+                if (line) variantAttrs = [];
+                if (!v) continue;
+                const compiled = cfg === null || cfgValue(cfg, enabled);
+                if (v[2] === undefined && shifted) targetDependent = true;
+                if (compiled === null) { shifted = true; continue; }
+                if (!compiled) continue;
+                if (v[2] !== undefined) shifted = false;
+                variants.push({ name: v[1], value: v[2] !== undefined ? intLiteral(v[2]) : idx });
+                idx = variants.at(-1).value + 1;
             }
             const hasSerde = derive.includes('Serialize') && derive.includes('Deserialize');
-            if (variants.length) enums.push({ name: enumM[1], variants });
+            if (targetDependent) log(`crossbind: rust bridge: enum ${enumM[1]} skipped (its discriminants depend on the target)`);
+            else if (variants.length) enums.push({ name: enumM[1], variants });
             // A variant that carries data cannot be an embind enum, but it can cross as a plain
             // JS value when the enum derives serde - in serde's own representation.
             else if (hasSerde) jsonTypes.push({ name: enumM[1] });
             else log(`crossbind: rust bridge: enum ${enumM[1]} skipped (a data enum crosses only when it derives Serialize and Deserialize)`);
+        } else if (genericStructM) {
+            // A generic struct binds only as a std::io stream (streamsOf decides).
+            acc.genericStructs.set(structM[1], { generics: genericStructM[1], definedIn: here });
+            if (!(t.endsWith(';') && !t.includes('{'))) i = skipBlock(lines, i);
         } else if (structM) {
             const isReprC = attrs.some((a) => /repr\(C\)/.test(a));
             const derive = attrs.find((a) => a.startsWith('#[derive')) ?? '';
@@ -525,13 +812,11 @@ function scanSource(src, acc, { collectTypes, log }) {
                 newtypes.push({ name: newtypeM[1], inner: newtypeM[2] });
             } else if (isReprC) {
                 const ok = derive.includes('Default') && derive.includes('Copy');
-                const fields = [];
-                for (i += 1; i < lines.length && !/^\}/.test(lines[i].trim()); i += 1) {
-                    const f = lines[i].trim().match(/^pub (\w+)\s*:\s*([\w()]+)\s*,?$/);
-                    // A field may be another value object: embind nests them, and the wrapper is
-                    // repr(transparent) over the user struct, so the offset still lands right.
-                    if (f && (PRIMITIVES.has(f[2]) || valueObjects.some((v) => v.name === f[2]))) fields.push({ name: f[1], type: f[2] });
-                }
+                const body = structFields(lines, i, enabled);
+                i = body.end;
+                // A field may be another value object: embind nests them, and the wrapper is
+                // repr(transparent) over the user struct, so the offset still lands right.
+                const fields = body.fields.filter((f) => PRIMITIVES.has(f.type) || valueObjects.some((v) => v.name === f.type));
                 if (ok && fields.length) valueObjects.push({ name: structM[1], fields, serde: derive.includes('Serialize') && derive.includes('Deserialize') });
                 else log(`crossbind: rust bridge: struct ${structM[1]} skipped (repr(C) needs derive(Default, Copy) and pub primitive or value-object fields)`);
             } else if (derive.includes('Serialize') && derive.includes('Deserialize') && !newtypeM) {
@@ -541,67 +826,222 @@ function scanSource(src, acc, { collectTypes, log }) {
                 if (!jsonTypes.some((j) => j.name === structM[1])) jsonTypes.push({ name: structM[1] });
                 if (t.endsWith('{')) { for (i += 1; i < lines.length && !/^\}/.test(lines[i].trim()); i += 1); }
             } else {
-                if (!classes.has(structM[1])) classes.set(structM[1], { name: structM[1], ctor: null, factories: [], methods: [], fields: [], hasDefault: derive.includes('Default') });
+                if (!classes.has(structM[1])) {
+                    classes.set(structM[1], {
+                        name: structM[1], ctor: null, factories: [], methods: [], statics: [], fields: [],
+                        hasDefault: derive.includes('Default'), clonable: /\b(?:Clone|Copy)\b/.test(derive),
+                    });
+                }
                 const cls = classes.get(structM[1]);
                 cls.serde = derive.includes('Serialize') && derive.includes('Deserialize');
                 // Public fields read and write as JS properties, the way napi-rs exposes them.
                 if (t.endsWith('{')) {
-                    for (i += 1; i < lines.length && !/^\}/.test(lines[i].trim()); i += 1) {
-                        const f = lines[i].trim().match(/^pub (\w+)\s*:\s*([\w()]+)\s*,?$/);
-                        if (f) cls.fields.push({ name: f[1], type: f[2] });
-                    }
+                    const body = structFields(lines, i, enabled);
+                    i = body.end;
+                    cls.fields.push(...body.fields);
                 }
             }
         } else if (constM) {
             const constTy = normalizeStringSpelling(constM[2]);
-            if (PRIMITIVES.has(constTy) || constTy === '&str') consts.push({ name: constM[1], ty: constTy, value: constM[3].trim() });
+            if (CONSTANT_TYPES.has(constTy)) consts.push({ name: constM[1], ty: constTy, value: constM[3].trim() });
             else log(`crossbind: rust bridge: const ${constM[1]} skipped (only i32, f64 and bool constants cross)`);
         } else if (modM) {
             // `mod x;` is followed for crate imports; inline `mod x { .. }` bodies are opaque.
-            if (modM[2] === ';') mods.push({ name: modM[1], cfg: cfgOf(attrs) });
+            if (modM[2] === ';') mods.push({ name: modM[1], cfg: cfgOf(attrs), isPub: /^pub\s/.test(t) });
             else i = skipBlock(lines, i);
         } else if (displayM) {
             // `impl Display for X` -> a JS toString(); the block body itself is not parsed.
             displayNames.add(displayM[1]);
             i = skipBlock(lines, i);
         } else if (traitImplM) {
+            // `impl Default for X` and `impl Clone for X` count like the derives.
+            const byHand = t.match(/^impl\s+(?:[\w:]+::)?(Default|Clone|Copy)\s+for\s+(\w+)\b/);
+            if (byHand) acc.traitImpls.set(byHand[2], new Set([...(acc.traitImpls.get(byHand[2]) ?? []), byHand[1]]));
+            // `impl<W: Write> Write for X<W>` makes X a std::io stream (streamsOf).
+            const io = t.match(/^impl\s*<[^>]*>\s*(?:std::io::|io::)?(Write|Read)\s+for\s+(\w+)\s*</);
+            if (io) acc.streamTraits.set(io[2], { trait: io[1], header: implFns(lines, i, enabled).header });
             i = skipBlock(lines, i);
-        } else if (implM && classes.has(implM[1])) {
-            const cls = classes.get(implM[1]);
+        } else if (implM) {
+            // Typed in finalizeModel: a signature may name a struct declared further down, and the
+            // impl may come before its own struct. An impl of a type never bound drops there.
             let depth = 1;
+            let fnAttrs = [];
             for (i += 1; i < lines.length && depth > 0; i += 1) {
                 const s = lines[i];
-                const sig = matchFnSignature(s.trim());
-                if (sig && depth === 1) parseFn(cls, sig, { enums, valueObjects, newtypes, jsonTypes, classes, allowJson: collectTypes, hasSerdeUse: acc.hasSerdeUse, hasArcUse: acc.hasArcUse, hasEmbindUse: acc.hasEmbindUse }, log);
+                const trimmed = s.trim();
+                if (depth === 1 && trimmed.startsWith('#[')) {
+                    fnAttrs.push(trimmed);
+                } else if (depth === 1 && trimmed) {
+                    const sig = matchFnSignature(trimmed);
+                    if (sig && cfgEnabled(cfgOf(fnAttrs), enabled)) acc.pending.push({ className: implM[1], module: here, sig, flags: scanFlags(acc, collectTypes) });
+                    fnAttrs = [];
+                }
                 depth += (s.match(/\{/g) ?? []).length - (s.match(/\}/g) ?? []).length;
             }
             i -= 1;
-        } else if (implM) {
-            // Consume unknown-impl bodies so their fns are never misread as free functions.
-            i = skipBlock(lines, i);
+        } else if (otherImplM) {
+            // `impl<W: Write> X<W>` feeds a std::io stream (streamsOf); no other generic impl is
+            // bound, and their fns are not free functions either.
+            const inherent = t.match(/^impl\s*<.*?>\s*(\w+)\s*<\s*\w+\s*>/);
+            if (inherent) {
+                const block = implFns(lines, i, enabled);
+                acc.genericImpls.set(inherent[1], [...(acc.genericImpls.get(inherent[1]) ?? []), block]);
+                i = block.end;
+            } else {
+                i = skipBlock(lines, i);
+            }
         } else if (freeFnM) {
-            parseFreeFn(freeFns, freeFnM, { enums, valueObjects, newtypes, jsonTypes, classes, allowJson: collectTypes, hasSerdeUse: acc.hasSerdeUse, hasArcUse: acc.hasArcUse, hasEmbindUse: acc.hasEmbindUse }, log);
+            acc.pending.push({ free: freeFnM, here, flags: scanFlags(acc, collectTypes) });
+        }
+        // Where an item is defined names it in a crate bridge that several imports share.
+        const declared = enumM?.[1] ?? structM?.[1] ?? constM?.[1];
+        const bound = (list) => list.some((item) => item.name === declared);
+        if (declared && !acc.definedIn.has(declared)
+            && (classes.has(declared) || [enums, valueObjects, newtypes, jsonTypes, consts].some(bound))) {
+            acc.definedIn.set(declared, here);
         }
         attrs = [];
     }
+    for (const name of reexportedFrom) {
+        if (!mods.some((m) => m.name === name)) mods.push({ name, cfg: null, isPub: false });
+    }
     return mods;
 }
 
+// The bounds a generic impl or struct puts on one type parameter (`W: Write + Send` and `where`
+// clauses alike), without their std::io / marker paths.
+function boundsOf(param, texts) {
+    const pattern = new RegExp(`\\b${param}\\s*:\\s*([^,{>]+)`, 'g');
+    return texts.flatMap((text) => [...text.matchAll(pattern)])
+        .flatMap((m) => m[1].split('+'))
+        .map((b) => b.trim().replace(/^(?:std::|core::)?(?:io::|marker::)/, ''))
+        .filter(Boolean);
+}
+
+// What crossbind's in-memory sink (writers) and source (readers) can stand in for.
+const STREAM_BOUNDS = {
+    Write: new Set(['Write', 'Send', 'Sync', "'static"]),
+    Read: new Set(['Read', 'BufRead', 'Seek', 'Send', 'Sync', "'static"]),
+};
+
+// Rust's std::io streams - `X<W: Write>` or `X<R: Read>` with the matching trait impl - bind with
+// crossbind's own byte sink or source in place of the type parameter, so JS hands over and gets
+// back Uint8Array chunks. A stream is built by a `new` that takes the sink or source; a writer's
+// consuming fn that returns its sink (`finish`) ends it.
+function streamsOf(acc, log) {
+    const ctx = {
+        enums: acc.enums, valueObjects: acc.valueObjects, newtypes: acc.newtypes, jsonTypes: acc.jsonTypes,
+        classes: acc.classes, allowJson: false, hasSerdeUse: acc.hasSerdeUse, hasArcUse: acc.hasArcUse, hasEmbindUse: acc.hasEmbindUse,
+    };
+    const streams = [];
+    for (const [name, struct] of acc.genericStructs) {
+        const io = acc.streamTraits.get(name);
+        if (!io) continue;
+        const skip = (why) => log(`crossbind: rust bridge: ${name} skipped (${why})`);
+        const params = splitTopLevel(struct.generics).map((p) => p.trim()).filter(Boolean);
+        if (params.length !== 1 || params[0].startsWith("'")) { skip('a stream binds with one type parameter and no lifetimes'); continue; }
+        const param = params[0].match(/^\w+/)[0];
+        const impls = acc.genericImpls.get(name) ?? [];
+        const odd = boundsOf(param, [struct.generics, io.header, ...impls.map((impl) => impl.header)])
+            .find((b) => !STREAM_BOUNDS[io.trait].has(b));
+        if (odd) { skip(`its ${param}: ${odd} bound has no in-memory ${io.trait === 'Write' ? 'sink' : 'source'}`); continue; }
+
+        const methodsOf = { name, ctor: null, factories: [], methods: [], statics: [], fields: [], clonable: false };
+        const finishers = [];
+        let ctor = null;
+        for (const sig of impls.flatMap((impl) => impl.fns)) {
+            const [, fnName, rawParams, rawRet] = sig;
+            const fnParams = splitTopLevel(rawParams).map((p) => p.trim()).filter(Boolean);
+            const ret = analyzeReturn(rawRet ?? '()', ctx);
+            if (fnParams[0] === '&self' || fnParams[0] === '&mut self') {
+                parseFn(methodsOf, sig, ctx, log);
+            } else if (fnParams[0] === 'self' || fnParams[0] === 'mut self') {
+                const why = io.trait === 'Read'
+                    ? `a reader is not consumed: its ${param} is the input passed to new`
+                    : `a writer is consumed only by a fn that hands back its ${param}`;
+                if (io.trait === 'Write' && fnParams.length === 1 && ret.inner === param && !ret.optional) finishers.push({ name: fnName, throws: ret.throws });
+                else log(`crossbind: rust bridge: ${name}::${fnName} skipped (${why})`);
+            } else if (fnName === 'new') {
+                const at = fnParams.findIndex((p) => p.match(PARAM_RE)?.[2]?.replace(/\s+/g, '') === param);
+                const others = at < 0 ? null : parseParams(fnParams.filter((_, idx) => idx !== at), ctx, `${name}::new`, log);
+                const builds = ret.inner === 'Self' || ret.inner === name || ret.inner.startsWith(`${name}<`);
+                if (at < 0 || !others || !builds || ret.optional) { log(`crossbind: rust bridge: ${name}::new skipped (it has to take the ${param} and return the stream)`); continue; }
+                // A reader's source is the bytes JS passes in; a writer's sink is crossbind's own.
+                const args = io.trait === 'Read'
+                    ? [...others.slice(0, at), { name: fnParams[at].match(PARAM_RE)[1], ty: '&[u8]' }, ...others.slice(at)]
+                    : others;
+                if (args.length > MAX_CTOR_ARGS) { log(`crossbind: rust bridge: ${name}::new skipped (max ${MAX_CTOR_ARGS} args)`); continue; }
+                ctor = { args, at, throws: ret.throws };
+            } else {
+                log(`crossbind: rust bridge: ${name}::${fnName} skipped (a stream is built by its new)`);
+            }
+        }
+        if (!ctor) { skip(`a stream needs a new that takes its ${param}`); continue; }
+        acc.definedIn.set(name, struct.definedIn);
+        streams.push({
+            name,
+            role: io.trait === 'Write' ? 'writer' : 'reader',
+            ctor,
+            finishers,
+            methods: methodsOf.methods.filter((m) => !m.ownedClass && !m.borrowedSelf && !m.consumes),
+        });
+    }
+    return streams;
+}
+
 function finalizeModel(acc, log) {
     const { enums, valueObjects, newtypes, jsonTypes, consts, classes, freeFns, displayNames } = acc;
+    for (const item of acc.pending) {
+        const ctx = { enums, valueObjects, newtypes, jsonTypes, classes, ...item.flags };
+        if (item.free) {
+            const known = freeFns.length;
+            parseFreeFn(freeFns, item.free, ctx, log);
+            if (freeFns.length > known && !acc.definedIn.has(item.free[1])) acc.definedIn.set(item.free[1], item.here);
+        } else if (classes.has(item.className) && implOfBound(acc, item)) {
+            parseFn(classes.get(item.className), item.sig, ctx, log);
+        }
+    }
+    // `impl Default for X` and `impl Clone for X` count like the derives, wherever the impl sits.
+    for (const [name, cls] of classes) {
+        const byHand = acc.traitImpls?.get(name);
+        cls.hasDefault ||= Boolean(byHand?.has('Default'));
+        cls.clonable ||= Boolean(byHand?.has('Clone') || byHand?.has('Copy'));
+    }
+    const streams = streamsOf(acc, log);
+    // A struct leaves its JS handle only as a copy, so consuming `self` and by-value parameters
+    // need it to be Clone.
+    const movesUncloned = (args) => args.find((p) => classes.has(p.ty) && !classes.get(p.ty).clonable);
+    const keepMoves = (owner) => (f) => {
+        const moved = movesUncloned(f.args);
+        if (moved) log(`crossbind: rust bridge: ${owner}${f.name} skipped (a ${moved.ty} passed by value must be Clone or Copy)`);
+        return !moved;
+    };
+    for (const cls of classes.values()) {
+        cls.methods = cls.methods.filter((m) => {
+            if (m.consumes && !cls.clonable) {
+                log(`crossbind: rust bridge: ${cls.name}::${m.name} skipped (consuming self is not supported unless ${cls.name} is Clone or Copy)`);
+                return false;
+            }
+            return keepMoves(`${cls.name}::`)(m);
+        });
+        cls.factories = cls.factories.filter(keepMoves(`${cls.name}::`));
+        cls.statics = cls.statics.filter(keepMoves(`${cls.name}::`));
+        if (cls.ctor && !keepMoves(`${cls.name}::`)({ name: 'new', args: cls.ctor.args })) cls.ctor = null;
+    }
+    freeFns.splice(0, freeFns.length, ...freeFns.filter(keepMoves('fn ')));
     // A class with no exported surface is dropped (with a note), mirroring the C++ generator.
     // A binding that borrows a dropped class would name a class that never registers and abort
     // the module at init, so dropping a class drops those bindings too, until nothing changes.
     const dropped = new Set();
     const borrowsDropped = (args) => args.some((p) => {
         const ty = String(p.ty);
-        return (ty.startsWith('&') && dropped.has(ty.slice(1))) || dropped.has(ty.match(ARC_RE)?.[1]);
+        return (ty.startsWith('&') && dropped.has(ty.slice(1))) || dropped.has(ty.match(ARC_RE)?.[1]) || dropped.has(ty);
     });
     let changed = true;
     while (changed) {
         changed = false;
         for (const [name, cls] of classes) {
-            if (!cls.ctor && !cls.factories.length && !cls.methods.length && !(cls.fields ?? []).length) {
+            if (!cls.ctor && !cls.factories.length && !cls.methods.length && !cls.statics.length && !(cls.fields ?? []).length) {
                 classes.delete(name);
                 dropped.add(name);
                 changed = true;
@@ -625,9 +1065,19 @@ function finalizeModel(acc, log) {
         for (const cls of classes.values()) {
             cls.methods = cls.methods.filter(keepFn(`${cls.name}::`));
             cls.factories = cls.factories.filter(keepFn(`${cls.name}::`));
+            cls.statics = cls.statics.filter(keepFn(`${cls.name}::`));
             if (cls.ctor && borrowsDropped(cls.ctor.args)) { cls.ctor = null; changed = true; log(`crossbind: rust bridge: ${cls.name}::new skipped (a parameter borrows a struct that is not registered)`); }
         }
     }
+    // A stream method that names a dropped or uncloned struct goes alone; the stream goes when
+    // its `new` does.
+    const liveStreams = streams
+        .map((s) => ({ ...s, methods: s.methods.filter((m) => !borrowsDropped(m.args) && !movesUncloned(m.args)) }))
+        .filter((s) => {
+            const lost = borrowsDropped(s.ctor.args) || movesUncloned(s.ctor.args);
+            if (lost) log(`crossbind: rust bridge: ${s.name} skipped (its new takes a struct that is not registered or not Clone)`);
+            return !lost;
+        });
     for (const cls of classes.values()) {
         cls.fields = (cls.fields ?? []).filter((f) => {
             const carries = PRIMITIVES.has(f.type) || enums.some((e) => e.name === f.type) || valueObjects.some((v) => v.name === f.type);
@@ -651,7 +1101,9 @@ function finalizeModel(acc, log) {
     const usesJson = freeFns.some((f) => anyJson(f.args, f.ret))
         || [...classes.values()].some((c) => (c.ctor && anyJson(c.ctor.args, '()'))
             || c.factories.some((f) => anyJson(f.args, '()'))
-            || c.methods.some((m) => anyJson(m.args, m.ret)));
+            || c.methods.some((m) => anyJson(m.args, m.ret))
+            || c.statics.some((f) => anyJson(f.args, f.ret)))
+        || liveStreams.some((s) => anyJson(s.ctor.args, '()') || s.methods.some((m) => anyJson(m.args, m.ret)));
 
     // Shared (Arc) classes: collect every class named by an Arc<...> surface anywhere, then
     // enforce the shapes whose Box paths would corrupt the Arc-based delete()/share machinery.
@@ -664,6 +1116,7 @@ function finalizeModel(acc, log) {
         if (c.ctor) noteAll(c.ctor.args, '()');
         c.factories.forEach((f) => noteAll(f.args, '()'));
         c.methods.forEach((m) => noteAll(m.args, m.ret));
+        c.statics.forEach((f) => noteAll(f.args, f.ret));
     }
     for (const c of classes.values()) {
         if (!sharedOf.has(c.name)) continue;
@@ -680,10 +1133,74 @@ function finalizeModel(acc, log) {
             throw new Error(`crossbind: rust bridge: ${c.name} is shared via Arc<...>, so every factory must return Arc<Self> ('${boxed.name}' returns Self)`);
         }
     }
-    return { enums, valueObjects, newtypes, jsonTypes, consts, classes: [...classes.values()], freeFns, usesJson, sharedOf: [...sharedOf].sort() };
+    return {
+        enums, valueObjects, newtypes, jsonTypes, consts, classes: [...classes.values()], freeFns, usesJson,
+        sharedOf: [...sharedOf].sort(), definedIn: acc.definedIn, streams: liveStreams,
+    };
 }
 
 // Consumes a brace-delimited block starting at line i; returns the closing line's index.
+// The impl block opened on line i: its header up to the brace (a `where` clause included), the
+// `pub fn` signatures a cfg keeps, and the index of its closing line.
+function implFns(lines, i, enabled) {
+    let open = i;
+    while (open < lines.length - 1 && !lines[open].includes('{')) open += 1;
+    const header = lines.slice(i, open + 1).map((l) => l.trim()).join(' ');
+    const fns = [];
+    let attrs = [];
+    let depth = (lines[open].match(/\{/g) ?? []).length - (lines[open].match(/\}/g) ?? []).length;
+    let end = open + 1;
+    for (; end < lines.length && depth > 0; end += 1) {
+        const line = lines[end].trim();
+        if (depth === 1 && line.startsWith('#[')) {
+            attrs.push(line);
+        } else if (depth === 1 && line) {
+            const sig = matchFnSignature(line);
+            if (sig && cfgEnabled(cfgOf(attrs), enabled)) fns.push(sig);
+            attrs = [];
+        }
+        depth += (lines[end].match(/\{/g) ?? []).length - (lines[end].match(/\}/g) ?? []).length;
+    }
+    return { header, fns, end: end - 1 };
+}
+
+// A line without its `//` comment. A `//` inside a string or char literal stays: a URL in an
+// attribute or a const is not a comment.
+function stripLineComment(line) {
+    let inString = false;
+    for (let i = 0; i < line.length; i += 1) {
+        const c = line[i];
+        if (inString) {
+            if (c === '\\') i += 1;
+            else if (c === '"') inString = false;
+        } else if (c === '"') {
+            inString = true;
+        } else if (c === "'") {
+            const char = line.slice(i).match(/^'(?:\\.[^']*|[^\\'])'/);
+            if (char) i += char[0].length - 1;
+        } else if (c === '/' && line[i + 1] === '/') {
+            return line.slice(0, i);
+        }
+    }
+    return line;
+}
+
+// The `pub name: Type` fields of the struct body opened on line i, minus those a cfg leaves out,
+// and the index of its closing line.
+function structFields(lines, i, enabled) {
+    const fields = [];
+    let attrs = [];
+    let end = i + 1;
+    for (; end < lines.length && !/^\}/.test(lines[end].trim()); end += 1) {
+        const line = lines[end].trim();
+        if (line.startsWith('#[')) { attrs.push(line); continue; }
+        const f = line.match(/^pub (\w+)\s*:\s*([\w()]+)\s*,?$/);
+        if (f && cfgEnabled(cfgOf(attrs), enabled)) fields.push({ name: f[1], type: f[2] });
+        if (line) attrs = [];
+    }
+    return { fields, end };
+}
+
 function skipBlock(lines, i) {
     let depth = 0;
     let started = false;
@@ -721,7 +1238,8 @@ function analyzeReturn(raw, ctx) {
     // gets the values rather than a lazy iterator.
     const iterator = raw.trim().match(/^impl\s+Iterator\s*<\s*Item\s*=\s*(.+?)\s*>$/);
     if (iterator) return { inner: `Vec<${iterator[1].trim()}>`, throws: false, optional: false, collect: true };
-    const r = normalizeStringSpelling(raw.trim());
+    // `io::Result<T>` and other path-qualified Result aliases are Results too.
+    const r = normalizeStringSpelling(raw.trim()).replace(/^(?:\w+::)+(?=Result\s*<)/, '');
     const res = unwrapGeneric(r, 'Result');
     // Only the Ok type crosses; the error type needs nothing but Display, so `Box<dyn Error>`
     // and friends are read past here.
@@ -771,30 +1289,26 @@ function splitTopLevel(text) {
     return parts;
 }
 
-function parseFn(cls, sig, ctx, log) {
-    const { enums, valueObjects, classes } = ctx;
-    const [, name, rawParams, rawRet] = sig;
-    // A borrowed string is known in both directions: as a parameter it borrows, as a return it
-    // comes back owned.
-    const known = (ty) => PRIMITIVES.has(ty) || PARAM_ONLY.has(ty) || typedArrayOf(ty) || (isCollection(ty) && collectionCarries(ty, ctx))
-        || enums.some((e) => e.name === ty) || valueObjects.some((v) => v.name === ty)
+// A borrowed string is known in both directions: as a parameter it borrows, as a return it
+// comes back owned.
+function isKnownType(ty, ctx) {
+    return PRIMITIVES.has(ty) || PARAM_ONLY.has(ty) || typedArrayOf(ty) || (isCollection(ty) && collectionCarries(ty, ctx))
+        || ctx.enums.some((e) => e.name === ty) || ctx.valueObjects.some((v) => v.name === ty)
         || (ctx.newtypes ?? []).some((n) => n.name === ty)
         || (ctx.jsonTypes ?? []).some((j) => j.name === ty)
         || isOptionalRecord(ty, ctx);
+}
+
+// The wire args of a binding, or null (with the reason logged) when a parameter cannot cross.
+// A struct passed by value is copied out of its JS handle; finalizeModel checks it is Clone.
+function parseParams(params, ctx, label, log) {
+    const { classes } = ctx;
+    const known = (ty) => isKnownType(ty, ctx);
     // `&OtherClass` params: the referenced struct must already be declared (parsed) above.
     const isClassRef = (ty) => ty.startsWith('&') && !PARAM_ONLY.has(ty) && classes.has(ty.slice(1));
-
-    const params = splitTopLevel(rawParams).map((p) => p.trim()).filter(Boolean);
-    let selfKind = null;
-    if (params[0] === '&mut self' || params[0] === '&self') selfKind = params.shift();
-    else if (params[0] === 'self' || params[0] === 'mut self') {
-        log(`crossbind: rust bridge: ${cls.name}::${name} skipped (consuming self is not supported)`);
-        return;
-    }
-
     const args = [];
     for (const p of params) {
-        const m = p.match(/^(\w+)\s*:\s*(&\s*(?:str|String)|Option\s*<\s*(?:i32|f64|bool|String|&\s*\w+)\s*>|Vec\s*<[^;]+>|\[[^\]]+;\s*\d+\]|&\s*\[[^\]]+\]|\([^)]*,[^)]*\)|(?:std\s*::\s*collections\s*::\s*)?(?:HashMap|BTreeMap|HashSet|BTreeSet)\s*<[^>]+>|serde_json\s*::\s*Value|(?:std\s*::\s*sync\s*::\s*)?Arc\s*<\s*\w+\s*>|embind_rs\s*::\s*Js(?:Value|Function)|&\s*\w+|[\w()]+)$/);
+        const m = p.match(PARAM_RE);
         let ty = m?.[2].replace(/\s+/g, '');
         if (ty) ty = normalizeStringSpelling(ty);
         if (ty && !known(ty) && isJsonSpelling(ty, ctx)) ty = JSON_TY;
@@ -805,15 +1319,34 @@ function parseFn(cls, sig, ctx, log) {
         const optClassRef = ty?.match(OPTION_CLASS_REF_RE)?.[1];
         const closure = closureShape(p.slice(p.indexOf(':') + 1));
         if (closure) { args.push({ name: `a${args.length}`, ty: `__closure${JSON.stringify(closure)}` }); continue; }
-        if (!m || !(known(ty) || ty === JSON_TY || jsTokP || (arcParam && classes.has(arcParam)) || PARAM_ONLY.has(ty) || OPTION_PARAM_RE.test(ty) || isClassRef(ty)
-            || (optClassRef && classes.has(optClassRef)))) {
+        if (!m || !(known(ty) || ty === JSON_TY || jsTokP || (arcParam && classes.has(arcParam)) || PARAM_ONLY.has(ty) || OPTION_PARAM_RE.test(ty) || OPTION_VIEW_RE.test(ty) || nonZeroBase(ty) || optionNonZero(ty) || isClassRef(ty)
+            || (optClassRef && classes.has(optClassRef)) || classes.has(ty))) {
             log(isCollection(ty) && !collectionCarries(ty, ctx)
-                ? `crossbind: rust bridge: ${cls.name}::${name} skipped (a struct inside '${ty}' must derive Serialize and Deserialize to cross)`
-                : `crossbind: rust bridge: ${cls.name}::${name} skipped (unsupported parameter '${p}')`);
-            return;
+                ? `crossbind: rust bridge: ${label} skipped (a struct inside '${ty}' must derive Serialize and Deserialize to cross)`
+                : `crossbind: rust bridge: ${label} skipped (unsupported parameter '${p}')`);
+            return null;
         }
         args.push({ name: m[1], ty });
     }
+    return args;
+}
+
+function parseFn(cls, sig, ctx, log) {
+    const { classes } = ctx;
+    const [, name, rawParams, rawRet] = sig;
+    const known = (ty) => isKnownType(ty, ctx);
+
+    const params = splitTopLevel(rawParams).map((p) => p.trim()).filter(Boolean);
+    let selfKind = null;
+    if (params[0] === '&mut self' || params[0] === '&self') selfKind = params.shift();
+    // A method that takes `self` runs on a copy, so the JS handle keeps its value (finalizeModel
+    // checks the struct is Clone).
+    else if (params[0] === 'self' || params[0] === 'mut self') { params.shift(); selfKind = 'self'; }
+    const byRef = selfKind !== '&mut self';
+    const consumes = selfKind === 'self';
+
+    const args = parseParams(params, ctx, `${cls.name}::${name}`, log);
+    if (!args) return;
     const returnInfo = analyzeReturn(rawRet ?? '()', ctx);
     let { inner: ret, throws, optional } = returnInfo;
     if (!known(ret) && isJsonSpelling(ret, ctx)) ret = JSON_TY;
@@ -828,13 +1361,15 @@ function parseFn(cls, sig, ctx, log) {
     if (!selfKind) {
         const arcSelf = ret === 'Arc<Self>' || ret === `Arc<${cls.name}>`;
         if (!arcSelf && ret !== 'Self' && ret !== cls.name) {
-            log(`crossbind: rust bridge: ${cls.name}::${name} skipped (associated fns must return Self, Result<Self, E> or Option<Self>)`);
+            // Any other associated fn is a static function on the class: `Class.name(..)` in JS.
+            const entry = callableEntry(name, args, rawRet, ctx, log, `${cls.name}::${name}`);
+            if (entry) cls.statics.push(entry);
             return;
         }
         if (name === 'new') {
             if (arcSelf) { log(`crossbind: rust bridge: ${cls.name}::new skipped (Arc<Self> has no ctor shape - use a named factory like 'create')`); return; }
             if (optional) { log(`crossbind: rust bridge: ${cls.name}::new skipped (Option<Self> has no ctor shape - use a named factory or Result<Self, E>)`); return; }
-            if (args.length > 6) { log(`crossbind: rust bridge: ${cls.name}::new skipped (max 6 args)`); return; }
+            if (args.length > MAX_CTOR_ARGS) { log(`crossbind: rust bridge: ${cls.name}::new skipped (max ${MAX_CTOR_ARGS} args)`); return; }
             cls.ctor = { args, throws };
         } else {
             if (arcSelf && optional) { log(`crossbind: rust bridge: ${cls.name}::${name} skipped (Option<Arc<Self>> is not supported in this wave)`); return; }
@@ -855,7 +1390,7 @@ function parseFn(cls, sig, ctx, log) {
             return;
         }
         if (args.length > 6) { log(`crossbind: rust bridge: ${cls.name}::${name} skipped (max 6 args)`); return; }
-        cls.methods.push({ name, args, ret: `Arc<${target}>`, byRef: selfKind === '&self', throws: false, optionalRet: false });
+        cls.methods.push({ name, args, ret: `Arc<${target}>`, byRef, consumes, throws: false, optionalRet: false });
         return;
     }
     if (optional && !OPTION_INNERS.has(ret)) {
@@ -868,7 +1403,7 @@ function parseFn(cls, sig, ctx, log) {
     if (selfOwned || selfBorrowed) {
         cls.methods.push({
             name, args, ret: selfOwned ? (ret === 'Self' ? cls.name : ret) : cls.name,
-            byRef: selfKind === '&self', throws, optionalRet: false,
+            byRef, consumes, throws, optionalRet: false,
             ownedClass: selfOwned ? (ret === 'Self' ? cls.name : ret) : null,
             borrowedSelf: selfBorrowed,
         });
@@ -879,43 +1414,22 @@ function parseFn(cls, sig, ctx, log) {
         return;
     }
     if (args.length > 6) { log(`crossbind: rust bridge: ${cls.name}::${name} skipped (max 6 args)`); return; }
-    cls.methods.push({ name, args, ret, byRef: selfKind === '&self', throws, optionalRet: optional, collect: returnInfo.collect });
+    cls.methods.push({ name, args, ret, byRef, consumes, throws, optionalRet: optional, collect: returnInfo.collect });
 }
 
 function parseFreeFn(freeFns, sig, ctx, log) {
-    const { enums, valueObjects, classes } = ctx;
     const [, name, rawParams, rawRet] = sig;
-    // A borrowed string is known in both directions: as a parameter it borrows, as a return it
-    // comes back owned.
-    const known = (ty) => PRIMITIVES.has(ty) || PARAM_ONLY.has(ty) || typedArrayOf(ty) || (isCollection(ty) && collectionCarries(ty, ctx))
-        || enums.some((e) => e.name === ty) || valueObjects.some((v) => v.name === ty)
-        || (ctx.newtypes ?? []).some((n) => n.name === ty)
-        || (ctx.jsonTypes ?? []).some((j) => j.name === ty)
-        || isOptionalRecord(ty, ctx);
-    const isClassRef = (ty) => ty.startsWith('&') && !PARAM_ONLY.has(ty) && classes.has(ty.slice(1));
+    const args = parseParams(splitTopLevel(rawParams).map((s) => s.trim()).filter(Boolean), ctx, `fn ${name}`, log);
+    if (!args) return;
+    const entry = callableEntry(name, args, rawRet, ctx, log, `fn ${name}`);
+    if (entry) freeFns.push(entry);
+}
 
-    const args = [];
-    for (const p of splitTopLevel(rawParams).map((s) => s.trim()).filter(Boolean)) {
-        const m = p.match(/^(\w+)\s*:\s*(&\s*(?:str|String)|Option\s*<\s*(?:i32|f64|bool|String|&\s*\w+)\s*>|Vec\s*<[^;]+>|\[[^\]]+;\s*\d+\]|&\s*\[[^\]]+\]|\([^)]*,[^)]*\)|(?:std\s*::\s*collections\s*::\s*)?(?:HashMap|BTreeMap|HashSet|BTreeSet)\s*<[^>]+>|serde_json\s*::\s*Value|(?:std\s*::\s*sync\s*::\s*)?Arc\s*<\s*\w+\s*>|embind_rs\s*::\s*Js(?:Value|Function)|&\s*\w+|[\w()]+)$/);
-        let ty = m?.[2].replace(/\s+/g, '');
-        if (ty) ty = normalizeStringSpelling(ty);
-        if (ty && !known(ty) && isJsonSpelling(ty, ctx)) ty = JSON_TY;
-        if (ty) ty = normalizeArc(ty, ctx);
-        const jsTokP = ty ? matchJsTok(ty, ctx) : null;
-        if (jsTokP) ty = jsTokP;
-        const arcParam = ty?.match(ARC_RE)?.[1];
-        const optClassRef = ty?.match(OPTION_CLASS_REF_RE)?.[1];
-        const closure = closureShape(p.slice(p.indexOf(':') + 1));
-        if (closure) { args.push({ name: `a${args.length}`, ty: `__closure${JSON.stringify(closure)}` }); continue; }
-        if (!m || !(known(ty) || ty === JSON_TY || jsTokP || (arcParam && classes.has(arcParam)) || PARAM_ONLY.has(ty) || OPTION_PARAM_RE.test(ty) || isClassRef(ty)
-            || (optClassRef && classes.has(optClassRef)))) {
-            log(isCollection(ty) && !collectionCarries(ty, ctx)
-                ? `crossbind: rust bridge: fn ${name} skipped (a struct inside '${ty}' must derive Serialize and Deserialize to cross)`
-                : `crossbind: rust bridge: fn ${name} skipped (unsupported parameter '${p}')`);
-            return;
-        }
-        args.push({ name: m[1], ty });
-    }
+// What a free function, or a static function on a class, hands back: null (with the reason
+// logged) when the return cannot cross.
+function callableEntry(name, args, rawRet, ctx, log, label) {
+    const { classes } = ctx;
+    const known = (ty) => isKnownType(ty, ctx);
     const returnInfo = analyzeReturn(rawRet ?? '()', ctx);
     let { inner: ret, throws, optional } = returnInfo;
     if (!known(ret) && isJsonSpelling(ret, ctx)) ret = JSON_TY;
@@ -924,20 +1438,19 @@ function parseFreeFn(freeFns, sig, ctx, log) {
     if (jsTokR) ret = jsTokR;
     const retArc = ret.match(ARC_RE)?.[1];
     if (retArc) {
-        if (!classes.has(retArc)) { log(`crossbind: rust bridge: fn ${name} skipped (unsupported return '${ret}')`); return; }
-        if (throws) { log(`crossbind: rust bridge: fn ${name} skipped (a fallible Arc return is not carried yet)`); return; }
+        if (!classes.has(retArc)) { log(`crossbind: rust bridge: ${label} skipped (unsupported return '${ret}')`); return null; }
+        if (throws) { log(`crossbind: rust bridge: ${label} skipped (a fallible Arc return is not carried yet)`); return null; }
     }
-    if (jsTokR && optional) { log(`crossbind: rust bridge: fn ${name} skipped (Option<${ret}> returns are not supported - return JsValue::null() instead)`); return; }
-    if (optional && !OPTION_INNERS.has(ret) && !retArc) { log(`crossbind: rust bridge: fn ${name} skipped (Option<${ret}> return is not representable - inners: i32, f64, bool, String, Arc<Class>)`); return; }
-    if (isCollection(ret) && !collectionCarries(ret, ctx)) { log(`crossbind: rust bridge: fn ${name} skipped (a struct inside '${ret}' must derive Serialize and Deserialize to cross)`); return; }
+    if (jsTokR && optional) { log(`crossbind: rust bridge: ${label} skipped (Option<${ret}> returns are not supported - return JsValue::null() instead)`); return null; }
+    if (optional && !OPTION_INNERS.has(ret) && !retArc) { log(`crossbind: rust bridge: ${label} skipped (Option<${ret}> return is not representable - inners: i32, f64, bool, String, Arc<Class>)`); return null; }
+    if (isCollection(ret) && !collectionCarries(ret, ctx)) { log(`crossbind: rust bridge: ${label} skipped (a struct inside '${ret}' must derive Serialize and Deserialize to cross)`); return null; }
     // A fresh instance handed back by value: JS owns it and frees it on delete().
     if (classes.has(ret) && !(ctx.jsonTypes ?? []).some((j) => j.name === ret)) {
-        freeFns.push({ name, jsName: camel(name), args, ret, throws, optionalRet: false, ownedClass: ret });
-        return;
+        return { name, jsName: camel(name), args, ret, throws, optionalRet: false, ownedClass: ret };
     }
-    if (!known(ret) && ret !== JSON_TY && !retArc && !jsTokR) { log(`crossbind: rust bridge: fn ${name} skipped (unsupported return '${ret}')`); return; }
-    if (args.length > 6) { log(`crossbind: rust bridge: fn ${name} skipped (max 6 args)`); return; }
-    freeFns.push({ name, jsName: camel(name), args, ret, throws, optionalRet: optional, collect: returnInfo.collect });
+    if (!known(ret) && ret !== JSON_TY && !retArc && !jsTokR) { log(`crossbind: rust bridge: ${label} skipped (unsupported return '${ret}')`); return null; }
+    if (args.length > 6) { log(`crossbind: rust bridge: ${label} skipped (max 6 args)`); return null; }
+    return { name, jsName: camel(name), args, ret, throws, optionalRet: optional, collect: returnInfo.collect };
 }
 
 // ---------------- emitter ----------------
@@ -945,13 +1458,16 @@ function parseFreeFn(freeFns, sig, ctx, log) {
 const camel = (s) => s.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
 
 function emitBridge(model, {
-    userCrate, vectors, log, prelude = '', namePrefix = '',
+    userCrate, vectors, log, prelude = '', namePrefix = '', rustPaths = null, wireNames = null,
 }) {
     const U = userCrate;
+    // A crate import's bridge names each item by the path it is reachable at (the root, or the
+    // module it was imported from); every other bridge has one crate for everything.
+    const rust = (name) => rustPaths?.get(name) ?? `${U}::${name}`;
     // embind's registry is flat, so two crate imports that both export `Version` would collide.
-    // A direct `cargo:` import registers its public names under a per-crate prefix; the generated
+    // A direct `cargo:` import registers its public names under per-crate names; the generated
     // proxy module maps them back to the clean names the import specifier already scopes.
-    const pub = (name) => `${namePrefix}${name}`;
+    const pub = (name) => wireNames?.get(name) ?? `${namePrefix}${name}`;
     const isEnum = (ty) => model.enums.some((e) => e.name === ty);
     const newtypeOf = (ty) => (model.newtypes ?? []).find((n) => n.name === ty);
     // A serde record, a data enum, a value object inside an Option: all cross as plain JS values
@@ -971,6 +1487,8 @@ function emitBridge(model, {
     // as the class pointer via a bridge-local Ref wrapper (borrowed unsafely at the call site).
     // A slice is a collection, not a borrowed class.
     const isRef = (ty) => ty.startsWith('&') && !PARAM_ONLY.has(ty) && !isCollection(ty) && !typedArrayOf(ty);
+    // A struct passed by value rides the `&Struct` pointer wire and is copied out of it.
+    const isClassValue = (ty) => model.classes.some((c) => c.name === ty);
     const arcInner = (ty) => String(ty).match(ARC_RE)?.[1];
     // An optional Arc rides the nullable shared wrapper; every other optional keeps `Option<T>`.
     // `&[T]` decodes into a Vec and is handed back as a slice; every other collection is owned.
@@ -994,7 +1512,7 @@ function emitBridge(model, {
         || model.enums.some((e) => e.name === name)
         || (model.newtypes ?? []).some((n) => n.name === name)
         || (model.jsonTypes ?? []).some((j) => j.name === name)
-            ? `${U}::${name}`
+            ? `${rust(name)}`
             : name));
     const borrowSuffix = (ty) => (!fixedArrayRef(ty) && /^&\s*\[/.test(String(ty).trim()) ? '.as_slice()' : '');
     const borrowPrefix = (ty) => (fixedArrayRef(ty) ? '&' : '');
@@ -1047,7 +1565,7 @@ function emitBridge(model, {
         // (ownedTy qualifies user type names with the crate path)
         : optionStrParam(ty) ? `${expr}.as_deref()`
         : optionClassRef(ty) ? `${expr}.as_option()`
-            : newtypeOf(ty) ? `${U}::${ty}(${expr})`
+            : newtypeOf(ty) ? `${rust(ty)}(${expr})`
         : PARAM_ONLY.has(ty) ? `&${expr}`
         : isRef(ty) ? `unsafe { &*${expr}.0 }`
             : ty === JSON_TY || arcInner(ty) || isEnum(ty) || isVo(ty) ? `${expr}.0` : expr);
@@ -1058,6 +1576,25 @@ function emitBridge(model, {
         : ty === JSON_TY ? `__CrossbindJson(${expr})`
         : arcInner(ty) ? `${arcInner(ty)}Shared(${expr})`
             : isEnum(ty) || isVo(ty) ? `${ty}W(${expr})` : expr);
+    // A property keeps `wireTy` for both halves: embind registers one type for its getter and setter.
+    const optionBigInt = (ty) => String(ty).match(OPTION_BIGINT_RE)?.[1];
+    const optionView = (ty) => String(ty).match(OPTION_VIEW_RE)?.[1];
+    const paramTy = (ty) => (nonZeroBase(ty) ? paramTy(nonZeroBase(ty))
+        : optionNonZero(ty) ? paramTy(`Option<${optionNonZero(ty).base}>`)
+            : typedArrayOf(ty) ? `embind_rs::${typedArrayOf(ty).arg}`
+                : optionBigInt(ty) ? `embind_rs::JsBigIntOptArg<${optionBigInt(ty)}>`
+                    : optionView(ty) ? `embind_rs::JsViewOptArg<${optionView(ty)}>`
+                        : isClassValue(ty) ? `${ty}Ref` : wireTy(ty));
+    // Every shim body runs inside embind_rs::guard, whose return type has an error sentinel, so a
+    // zero can return the raised error before the call.
+    const nonZeroFrom = (inner, value, some) => `match std::num::${inner}::new(${value}) { Some(n) => ${some}, None => return embind_rs::raise_err(String::from("a ${inner} cannot be 0")) }`;
+    const unwrapParam = (ty, expr) => (nonZeroBase(ty) ? nonZeroFrom(ty, unwrapParam(nonZeroBase(ty), expr), 'n')
+        : optionNonZero(ty) ? `match ${unwrapParam(`Option<${optionNonZero(ty).base}>`, expr)} { None => None, Some(v) => ${nonZeroFrom(optionNonZero(ty).inner, 'v', 'Some(n)')} }`
+            : typedArrayOf(ty) ? `${expr}.${typedArrayOf(ty).slice ? 'as_slice()' : 'to_vec()'}`
+                : optionBigInt(ty) ? `${expr}.0`
+                    : optionView(ty) ? `${expr}.as_slice()`
+                        : isClassValue(ty) ? `(unsafe { &*${expr}.0 }).clone()`
+                            : unwrap(ty, expr));
 
     const out = [];
     out.push('// Generated by crossbind rustBridgeGen - do not edit. The user crate stays plain Rust;');
@@ -1076,15 +1613,15 @@ function emitBridge(model, {
         // No derives on the wrapper: a plain fieldless enum need not be Clone or Copy, and the
         // wire only ever moves one (`to_wire` takes self, `from_wire` builds a fresh one).
         out.push('#[repr(transparent)]');
-        out.push(`pub struct ${e.name}W(pub ${U}::${e.name});`);
+        out.push(`pub struct ${e.name}W(pub ${rust(e.name)});`);
         out.push(`impl WireType for ${e.name}W {`);
         out.push('    type Wire = i32;');
         out.push("    const SIG: char = 'i';");
         out.push(`    fn tid() -> *const c_void { enum_tid::<${e.name}W>() }`);
         out.push(`    fn from_wire(w: i32) -> ${e.name}W {`);
         out.push('        match w {');
-        for (const v of e.variants) out.push(`            ${v.value} => ${e.name}W(${U}::${e.name}::${v.name}),`);
-        out.push(`            _ => ${e.name}W(${U}::${e.name}::${e.variants[0].name}),`);
+        for (const v of e.variants) out.push(`            ${v.value} => ${e.name}W(${rust(e.name)}::${v.name}),`);
+        out.push(`            _ => ${e.name}W(${rust(e.name)}::${e.variants[0].name}),`);
         out.push('        }');
         out.push('    }');
         out.push('    fn to_wire(self) -> i32 { self.0 as i32 }');
@@ -1096,8 +1633,8 @@ function emitBridge(model, {
     for (const v of model.valueObjects) {
         out.push('#[derive(Clone, Copy)]');
         out.push('#[repr(transparent)]');
-        out.push(`pub struct ${v.name}W(pub ${U}::${v.name});`);
-        out.push(`impl Default for ${v.name}W { fn default() -> Self { ${v.name}W(${U}::${v.name}::default()) } }`);
+        out.push(`pub struct ${v.name}W(pub ${rust(v.name)});`);
+        out.push(`impl Default for ${v.name}W { fn default() -> Self { ${v.name}W(${rust(v.name)}::default()) } }`);
         out.push(`impl WireType for ${v.name}W {`);
         out.push(`    type Wire = *mut ${v.name}W;`);
         out.push("    const SIG: char = 'p';");
@@ -1113,9 +1650,11 @@ function emitBridge(model, {
     // the referenced classes up front so the wrappers exist before the shims that use them.
     const classRefs = new Set();
     (model.classes ?? []).forEach((c) => c.methods.forEach((m) => { if (m.ownedClass || m.borrowedSelf) classRefs.add(m.ret); }));
+    (model.classes ?? []).forEach((c) => (c.statics ?? []).forEach((f) => { if (f.ownedClass) classRefs.add(f.ownedClass); }));
     (model.freeFns ?? []).forEach((f) => { if (f.ownedClass) classRefs.add(f.ownedClass); });
     const scanRefs = (args) => args.forEach((p) => {
         if (isRef(p.ty)) classRefs.add(p.ty.slice(1));
+        if (isClassValue(p.ty)) classRefs.add(p.ty);
         const optRef = optionClassRef(p.ty);
         if (optRef) classRefs.add(optRef);
     });
@@ -1123,40 +1662,45 @@ function emitBridge(model, {
         if (cls.ctor) scanRefs(cls.ctor.args);
         cls.factories.forEach((f) => scanRefs(f.args));
         cls.methods.forEach((m) => scanRefs(m.args));
+        (cls.statics ?? []).forEach((f) => scanRefs(f.args));
+    }
+    for (const s of model.streams ?? []) {
+        scanRefs(s.ctor.args);
+        s.methods.forEach((m) => scanRefs(m.args));
     }
     (model.freeFns ?? []).forEach((f) => scanRefs(f.args));
     for (const name of [...classRefs].sort()) {
         out.push('#[derive(Clone, Copy)]');
         out.push('#[repr(transparent)]');
-        out.push(`pub struct ${name}Ref(pub *mut ${U}::${name});`);
+        out.push(`pub struct ${name}Ref(pub *mut ${rust(name)});`);
         out.push(`impl WireType for ${name}Ref {`);
         out.push('    type Wire = *mut c_void;');
         out.push("    const SIG: char = 'p';");
-        out.push(`    fn tid() -> *const c_void { embind_rs::class_tid::<${U}::${name}>() }`);
-        out.push(`    fn from_wire(w: *mut c_void) -> ${name}Ref { ${name}Ref(w as *mut ${U}::${name}) }`);
+        out.push(`    fn tid() -> *const c_void { embind_rs::class_tid::<${rust(name)}>() }`);
+        out.push(`    fn from_wire(w: *mut c_void) -> ${name}Ref { ${name}Ref(w as *mut ${rust(name)}) }`);
         out.push(`    fn to_wire(self) -> *mut c_void { self.0 as *mut c_void }`);
         out.push('}');
         out.push('');
         // A fresh instance of the class: the wire is the smart pointer JS owns and frees.
         out.push('#[repr(transparent)]');
-        out.push(`pub struct ${name}Owned(pub *mut ${U}::${name});`);
+        out.push(`pub struct ${name}Owned(pub *mut ${rust(name)});`);
         out.push(`impl WireType for ${name}Owned {`);
         out.push('    type Wire = *mut c_void;');
         out.push("    const SIG: char = 'p';");
-        out.push(`    fn tid() -> *const c_void { embind_rs::owned_ptr_tid::<${U}::${name}>() }`);
-        out.push(`    fn from_wire(w: *mut c_void) -> ${name}Owned { ${name}Owned(w as *mut ${U}::${name}) }`);
+        out.push(`    fn tid() -> *const c_void { embind_rs::owned_ptr_tid::<${rust(name)}>() }`);
+        out.push(`    fn from_wire(w: *mut c_void) -> ${name}Owned { ${name}Owned(w as *mut ${rust(name)}) }`);
         out.push('    fn to_wire(self) -> *mut c_void { self.0 as *mut c_void }');
         out.push('}');
         out.push(`impl embind_rs::ErrSentinel for ${name}Owned { fn err_sentinel() -> Self { ${name}Owned(core::ptr::null_mut()) } }`);
         out.push('');
         // The same object handed back for chaining: a pointer, so JS does not own it twice.
         out.push('#[repr(transparent)]');
-        out.push(`pub struct ${name}RefOut(pub *mut ${U}::${name});`);
+        out.push(`pub struct ${name}RefOut(pub *mut ${rust(name)});`);
         out.push(`impl WireType for ${name}RefOut {`);
         out.push('    type Wire = *mut c_void;');
         out.push("    const SIG: char = 'p';");
-        out.push(`    fn tid() -> *const c_void { embind_rs::class_ptr_tid::<${U}::${name}>() }`);
-        out.push(`    fn from_wire(w: *mut c_void) -> ${name}RefOut { ${name}RefOut(w as *mut ${U}::${name}) }`);
+        out.push(`    fn tid() -> *const c_void { embind_rs::class_ptr_tid::<${rust(name)}>() }`);
+        out.push(`    fn from_wire(w: *mut c_void) -> ${name}RefOut { ${name}RefOut(w as *mut ${rust(name)}) }`);
         out.push('    fn to_wire(self) -> *mut c_void { self.0 as *mut c_void }');
         out.push('}');
         out.push(`impl embind_rs::ErrSentinel for ${name}RefOut { fn err_sentinel() -> Self { ${name}RefOut(core::ptr::null_mut()) } }`);
@@ -1164,17 +1708,17 @@ function emitBridge(model, {
         // `Option<&Class>` parameter: a null pointer is the None the caller wrote as null.
         out.push('#[derive(Clone, Copy)]');
         out.push('#[repr(transparent)]');
-        out.push(`pub struct ${name}RefOpt(pub *mut ${U}::${name});`);
+        out.push(`pub struct ${name}RefOpt(pub *mut ${rust(name)});`);
         out.push(`impl ${name}RefOpt {`);
-        out.push(`    pub fn as_option(&self) -> Option<&${U}::${name}> {`);
+        out.push(`    pub fn as_option(&self) -> Option<&${rust(name)}> {`);
         out.push('        if self.0.is_null() { None } else { Some(unsafe { &*self.0 }) }');
         out.push('    }');
         out.push('}');
         out.push(`impl WireType for ${name}RefOpt {`);
         out.push('    type Wire = *mut c_void;');
         out.push("    const SIG: char = 'p';");
-        out.push(`    fn tid() -> *const c_void { embind_rs::class_ptr_tid::<${U}::${name}>() }`);
-        out.push(`    fn from_wire(w: *mut c_void) -> ${name}RefOpt { ${name}RefOpt(w as *mut ${U}::${name}) }`);
+        out.push(`    fn tid() -> *const c_void { embind_rs::class_ptr_tid::<${rust(name)}>() }`);
+        out.push(`    fn from_wire(w: *mut c_void) -> ${name}RefOpt { ${name}RefOpt(w as *mut ${rust(name)}) }`);
         out.push(`    fn to_wire(self) -> *mut c_void { self.0 as *mut c_void }`);
         out.push('}');
         out.push('');
@@ -1250,15 +1794,15 @@ function emitBridge(model, {
     // pointer, one strong count per JS handle (given on to_wire, added on from_wire).
     for (const inner of model.sharedOf ?? []) {
         out.push('#[repr(transparent)]');
-        out.push(`pub struct ${inner}Shared(pub std::sync::Arc<${U}::${inner}>);`);
+        out.push(`pub struct ${inner}Shared(pub std::sync::Arc<${rust(inner)}>);`);
         out.push(`impl WireType for ${inner}Shared {`);
         out.push('    type Wire = *mut c_void;');
         out.push("    const SIG: char = 'p';");
-        out.push(`    fn tid() -> *const c_void { embind_rs::shared_tid::<${U}::${inner}>() }`);
+        out.push(`    fn tid() -> *const c_void { embind_rs::shared_tid::<${rust(inner)}>() }`);
         out.push('    fn from_wire(w: *mut c_void) -> Self {');
         out.push('        unsafe {');
-        out.push(`            std::sync::Arc::increment_strong_count(w as *const ${U}::${inner});`);
-        out.push(`            ${inner}Shared(std::sync::Arc::from_raw(w as *const ${U}::${inner}))`);
+        out.push(`            std::sync::Arc::increment_strong_count(w as *const ${rust(inner)});`);
+        out.push(`            ${inner}Shared(std::sync::Arc::from_raw(w as *const ${rust(inner)}))`);
         out.push('        }');
         out.push('    }');
         out.push(`    fn to_wire(self) -> *mut c_void { std::sync::Arc::into_raw(self.0) as *mut c_void }`);
@@ -1267,16 +1811,16 @@ function emitBridge(model, {
         // `Option<Arc<T>>`: a null smart pointer is what embind reads back as JS null, so None
         // needs no optional type of its own.
         out.push('#[repr(transparent)]');
-        out.push(`pub struct ${inner}SharedOpt(pub Option<std::sync::Arc<${U}::${inner}>>);`);
+        out.push(`pub struct ${inner}SharedOpt(pub Option<std::sync::Arc<${rust(inner)}>>);`);
         out.push(`impl WireType for ${inner}SharedOpt {`);
         out.push('    type Wire = *mut c_void;');
         out.push("    const SIG: char = 'p';");
-        out.push(`    fn tid() -> *const c_void { embind_rs::shared_tid::<${U}::${inner}>() }`);
+        out.push(`    fn tid() -> *const c_void { embind_rs::shared_tid::<${rust(inner)}>() }`);
         out.push('    fn from_wire(w: *mut c_void) -> Self {');
         out.push(`        if w.is_null() { return ${inner}SharedOpt(None); }`);
         out.push('        unsafe {');
-        out.push(`            std::sync::Arc::increment_strong_count(w as *const ${U}::${inner});`);
-        out.push(`            ${inner}SharedOpt(Some(std::sync::Arc::from_raw(w as *const ${U}::${inner})))`);
+        out.push(`            std::sync::Arc::increment_strong_count(w as *const ${rust(inner)});`);
+        out.push(`            ${inner}SharedOpt(Some(std::sync::Arc::from_raw(w as *const ${rust(inner)})))`);
         out.push('        }');
         out.push('    }');
         out.push('    fn to_wire(self) -> *mut c_void {');
@@ -1293,14 +1837,14 @@ function emitBridge(model, {
     const registrations = [];
     const usedOptionals = new Set();
     const noteOptionArgs = (args) => args.forEach((p) => {
-        const m = p.ty.match(OPTION_PARAM_RE);
+        const m = (optionNonZero(p.ty) ? `Option<${optionNonZero(p.ty).base}>` : p.ty).match(OPTION_PARAM_RE);
         // `Option<&str>` rides the String optional; a class reference needs none (null is None).
         if (m) usedOptionals.add(m[1] === '&str' ? 'String' : m[1]);
     });
     for (const c of model.consts ?? []) {
         registrations.push(c.ty === '&str'
-            ? `    embind_rs::constant_str("${pub(c.name)}", ${U}::${c.name});`
-            : `    embind_rs::constant("${pub(c.name)}", ${U}::${c.name});`);
+            ? `    embind_rs::constant_str("${pub(c.name)}", ${rust(c.name)});`
+            : `    embind_rs::constant("${pub(c.name)}", ${rust(c.name)});`);
     }
     for (const e of model.enums) {
         registrations.push(`    enum_::<${e.name}W>("${pub(e.name)}")${e.variants.map((v) => `.value("${v.name}", ${v.value})`).join('')};`);
@@ -1308,7 +1852,7 @@ function emitBridge(model, {
     for (const v of model.valueObjects) {
         const fields = v.fields.map((f) => {
             const fieldTy = model.valueObjects.some((o) => o.name === f.type) ? `${f.type}W` : f.type;
-            return `.field::<${fieldTy}>("${f.name}", core::mem::offset_of!(${U}::${v.name}, ${f.name}))`;
+            return `.field::<${fieldTy}>("${f.name}", core::mem::offset_of!(${rust(v.name)}, ${f.name}))`;
         }).join('');
         registrations.push(`    value_object_::<${v.name}W>("${pub(v.name)}")${fields}.finalize();`);
     }
@@ -1317,14 +1861,40 @@ function emitBridge(model, {
         registrations.push(`    register_vector::<${vec.of}>("${pub(vec.name)}");`);
     }
 
-    for (const cls of model.classes) {
-        const C = `${U}::${cls.name}`;
+    const RAISE = 'embind_rs::raise_err_coded(e.to_string(), { use embind_rs::{CrossbindErrorCode, CrossbindErrorCodeFallback}; (&e).crossbind_code() })';
+    // A struct handed back by value: JS owns the new instance and frees it on delete().
+    const ownedValue = (wrapper, call, throws) => (throws
+        ? `match ${call} { Ok(v) => ${wrapper}(Box::into_raw(Box::new(v))), Err(e) => ${RAISE} }`
+        : `${wrapper}(Box::into_raw(Box::new(${call})))`);
+    // The return side of a free or static function: its wire type and the body producing it.
+    const callable = (f, rawCall) => {
+        const call = f.collect ? `(${rawCall}).collect::<Vec<_>>()` : rawCall;
+        if (f.ownedClass) return { retTy: `${f.ownedClass}Owned`, body: ownedValue(`${f.ownedClass}Owned`, call, f.throws) };
+        const retTy = f.optionalRet ? optionalWireTy(f.ret) : (f.ret === '()' ? '()' : wireTy(f.ret));
+        if (f.optionalRet && !arcInner(f.ret)) usedOptionals.add(f.ret);
+        const optArc = f.optionalRet && arcInner(f.ret);
+        const body = f.throws
+            ? `match ${call} { Ok(v) => ${wrap(f.ret, 'v')}, Err(e) => ${RAISE} }`
+            : (f.ret === '()' ? call : optArc ? `${arcInner(f.ret)}SharedOpt(${call})` : wrap(f.ret, call));
+        return { retTy, body };
+    };
+    // A class handed back by value needs its smart pointer before the binding that returns it
+    // registers; registering every class first lets bindings name each other's classes in any
+    // order (a builder and the struct it builds return each other).
+    const ownedReturns = new Set([...model.classes.flatMap((c) => [...c.methods, ...(c.statics ?? [])]), ...(model.freeFns ?? [])]
+        .map((f) => f.ownedClass).filter(Boolean));
+    const classHeads = [];
+    const classTails = [];
+
+    for (const [index, cls] of model.classes.entries()) {
+        const C = `${rust(cls.name)}`;
         const shim = (fnName) => `__${cls.name.toLowerCase()}_${fnName}`;
-        const chain = [`    class_::<${C}>("${pub(cls.name)}")`];
-
-        const handsBackSelf = cls.methods.some((m) => m.ownedClass) || (model.freeFns ?? []).some((f) => f.ownedClass === cls.name);
-        if (cls.shared) chain.push(`        .smart_ptr_shared("${pub(cls.name)}Shared")`);
-        else if (cls.factories.length || handsBackSelf) chain.push(`        .smart_ptr("${pub(cls.name)}Ptr")`);
+        const handle = `__class${index}`;
+        const head = [`    let ${handle} = class_::<${C}>("${pub(cls.name)}")`];
+        if (cls.shared) head.push(`        .smart_ptr_shared("${pub(cls.name)}Shared")`);
+        else if (cls.factories.length || ownedReturns.has(cls.name)) head.push(`        .smart_ptr("${pub(cls.name)}Ptr")`);
+        classHeads.push(`${head.join('\n')};`);
+        const chain = [`    ${handle}`];
         // A struct that derives Default and declares no `new` still constructs from JS: the
         // derive is the author saying what a default instance is.
         if (!cls.ctor && !cls.shared && cls.hasDefault) {
@@ -1334,8 +1904,8 @@ function emitBridge(model, {
         if (cls.ctor) {
             const a = cls.ctor.args;
             noteOptionArgs(a);
-            const ps = a.map((p, i) => `a${i}: ${wireTy(p.ty)}`).join(', ');
-            const call = `${C}::new(${a.map((p, i) => unwrap(p.ty, `a${i}`)).join(', ')})`;
+            const ps = a.map((p, i) => `a${i}: ${paramTy(p.ty)}`).join(', ');
+            const call = `${C}::new(${a.map((p, i) => unwrapParam(p.ty, `a${i}`)).join(', ')})`;
             if (cls.ctor.throws) {
                 out.push(`fn ${shim('new')}(${ps}) -> *mut ${C} { ${guarded('*mut', `match ${call} { Ok(v) => Box::into_raw(Box::new(v)), Err(e) => embind_rs::raise_err_coded(e.to_string(), { use embind_rs::{CrossbindErrorCode, CrossbindErrorCodeFallback}; (&e).crossbind_code() }) }`)} }`);
                 chain.push(`        .constructor_ptr${a.length}(${shim('new')})`);
@@ -1346,8 +1916,8 @@ function emitBridge(model, {
         }
         for (const f of cls.factories) {
             noteOptionArgs(f.args);
-            const ps = f.args.map((p, i) => `a${i}: ${wireTy(p.ty)}`).join(', ');
-            const call = `${C}::${f.name}(${f.args.map((p, i) => unwrap(p.ty, `a${i}`)).join(', ')})`;
+            const ps = f.args.map((p, i) => `a${i}: ${paramTy(p.ty)}`).join(', ');
+            const call = `${C}::${f.name}(${f.args.map((p, i) => unwrapParam(p.ty, `a${i}`)).join(', ')})`;
             if (f.shared) {
                 if (f.throws) {
                     out.push(`fn ${shim(f.name)}(${ps}) -> *mut ${C} { match ${call} { Ok(v) => std::sync::Arc::into_raw(v) as *mut ${C}, Err(e) => embind_rs::raise_err_coded(e.to_string(), { use embind_rs::{CrossbindErrorCode, CrossbindErrorCodeFallback}; (&e).crossbind_code() }) } }`);
@@ -1369,6 +1939,13 @@ function emitBridge(model, {
                 chain.push(`        .create_ptr${f.args.length}("${camel(f.name)}", ${shim(f.name)})`);
             }
         }
+        for (const f of cls.statics ?? []) {
+            noteOptionArgs(f.args);
+            const ps = f.args.map((p, i) => `a${i}: ${paramTy(p.ty)}`).join(', ');
+            const { retTy, body } = callable(f, `${C}::${f.name}(${f.args.map((p, i) => unwrapParam(p.ty, `a${i}`)).join(', ')})`);
+            out.push(`fn ${shim(f.name)}(${ps}) -> ${retTy} { ${guarded(retTy, body)} }`);
+            chain.push(`        .static_function${f.args.length}("${camel(f.name)}", ${shim(f.name)})`);
+        }
         for (const f of cls.fields ?? []) {
             out.push(`fn ${shim(`get_${f.name}`)}(t: &mut ${C}) -> ${wireTy(f.type)} { ${wrap(f.type, `t.${f.name}.clone()`)} }`);
             out.push(`fn ${shim(`set_${f.name}`)}(t: &mut ${C}, v: ${wireTy(f.type)}) { t.${f.name} = ${unwrap(f.type, 'v')}; }`);
@@ -1390,16 +1967,16 @@ function emitBridge(model, {
         for (const m of cls.methods) {
             if (accessorNames.has(m.name)) continue;
             noteOptionArgs(m.args);
-            const params = [`t: &mut ${C}`, ...m.args.map((p, i) => `a${i}: ${wireTy(p.ty)}`)].join(', ');
-            const callArgs = m.args.map((p, i) => unwrap(p.ty, `a${i}`)).join(', ');
-            const recv = m.byRef ? '(&*t)' : 't';
+            const params = [`t: &mut ${C}`, ...m.args.map((p, i) => `a${i}: ${paramTy(p.ty)}`)].join(', ');
+            const callArgs = m.args.map((p, i) => unwrapParam(p.ty, `a${i}`)).join(', ');
+            const recv = m.consumes ? '(&*t).clone()' : m.byRef ? '(&*t)' : 't';
             const rawCall = `${recv}.${m.name}(${callArgs})`;
             const call = m.collect ? `(${rawCall}).collect::<Vec<_>>()` : rawCall;
             if (m.ownedClass || m.borrowedSelf) {
                 const wrapper = m.ownedClass ? `${m.ret}Owned` : `${m.ret}RefOut`;
                 const value = m.ownedClass
-                    ? `${wrapper}(Box::into_raw(Box::new(${call})))`
-                    : `${wrapper}(${call} as *mut ${U}::${m.ret})`;
+                    ? ownedValue(wrapper, call, m.throws)
+                    : `${wrapper}(${call} as *mut ${rust(m.ret)})`;
                 out.push(`fn ${shim(m.name)}(${params}) -> ${wrapper} { ${guarded(wrapper, value)} }`);
                 chain.push(`        .function${m.args.length}("${camel(m.name)}", ${shim(m.name)})`);
                 classRefs.add(m.ret);
@@ -1418,27 +1995,71 @@ function emitBridge(model, {
             out.push(`fn ${shim('display_tostring')}(t: &mut ${C}) -> String { ${guarded('String', 'format!("{}", (&*t))')} }`);
             chain.push(`        .function0("toString", ${shim('display_tostring')})`);
         }
-        registrations.push(`${chain.join('\n')};`);
+        if (chain.length > 1) classTails.push(`${chain.join('\n')};`);
     }
+    const streams = model.streams ?? [];
+    if (streams.some((s) => s.role === 'writer')) {
+        // The byte sink every writer stream writes into; each call hands JS what it has gathered.
+        out.push('#[derive(Clone, Default)]');
+        out.push('pub struct __CrossbindSink(std::sync::Arc<std::sync::Mutex<Vec<u8>>>);');
+        out.push('impl std::io::Write for __CrossbindSink {');
+        out.push('    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> { self.0.lock().unwrap().extend_from_slice(buf); Ok(buf.len()) }');
+        out.push('    fn flush(&mut self) -> std::io::Result<()> { Ok(()) }');
+        out.push('}');
+        out.push('impl __CrossbindSink { fn drain(&self) -> Vec<u8> { std::mem::take(&mut *self.0.lock().unwrap()) } }');
+        out.push('');
+    }
+    for (const [index, s] of streams.entries()) {
+        const S = `${s.name}CrossbindStream`;
+        const shim = (fnName) => `__${s.name.toLowerCase()}_${fnName}`;
+        const writer = s.role === 'writer';
+        const finished = `embind_rs::raise_err(String::from("${s.name} is finished"))`;
+        out.push(writer
+            ? `pub struct ${S} { inner: Option<${rust(s.name)}<__CrossbindSink>>, sink: __CrossbindSink }`
+            : `pub struct ${S} { inner: Option<${rust(s.name)}<std::io::Cursor<Vec<u8>>>> }`);
+
+        noteOptionArgs(s.ctor.args);
+        const ps = s.ctor.args.map((p, i) => `a${i}: ${paramTy(p.ty)}`).join(', ');
+        const passed = s.ctor.args.map((p, i) => (!writer && i === s.ctor.at ? `std::io::Cursor::new(a${i}.to_vec())` : unwrapParam(p.ty, `a${i}`)));
+        const call = `${rust(s.name)}::new(${(writer ? [...passed.slice(0, s.ctor.at), 'sink.clone()', ...passed.slice(s.ctor.at)] : passed).join(', ')})`;
+        const store = (value) => `Box::into_raw(Box::new(${S} { inner: Some(${value})${writer ? ', sink' : ''} }))`;
+        const make = s.ctor.throws ? `match ${call} { Ok(v) => ${store('v')}, Err(e) => ${RAISE} }` : store(call);
+        out.push(`fn ${shim('new')}(${ps}) -> *mut ${S} { ${guarded('*mut', writer ? `{ let sink = __CrossbindSink::default(); ${make} }` : make)} }`);
+        const chain = [`    __stream${index}`, `        .constructor_ptr${s.ctor.args.length}(${shim('new')})`];
+
+        if (writer) {
+            out.push(`fn ${shim('write')}(t: &mut ${S}, a0: embind_rs::JsBytesArg) -> embind_rs::JsBytes { embind_rs::guard(|| match t.inner.as_mut() { None => ${finished}, Some(w) => match std::io::Write::write_all(w, a0.as_slice()) { Ok(()) => embind_rs::JsBytes(t.sink.drain()), Err(e) => ${RAISE} } }) }`);
+            out.push(`fn ${shim('flush')}(t: &mut ${S}) -> embind_rs::JsBytes { embind_rs::guard(|| match t.inner.as_mut() { None => ${finished}, Some(w) => match std::io::Write::flush(w) { Ok(()) => embind_rs::JsBytes(t.sink.drain()), Err(e) => ${RAISE} } }) }`);
+            chain.push(`        .function1("write", ${shim('write')})`, `        .function0("flush", ${shim('flush')})`);
+            for (const f of s.finishers) {
+                const done = f.throws
+                    ? `match w.${f.name}() { Ok(_) => embind_rs::JsBytes(t.sink.drain()), Err(e) => ${RAISE} }`
+                    : `{ let _ = w.${f.name}(); embind_rs::JsBytes(t.sink.drain()) }`;
+                out.push(`fn ${shim(f.name)}(t: &mut ${S}) -> embind_rs::JsBytes { embind_rs::guard(|| match t.inner.take() { None => ${finished}, Some(w) => ${done} }) }`);
+                chain.push(`        .function0("${camel(f.name)}", ${shim(f.name)})`);
+            }
+        } else {
+            // read(max) takes up to max bytes, fewer only at the end, growing with what it gets.
+            const readShim = (fnName, params, source) => `fn ${shim(fnName)}(t: &mut ${S}${params}) -> embind_rs::JsBytes { embind_rs::guard(|| match t.inner.as_mut() { None => ${finished}, Some(r) => { let mut out = Vec::new(); match std::io::Read::read_to_end(${source}, &mut out) { Ok(_) => embind_rs::JsBytes(out), Err(e) => ${RAISE} } } }) }`;
+            out.push(readShim('read', ', a0: u32', '&mut std::io::Read::take(r, a0 as u64)'), readShim('read_all', '', 'r'));
+            chain.push(`        .function1("read", ${shim('read')})`, `        .function0("readAll", ${shim('read_all')})`);
+        }
+        for (const m of s.methods) {
+            noteOptionArgs(m.args);
+            const params = [`t: &mut ${S}`, ...m.args.map((p, i) => `a${i}: ${paramTy(p.ty)}`)].join(', ');
+            const { retTy, body } = callable(m, `v.${m.name}(${m.args.map((p, i) => unwrapParam(p.ty, `a${i}`)).join(', ')})`);
+            out.push(`fn ${shim(m.name)}(${params}) -> ${retTy} { ${guarded(retTy, `match t.inner.as_mut() { None => ${finished}, Some(v) => ${body} }`)} }`);
+            chain.push(`        .function${m.args.length}("${camel(m.name)}", ${shim(m.name)})`);
+        }
+        classHeads.push(`    let __stream${index} = class_::<${S}>("${pub(s.name)}");`);
+        classTails.push(`${chain.join('\n')};`);
+    }
+    registrations.push(...classHeads, ...classTails);
 
     for (const f of model.freeFns ?? []) {
         noteOptionArgs(f.args);
-        const ps = f.args.map((p, i) => `a${i}: ${wireTy(p.ty)}`).join(', ');
-        const rawCall = `${U}::${f.name}(${f.args.map((p, i) => unwrap(p.ty, `a${i}`)).join(', ')})`;
-        const call = f.collect ? `(${rawCall}).collect::<Vec<_>>()` : rawCall;
-        const retTy = f.optionalRet ? optionalWireTy(f.ret) : (f.ret === '()' ? '()' : wireTy(f.ret));
-        if (f.optionalRet && !arcInner(f.ret)) usedOptionals.add(f.ret);
-        if (f.ownedClass) {
-            const wrapper = `${f.ownedClass}Owned`;
-            out.push(`fn __free_${f.name}(${ps}) -> ${wrapper} { ${guarded(wrapper, `${wrapper}(Box::into_raw(Box::new(${call})))`)} }`);
-            registrations.push(`    embind_rs::fn${f.args.length}("${pub(f.jsName)}", __free_${f.name});`);
-            classRefs.add(f.ownedClass);
-            continue;
-        }
-        const optArc = f.optionalRet && arcInner(f.ret);
-        const body = f.throws
-            ? `match ${call} { Ok(v) => ${wrap(f.ret, 'v')}, Err(e) => embind_rs::raise_err_coded(e.to_string(), { use embind_rs::{CrossbindErrorCode, CrossbindErrorCodeFallback}; (&e).crossbind_code() }) }`
-            : (f.ret === '()' ? call : optArc ? `${arcInner(f.ret)}SharedOpt(${call})` : wrap(f.ret, call));
+        const ps = f.args.map((p, i) => `a${i}: ${paramTy(p.ty)}`).join(', ');
+        const { retTy, body } = callable(f, `${rust(f.name)}(${f.args.map((p, i) => unwrapParam(p.ty, `a${i}`)).join(', ')})`);
         out.push(`fn __free_${f.name}(${ps}) -> ${retTy} { ${guarded(retTy, body)} }`);
         registrations.push(`    embind_rs::fn${f.args.length}("${pub(f.jsName)}", __free_${f.name});`);
     }
@@ -1492,6 +2113,10 @@ export function emitDts(model, vectors, mode = 'sync') {
     const ts = (ty) => {
         const opt = ty.match(OPTION_PARAM_RE);
         if (opt) return `${TS_TYPES[opt[1]] ?? opt[1]} | null | undefined`;
+        const optView = ty.match(OPTION_VIEW_RE);
+        if (optView) return `${optView[1] === 'u8' ? 'Uint8Array' : 'Float64Array'} | null | undefined`;
+        if (nonZeroBase(ty)) return TS_TYPES[nonZeroBase(ty)];
+        if (optionNonZero(ty)) return `${TS_TYPES[optionNonZero(ty).base]} | null | undefined`;
         if (ty === JSON_TY) return 'JsonValue';
         const arc = ty.match(ARC_RE);
         if (arc) return arc[1];  // Arc<X> is transparent in JS: the shared instance itself
@@ -1536,6 +2161,9 @@ export function emitDts(model, vectors, mode = 'sync') {
         for (const f of cls.factories) {
             out.push(`    static ${camel(f.name)}(${f.args.map((p) => `${p.name}: ${ts(p.ty)}`).join(', ')}): ${wrap(`${cls.name}${f.optional ? ' | null' : ''}`)};`);
         }
+        for (const f of cls.statics ?? []) {
+            out.push(`    static ${camel(f.name)}(${f.args.map((p) => `${p.name}: ${ts(p.ty)}`).join(', ')}): ${wrap(`${ts(f.ret)}${f.optionalRet ? ' | null' : ''}`)};`);
+        }
         for (const m of cls.methods) {
             out.push(`    ${camel(m.name)}(${m.args.map((p) => `${p.name}: ${ts(p.ty)}`).join(', ')}): ${wrap(`${ts(m.ret)}${m.optionalRet ? ' | null' : ''}`)};`);
         }
@@ -1543,6 +2171,23 @@ export function emitDts(model, vectors, mode = 'sync') {
         out.push(`    delete(): ${wrap('void')};`);
         out.push('}');
     }
+    for (const s of model.streams ?? []) {
+        out.push(`export declare class ${s.name} {`);
+        out.push(`    constructor(${s.ctor.args.map((p) => `${p.name}: ${ts(p.ty)}`).join(', ')});`);
+        if (s.role === 'writer') {
+            out.push(`    write(data: Uint8Array): ${wrap('Uint8Array')};`);
+            out.push(`    flush(): ${wrap('Uint8Array')};`);
+            for (const f of s.finishers) out.push(`    ${camel(f.name)}(): ${wrap('Uint8Array')};`);
+        } else {
+            out.push(`    read(max: number): ${wrap('Uint8Array')};`);
+            out.push(`    readAll(): ${wrap('Uint8Array')};`);
+        }
+        for (const m of s.methods) {
+            out.push(`    ${camel(m.name)}(${m.args.map((p) => `${p.name}: ${ts(p.ty)}`).join(', ')}): ${wrap(`${ts(m.ret)}${m.optionalRet ? ' | null' : ''}`)};`);
+        }
+        out.push(`    delete(): ${wrap('void')};`);
+        out.push('}');
+    }
     for (const f of model.freeFns ?? []) {
         out.push(`export declare function ${f.jsName}(${f.args.map((p) => `${p.name}: ${ts(p.ty)}`).join(', ')}): ${wrap(`${ts(f.ret)}${f.optionalRet ? ' | null' : ''}`)};`);
     }