behavior-contracts 0.4.0 → 0.6.0

package/dist/generator/emit-typed-native-rust.js

@@ -0,0 +1,2123 @@
+import { GeneratorFailure } from "./core.js";
+import { rustStraightlineInternals } from "./emit-shared-rust.js";
+import { rustTypedInternals } from "./emit-shared-rust-typed.js";
+import { buildTypePlan, deriveTypeRef, findDecl } from "./typed.js";
+import { concurrencyPlan, execPlan, analyzeSequentialOps, classifyExpr } from "./straightline.js";
+import { NativeExprCompiler } from "./native-expr.js";
+import { buildAsyncPlans } from "./async-plan.js";
+const { sanitize, rustStrLit } = rustStraightlineInternals;
+const { rustFieldName, renderTypeRef, typedCell, typedFieldAccess, serializeTyped, emitTypeDecls, emitDefaults, emitSerializers, emitTypedValue, emitMarshallers, emitMarshalHelpers, materializeExpr, } = rustTypedInternals;
+/** rustErr — build the LOCAL concrete error value for a behavior/plan failure on the covered read
+ * plane (runtime-free). The covered module declares a local `BehaviorError` (see emitBehaviorErrorType);
+ * the runner returns `Result<_, BehaviorError>` over THAT local type. This REPLACES the old
+ * `behavior_contracts::BehaviorError::new(...)` (the last error-plane runtime coupling) — the SAME codes
+ * are preserved verbatim so the observed failure is byte-equal to run_behavior. */
+function rustErr(code, msgExpr) {
+    return `BehaviorError::new(${JSON.stringify(code)}, ${msgExpr})`;
+}
+/** emitBehaviorErrorType — the LOCAL concrete error type baked into the covered module so a runner can
+ * fail closed with ZERO bc-runtime import. Codes match run_behavior verbatim (byte-equal). `code()` /
+ * `failure_code()` expose the stable code without a bc-runtime type. */
+function emitBehaviorErrorType() {
+    return `// BehaviorError — the LOCAL concrete failure type for the covered read plane (runtime-free): a
+// covered runner returns \`Result<T, BehaviorError>\` over THIS local type instead of a bc-runtime
+// failure, so the fully-covered module imports ZERO bc runtime. Codes match run_behavior verbatim
+// (byte-equal). The observe companion (test glue, a super:: submodule) bridges this local error to the
+// bc-runtime BehaviorError at the observe boundary — the covered module itself stays runtime-free.
+#[derive(Debug, Clone)]
+pub struct BehaviorError {
+    pub code: String,
+    pub message: String,
+}
+
+impl BehaviorError {
+    pub fn new(code: impl Into<String>, message: impl Into<String>) -> Self {
+        BehaviorError { code: code.into(), message: message.into() }
+    }
+    /// The stable failure code (byte-equal to run_behavior) WITHOUT a bc-runtime type.
+    pub fn code(&self) -> &str {
+        &self.code
+    }
+}
+
+impl std::fmt::Display for BehaviorError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}: {}", self.code, self.message)
+    }
+}
+impl std::error::Error for BehaviorError {}`;
+}
+function portFieldName(wire) {
+    const safe = wire.replace(/[^A-Za-z0-9_]/g, "_").toLowerCase();
+    return `f_${safe}`;
+}
+function pascal(s) {
+    return s.replace(/[^A-Za-z0-9]+/g, " ").split(" ").filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("") || "X";
+}
+function portsStructName(compName, nodeId) {
+    return `PortsNR${pascal(compName)}${pascal(nodeId)}`;
+}
+/** RawRowNR<Comp><Node> — the concrete per-node handler-result row struct name. */
+function rawRowStructName(compName, nodeId) {
+    return `RawRowNR${pascal(compName)}${pascal(nodeId)}`;
+}
+/** RawElemNR<Comp><Node> — the concrete per-ELEMENT row struct name for a covered map node. */
+function rawElemStructName(compName, nodeId) {
+    return `RawElemNR${pascal(compName)}${pascal(nodeId)}`;
+}
+/** HandlerNR<Comp> — the per-component concrete handler trait name (one node_* method per node). */
+function handlerTraitName(compName) {
+    return `HandlerNR${pascal(compName)}`;
+}
+/** node_<id> — the concrete per-node handler method name. */
+function nodeMethodName(nodeId) {
+    return `node_${nodeId.replace(/[^A-Za-z0-9_]/g, "_").toLowerCase()}`;
+}
+/** InNR<Comp> — the concrete per-component input struct name (fields = inputPorts). */
+function inStructName(compName) {
+    return `InNR${pascal(compName)}`;
+}
+function staticArrElems(node) {
+    if (node === null || typeof node !== "object" || Array.isArray(node))
+        return null;
+    const keys = Object.keys(node);
+    if (keys.length !== 1 || keys[0] !== "arr")
+        return null;
+    const arg = node.arr;
+    return Array.isArray(arg) ? arg : null;
+}
+function inferPortType(node, inputPorts, asBinding) {
+    if (staticArrElems(node) !== null)
+        return "Value";
+    const e = classifyExpr(node);
+    switch (e.kind) {
+        case "str":
+        case "concat":
+            return "String";
+        case "bool":
+            return "bool";
+        case "ref": {
+            // #108: a `$as`-headed ref (map element binding) — resolve the element field's scalar type.
+            if (asBinding !== undefined && e.path[0] === asBinding.name) {
+                try {
+                    const { ref } = typedFieldAccess(asBinding.name, asBinding.ref, e.path.slice(1), asBinding.plan);
+                    if (ref.kind === "scalar" && ref.scalar !== "null")
+                        return rustScalar(ref.scalar);
+                }
+                catch {
+                    return "Value";
+                }
+                return "Value";
+            }
+            if (e.path.length === 1) {
+                const s = inputPorts[e.path[0]];
+                if (s) {
+                    if (s.type === "string")
+                        return "String";
+                    if (s.type === "int")
+                        return "i64";
+                    if (s.type === "float")
+                        return "f64";
+                    if (s.type === "bool")
+                        return "bool";
+                }
+            }
+            return "Value";
+        }
+        default:
+            return "Value";
+    }
+}
+/** A static string-array port (every element a static string literal) — the graphddb `projection`
+ * shape. Returns the list of literal strings, or null when the node is not that shape. */
+function staticStringArrElems(node) {
+    const arr = staticArrElems(node);
+    if (arr === null)
+        return null;
+    const out = [];
+    for (const el of arr) {
+        const e = classifyExpr(el);
+        if (e.kind !== "str")
+            return null;
+        out.push(e.value);
+    }
+    return out;
+}
+/**
+ * portFieldRustType — the NATIVE Rust type for a covered port field (bc#90 / runtime-free). The covered
+ * ports struct carries NO `Value` field: every port lowers to a concrete Rust type.
+ *   - a static string-array (projection) → `Vec<&'static str>` (change #2);
+ *   - a bare int/float number literal (e.g. Query `limit: 20`) → `i64` / `f64`;
+ *   - a string/bool/scalar-input port → the scalar Rust type (inferPortType).
+ * A port that would otherwise infer to the boxed `Value` (a dynamic operator, a non-static array, a
+ * Value-typed input) FAILS CLOSED — the covered read plane admits NO boxed escape (there is no `Value`
+ * fallback on the native module). `where` names the emission site for the error.
+ */
+function portFieldRustType(node, inputPorts, where = "port", asBinding) {
+    if (staticStringArrElems(node) !== null)
+        return "Vec<&'static str>";
+    const num = numLiteralRustExpr(node);
+    if (num !== null)
+        return typeof node === "number" && Number.isInteger(node) ? "i64" : "f64";
+    const ft = inferPortType(node, inputPorts, asBinding);
+    if (ft === "Value") {
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust combined read (bc#90 / runtime-free): ${where} '${JSON.stringify(node)}' does not lower to a native Rust type (would need a boxed Value). The covered read plane is runtime-free and admits NO boxed escape — the covered corpus ports are string / bool / static-string-array (projection) / bare-number (limit) only. Regenerate on the boxed straight-line path if this port is genuinely dynamic.`);
+    }
+    return ft;
+}
+/**
+ * emitPortsStruct — the CONCRETE native ports struct for a componentRef node. Typed fields per the
+ * static port type, constructed directly. NO `impl PortReaderT` / by-name `port()` — the covered runner
+ * passes `&PortsNR…` to the concrete `node_*` method by direct generic instantiation, and the handler
+ * reads `ports.f_<field>` DIRECTLY. The struct derives Clone (a bc#87 parallel stage clones it into the
+ * per-worker dispatch). Every field is a NATIVE Rust type (bc#90 / runtime-free) — NO boxed `Value`.
+ */
+function emitPortsStruct(comp, node, asBinding) {
+    const name = portsStructName(comp.name, node.id);
+    const portNames = Object.keys(node.ports);
+    if (portNames.length === 0) {
+        return `// ${name} — native ports for node '${node.id}' (${node.component}); no ports.\n#[derive(Clone)]\npub struct ${name};`;
+    }
+    const types = portNames.map((p) => portFieldRustType(node.ports[p], comp.inputPorts, `port '${p}' of node '${node.id}'`, asBinding));
+    const fields = portNames
+        .map((p, i) => `    pub ${portFieldName(p)}: ${types[i]}, // ${JSON.stringify(p)}`)
+        .join("\n");
+    return `// ${name} — CONCRETE native ports for node '${node.id}' (${node.component}). Typed fields per the
+// static port type; constructed directly (no Vec, no heap key strings, no per-port Value boxing). The
+// handler reads the typed fields directly off this concrete struct — no by-name accessor.
+#[derive(Clone)]
+pub struct ${name} {
+${fields}
+}`;
+}
+/**
+ * emitMapPortsStructs — element ports struct + batch struct for a covered map node (CONCRETE). The batch
+ * struct carries the Vec of per-element CONCRETE ports structs (the handler reads them off the concrete
+ * struct — no by-name accessor, no key-value object).
+ */
+function emitMapPortsStructs(comp, node, typedNodes, plan) {
+    const m = node.map;
+    const name = portsStructName(comp.name, node.id);
+    const batch = `${name}Batch`;
+    // #108: element ports may read the `$as` binding — resolve the over element type for native typing.
+    const { elemRef } = mapOverElemInfo(comp, node, typedNodes, plan);
+    const asBinding = { name: m.as, ref: elemRef, plan };
+    const elemStruct = emitPortsStruct(comp, { id: node.id, component: m.component, ports: m.ports }, asBinding);
+    return `${elemStruct}
+
+// ${batch} — CONCRETE batched ports for map '${node.id}': the Vec of per-element CONCRETE ports structs
+// (a Vec<${name}>, NOT a generic key-value container). The consumer's batched handler reads the typed
+// element ports off the concrete struct directly.
+#[derive(Clone)]
+pub struct ${batch} {
+    pub items: Vec<${name}>,
+}`;
+}
+// ── native expression compiler backend (#108) — cond `if` / map `when` / cond branches (Rust) ────────
+//
+// The runtime-free native expression compiler (native-expr.ts) mirrors run_behavior's cond/guard with
+// BYTE-EQUAL semantics. The value-dependent runtime failures (INT_OVERFLOW / NAN_OR_INF / MOD_ZERO /
+// PRECISION_LOSS) are emitted as calls to a FIXED set of RUNTIME-FREE helper fns baked into the module
+// (bc_expr_* below) returning Result<T, BehaviorError> — the covered module still imports ZERO bc runtime.
+// The runner is Result<_, BehaviorError>, so a fallible helper propagates with `?`.
+let rustExprTempSeq = 0;
+/** module-level accumulator: set when the native-expr compiler emits a fallible helper call (so emit()
+ * bakes the helper library). Reset at the start of each emit(). */
+const rustExprUsed = { helpers: false };
+/** makeRustExprBackend — renders native-expr for Rust. `resolveHead` maps a ref head to an OWNED typed
+ * base expr (a prior-node cell clone / an input field / a $as element). Sets rustExprUsed.helpers when
+ * a fallible helper is emitted. The runner is Result<_, BehaviorError>, so hoistFallible uses `?`. */
+function makeRustExprBackend(resolveHead, plan) {
+    const used = rustExprUsed;
+    return {
+        lang: "rust",
+        freshTemp: () => `ex_${rustExprTempSeq++}`,
+        renderType: (ref) => renderTypeRef(ref),
+        scalarType: (s) => rustScalar(s),
+        strLit: (s) => `${rustStrLit(s)}.to_string()`,
+        boolLit: (b) => (b ? "true" : "false"),
+        intLit: (dec) => `${dec}i64`,
+        floatLit: (n) => `${rustFloatLitExpr(n)}f64`,
+        fieldAccess: (baseExpr, baseRef, path) => typedFieldAccess(baseExpr, baseRef, path, plan),
+        resolveHead,
+        hoistFallible: (temp, _ty, call) => {
+            used.helpers = true;
+            return [`let ${temp} = ${call}?;`];
+        },
+        helperCall: (helper, args) => {
+            used.helpers = true;
+            // the string code-point compare helpers take &str — borrow the owned String args.
+            const isStrCmp = helper === "strLt" || helper === "strLe" || helper === "strGt" || helper === "strGe";
+            const passed = isStrCmp ? args.map((a) => `&${a}`) : args;
+            // lenArr takes &[T] — borrow the owned Vec.
+            const finalArgs = helper === "lenArr" ? args.map((a) => `&${a}`) : passed;
+            return `bc_expr_${rustSnake(helper)}(${finalArgs.join(", ")})`;
+        },
+        binOp: (op, a, b) => `(${a} ${op} ${b})`,
+        concat: (parts) => {
+            // native String concat via a `[&str; N].concat()` — a string-literal part (`"…".to_string()`) is
+            // used as the bare `"…"` &str; any other owned String is borrowed with `.as_str()`. This shape is
+            // clippy-clean (no to_string_in_format_args / single_char_push_str / unnecessary_to_string).
+            const refs = parts.map((p) => {
+                const m = /^(".*")\.to_string\(\)$/.exec(p);
+                return m ? m[1] : `(${p}).as_str()`;
+            });
+            return `[${refs.join(", ")}].concat()`;
+        },
+        notOp: (a) => `(!${a})`,
+        structLit: (name, inits) => `${name} { ${inits.map((i) => `${rustFieldName(i.field)}: ${i.expr}`).join(", ")} }`,
+        arrLit: (elemTy, items) => `{ let __v: Vec<${elemTy}> = vec![${items.join(", ")}]; __v }`,
+        ternary: (cond, t, e, _ty) => `(if ${rustStripOuterParens(cond)} { ${rustStripOuterParens(t)} } else { ${rustStripOuterParens(e)} })`,
+        shortCircuitBool: (op, temp, left, rStmts, rExpr) => {
+            // and: let temp = if left { <rStmts> rExpr } else { false };  or: if left { true } else { <rStmts> rExpr }.
+            // build a block that runs rStmts then yields rExpr (parens stripped — block-tail is not a sub-expr).
+            const rblock = `{ ${rStmts.join(" ")} ${rustStripOuterParens(rExpr)} }`;
+            if (op === "and") {
+                return [`let ${temp}: bool = if ${rustStripOuterParens(left)} ${rblock} else { false };`];
+            }
+            return [`let ${temp}: bool = if ${rustStripOuterParens(left)} { true } else ${rblock};`];
+        },
+        condGuard: (temp, ty, cond, tStmts, tExpr, eStmts, eExpr) => {
+            const tblock = `{ ${tStmts.join(" ")} ${rustStripOuterParens(tExpr)} }`;
+            const eblock = `{ ${eStmts.join(" ")} ${rustStripOuterParens(eExpr)} }`;
+            return [`let ${temp}: ${ty} = if ${rustStripOuterParens(cond)} ${tblock} else ${eblock};`];
+        },
+    };
+}
+/** camelCase helper name → snake_case for the Rust helper fn (addI64 → add_i64, strLt → str_lt). */
+function rustSnake(name) {
+    return name.replace(/([a-z])([A-Z0-9])/g, "$1_$2").replace(/([0-9])([a-z])/g, "$1_$2").toLowerCase();
+}
+/** strip ONE redundant outer paren pair from an expr (clippy `if (cond)` unused_parens). Only when the
+ * whole string is a single balanced `( … )` — a `(a) && (b)` stays untouched. */
+function rustStripOuterParens(expr) {
+    if (!expr.startsWith("(") || !expr.endsWith(")"))
+        return expr;
+    let depth = 0;
+    for (let i = 0; i < expr.length; i++) {
+        if (expr[i] === "(")
+            depth++;
+        else if (expr[i] === ")") {
+            depth--;
+            if (depth === 0 && i !== expr.length - 1)
+                return expr; // closed before the end → not a single wrap
+        }
+    }
+    return expr.slice(1, -1);
+}
+/** Rust float literal (finite; integral gets `.0`). */
+function rustFloatLitExpr(n) {
+    if (Number.isInteger(n))
+        return `${n}.0`;
+    return String(n);
+}
+/**
+ * emitExprHelpersRust — the FIXED runtime-free native-expr helper library (Rust). Emitted once per
+ * covered module that uses cond/guard/arith. Each helper is BYTE-EQUAL to expr-eval.ts core. Failures
+ * are the LOCAL BehaviorError with the SAME code strings as run_behavior.
+ */
+function emitExprHelpersRust() {
+    return `// ── native-expr runtime-free helper library (#108) — byte-equal to expr-eval.ts core ──
+#[allow(dead_code)]
+fn bc_expr_add_i64(a: i64, b: i64) -> Result<i64, BehaviorError> {
+    a.checked_add(b).ok_or_else(|| BehaviorError::new("INT_OVERFLOW", "i64 overflow"))
+}
+#[allow(dead_code)]
+fn bc_expr_sub_i64(a: i64, b: i64) -> Result<i64, BehaviorError> {
+    a.checked_sub(b).ok_or_else(|| BehaviorError::new("INT_OVERFLOW", "i64 overflow"))
+}
+#[allow(dead_code)]
+fn bc_expr_mul_i64(a: i64, b: i64) -> Result<i64, BehaviorError> {
+    a.checked_mul(b).ok_or_else(|| BehaviorError::new("INT_OVERFLOW", "i64 overflow"))
+}
+#[allow(dead_code)]
+fn bc_expr_neg_i64(a: i64) -> Result<i64, BehaviorError> {
+    a.checked_neg().ok_or_else(|| BehaviorError::new("INT_OVERFLOW", "i64 overflow"))
+}
+#[allow(dead_code)]
+fn bc_expr_check_finite(v: f64) -> Result<f64, BehaviorError> {
+    if v.is_finite() { Ok(v) } else { Err(BehaviorError::new("NAN_OR_INF", "non-finite float")) }
+}
+#[allow(dead_code)]
+fn bc_expr_add_f(a: f64, b: f64) -> Result<f64, BehaviorError> { bc_expr_check_finite(a + b) }
+#[allow(dead_code)]
+fn bc_expr_sub_f(a: f64, b: f64) -> Result<f64, BehaviorError> { bc_expr_check_finite(a - b) }
+#[allow(dead_code)]
+fn bc_expr_mul_f(a: f64, b: f64) -> Result<f64, BehaviorError> { bc_expr_check_finite(a * b) }
+#[allow(dead_code)]
+fn bc_expr_neg_f(a: f64) -> Result<f64, BehaviorError> { bc_expr_check_finite(-a) }
+#[allow(dead_code)]
+fn bc_expr_mod_f(a: f64, b: f64) -> Result<f64, BehaviorError> { bc_expr_check_finite(a % b) }
+#[allow(dead_code)]
+fn bc_expr_mod_i64(a: i64, b: i64) -> Result<i64, BehaviorError> {
+    if b == 0 { return Err(BehaviorError::new("MOD_ZERO", "int mod by zero")); }
+    // Rust % is truncated (sign of dividend) — matches modCore. MIN % -1 would panic; guard it.
+    if a == i64::MIN && b == -1 { return Ok(0); }
+    Ok(a % b)
+}
+#[allow(dead_code)]
+fn bc_expr_widen_i64f(a: i64) -> Result<f64, BehaviorError> {
+    if !(-9007199254740992..=9007199254740992).contains(&a) {
+        return Err(BehaviorError::new("PRECISION_LOSS", "int exceeds exact float range (±2^53)"));
+    }
+    Ok(a as f64)
+}
+#[allow(dead_code)]
+fn bc_expr_div_f(a: f64, b: f64) -> Result<f64, BehaviorError> { bc_expr_check_finite(a / b) }
+#[allow(dead_code)]
+fn bc_expr_len_arr<T>(a: &[T]) -> Result<i64, BehaviorError> {
+    i64::try_from(a.len()).map_err(|_| BehaviorError::new("INT_OVERFLOW", "i64 overflow"))
+}
+// code-point (char) order comparison — matches cmpCodePoints (char-by-char, NOT byte order).
+#[allow(dead_code)]
+fn bc_expr_cmp_cp(a: &str, b: &str) -> std::cmp::Ordering {
+    let mut ia = a.chars();
+    let mut ib = b.chars();
+    loop {
+        match (ia.next(), ib.next()) {
+            (None, None) => return std::cmp::Ordering::Equal,
+            (None, Some(_)) => return std::cmp::Ordering::Less,
+            (Some(_), None) => return std::cmp::Ordering::Greater,
+            (Some(ca), Some(cb)) => {
+                if ca != cb {
+                    return if (ca as u32) < (cb as u32) { std::cmp::Ordering::Less } else { std::cmp::Ordering::Greater };
+                }
+            }
+        }
+    }
+}
+#[allow(dead_code)]
+fn bc_expr_str_lt(a: &str, b: &str) -> bool { bc_expr_cmp_cp(a, b) == std::cmp::Ordering::Less }
+#[allow(dead_code)]
+fn bc_expr_str_le(a: &str, b: &str) -> bool { bc_expr_cmp_cp(a, b) != std::cmp::Ordering::Greater }
+#[allow(dead_code)]
+fn bc_expr_str_gt(a: &str, b: &str) -> bool { bc_expr_cmp_cp(a, b) == std::cmp::Ordering::Greater }
+#[allow(dead_code)]
+fn bc_expr_str_ge(a: &str, b: &str) -> bool { bc_expr_cmp_cp(a, b) != std::cmp::Ordering::Less }`;
+}
+// ── CONCRETE per-node row structs + row→outType copiers (mirror the Go concrete contract) ──────────
+//
+// Each covered node has a CONCRETE row struct `RawRowNR<Comp><Node>` whose fields are the node's projected
+// outType fields (typed, flattened) plus a per-node error signal (is_error/err). A named-struct outType
+// flattens to one Rust field per outType field; a scalar/arr/opt node carries a single `val: <typed>`
+// payload. The per-component `HandlerNR<Comp>` trait has one method per node returning that concrete
+// struct; the runner reads `row.<field>` DIRECTLY (no `RawValue`, no `match`, no `Value::`) and copies
+// each field into the node's outType struct local.
+/** emitRawRowStructs — emit the concrete `RawRowNR<Comp><Node>` struct per covered node (+ per-element
+ * `RawElemNR<Comp><Node>` for a covered map). Every row carries the per-node error signal (is_error/err). */
+function emitRawRowStructs(comp, typedNodes, plan) {
+    const parts = [];
+    for (const n of comp.body) {
+        if ("cond" in n)
+            continue; // #108: a cond node has no handler-result row (pure Expression).
+        const ref = typedNodes.get(n.id);
+        if ("map" in n) {
+            const arrRef = ref;
+            const elemRowRef = mapElemRowRef(n, arrRef, plan);
+            parts.push(emitOneRowStruct(rawElemStructName(comp.name, n.id), elemRowRef, plan));
+            parts.push(`// ${rawRowStructName(comp.name, n.id)} — the BATCH row for map '${n.id}': the aligned per-element rows.\n` +
+                `#[derive(Default)]\npub struct ${rawRowStructName(comp.name, n.id)} {\n    pub is_error: bool,\n    pub err: String,\n    pub rows: Vec<${rawElemStructName(comp.name, n.id)}>,\n}`);
+            continue;
+        }
+        parts.push(emitOneRowStruct(rawRowStructName(comp.name, n.id), ref, plan));
+    }
+    return parts.join("\n\n");
+}
+/** Emit one concrete row struct: flatten a named outType to typed fields, else a single `val` payload;
+ * always carry is_error/err. Derives Default so a handler can build an error row cheaply (`..Default`). */
+function emitOneRowStruct(name, ref, plan) {
+    const lines = [];
+    lines.push(`// ${name} — CONCRETE handler-result row (typed fields = the node's outType; + error signal).`);
+    lines.push(`#[derive(Default)]`);
+    lines.push(`pub struct ${name} {`);
+    lines.push(`    pub is_error: bool,`);
+    lines.push(`    pub err: String,`);
+    if (ref.kind === "named") {
+        const decl = findDecl(plan, ref.name);
+        for (const f of decl.fields) {
+            lines.push(`    pub ${rustFieldName(f.name)}: ${renderTypeRef(f.type)}, // ${JSON.stringify(f.name)}`);
+        }
+    }
+    else {
+        lines.push(`    pub val: ${renderTypeRef(ref)},`);
+    }
+    lines.push(`}`);
+    return lines.join("\n");
+}
+/** emitRowCopy — the statement copying a concrete row's typed fields into the node's outType local
+ * `target` (a value of Rust type renderTypeRef(ref)). Named: struct literal from the row's moved fields;
+ * scalar/arr/opt: `.val`. `rowExpr` is the concrete row VALUE (moved). No dynamic read — pure move/copy. */
+function emitRowMove(target, rowExpr, ref, plan) {
+    if (ref.kind === "named") {
+        const decl = findDecl(plan, ref.name);
+        const inits = decl.fields.map((f) => `${rustFieldName(f.name)}: ${rowExpr}.${rustFieldName(f.name)}`).join(", ");
+        return `${target} = ${ref.name} { ${inits} };`;
+    }
+    return `${target} = ${rowExpr}.val;`;
+}
+/**
+ * boundRustType (change #3 — typed `bound`) — the CONCRETE Rust type of a covered node's `bound` handler
+ * param (bc#90 / runtime-free). `bound` is the parent-produced key (the bindField value); it replaces the
+ * old boxed `Value`. We represent PRODUCED-vs-UNPRODUCED with an OWNED `Option<K>`: `Some(v)` = the parent
+ * value was produced/present (an empty string is a VALID produced value — `Some("")`); `None` =
+ * UNPRODUCED/skip (exactly the old `!= Null` guard ≡ run_behavior). `K` is the bindField's concrete Rust
+ * type (a string key here). A node WITHOUT a bindField never receives a bound value — its param is an
+ * `Option<String>` placeholder always passed `None` (a typed None, so the ABI stays uniform and carries
+ * NO Value).
+ */
+function boundRustType(node, typedNodes, plan) {
+    if (node.bindField === undefined || node.parent === undefined)
+        return "Option<String>";
+    const parentRef = typedNodes.get(node.parent);
+    if (parentRef === undefined)
+        return "Option<String>";
+    let bfRef;
+    try {
+        bfRef = typedFieldAccess(`${typedCell(node.parent)}.borrow()`, parentRef, [node.bindField], plan).ref;
+    }
+    catch {
+        return "Option<String>";
+    }
+    // opt bindField: the field is already `Option<T>` — the bound is that same Option. A required scalar
+    // bindField: the bound is `Option<T>` (always Some — the "produced" pointer is never None).
+    if (bfRef.kind === "opt")
+        return `Option<${renderTypeRef(bfRef.inner)}>`;
+    return `Option<${renderTypeRef(bfRef)}>`;
+}
+/**
+ * emitHandlerTrait — the per-component `HandlerNR<Comp>` trait: one concrete-typed `node_*` method per
+ * covered node. A componentRef node method takes the node's native ports struct + the typed produced-aware
+ * `bound` (change #3 — NO boxed Value) and returns Option<RawRowNR…> (None = unknown component,
+ * fail-closed). A covered map node's method takes the batch ports struct (batched) or the element ports
+ * struct (per-element). This is the fully-concrete, runtime-free replacement for the NativeRawComponentExec
+ * seam.
+ */
+function emitHandlerTrait(comp, typedNodes, plan, ap) {
+    // bc#97 (increment 2): async I/O model is PER-TERMINAL-NODE. A node whose terminal handler is declared
+    // async gets an `async fn node_*` (the consumer's impl returns a future the runner awaits at the call
+    // site); a sync terminal stays plain `fn node_*` (called directly, no await). Mixed sync+async in one
+    // trait is fine. `async fn` needs NO external runtime to compile — the future is `async fn` sugar over
+    // std, so the covered module stays runtime-free either way. Uniform ioModel:'async' ⇒ every method
+    // async (byte-identical to increment-1); ioModel unset/'sync' ⇒ every method plain `fn` (pre-#97).
+    const fnKwFor = (nodeId) => (ap.nodeIsAsync(nodeId) ? "async fn" : "fn");
+    const lines = [];
+    lines.push(`// ${handlerTraitName(comp.name)} — the CONCRETE per-component handler seam: one typed method`);
+    lines.push(`// per covered node (native ports struct IN, concrete row struct OUT). No generic boxed-ports`);
+    lines.push(`// / boxed-value / dynamic accessor crosses the covered boundary — the consumer implements each`);
+    lines.push(`// node_* with a decode of its own wire payload into the concrete row (see INTEGRATION.md §6).`);
+    lines.push(`pub trait ${handlerTraitName(comp.name)} {`);
+    for (const n of comp.body) {
+        if ("cond" in n)
+            continue; // #108: a cond node has no handler method (pure Expression).
+        const method = nodeMethodName(n.id);
+        const fnKw = fnKwFor(n.id);
+        const bt = boundRustType(n, typedNodes, plan);
+        if ("map" in n) {
+            const m = n.map;
+            const batched = m.batched === true;
+            const portsT = batched ? `${portsStructName(comp.name, n.id)}Batch` : portsStructName(comp.name, n.id);
+            const retT = batched ? rawRowStructName(comp.name, n.id) : rawElemStructName(comp.name, n.id);
+            lines.push(`    ${fnKw} ${method}(&self, ports: &${portsT}, bound: ${bt}) -> Option<${retT}>;`);
+            continue;
+        }
+        lines.push(`    ${fnKw} ${method}(&self, ports: &${portsStructName(comp.name, n.id)}, bound: ${bt}) -> Option<${rawRowStructName(comp.name, n.id)}>;`);
+    }
+    lines.push(`}`);
+    return lines.join("\n");
+}
+/** mapElemMaterializerName — the augmented-element copier for a covered map...into node. */
+function mapElemMaterializerName(nodeId) {
+    return `materialize_map_elem_${typedCell(nodeId)}`;
+}
+/** mapElemRowRef — the handler's per-element RETURN shape for a covered map node: the `into` field's
+ * type (into) or the element outType directly (no-into). This is the type of RawElemNR<Comp><Node>. */
+function mapElemRowRef(node, arrRef, plan) {
+    const m = node.map;
+    if (m.into === undefined)
+        return arrRef.elem;
+    if (arrRef.elem.kind !== "named") {
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust combined map (#86 pt2): node '${node.id}' element outType must be a named struct — regenerate as boxed typed/straight-line.`);
+    }
+    const decl = findDecl(plan, arrRef.elem.name);
+    const intoField = decl.fields.find((f) => f.name === m.into);
+    if (!intoField) {
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust combined map (#86 pt2): element struct '${arrRef.elem.name}' has no '${m.into}' (into) field.`);
+    }
+    return intoField.type;
+}
+/**
+ * emitMapElemMaterializers — for each covered map...into node, emit the AUGMENTED-element copier: copy
+ * the over element's typed fields + move the `into` field from the concrete per-element handler row
+ * (RawElemNR). Pure struct field assignment — NO dynamic value read (the handler already produced the
+ * typed into row).
+ */
+function emitMapElemMaterializers(comp, typedNodes, plan) {
+    const parts = [];
+    for (const n of comp.body) {
+        if (!("map" in n))
+            continue;
+        const m = n.map;
+        // #93 shape 3: a NO-into map materializes each element directly from the per-element row.
+        if (m.into === undefined)
+            continue;
+        const arrRef = typedNodes.get(n.id);
+        if (arrRef.kind !== "arr" || arrRef.elem.kind !== "named") {
+            throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust combined map (#86 pt2): node '${n.id}' element outType must be a named struct — regenerate as boxed typed/straight-line.`);
+        }
+        const elemRef = arrRef.elem;
+        const decl = findDecl(plan, elemRef.name);
+        const intoKey = m.into;
+        const intoField = decl.fields.find((f) => f.name === intoKey);
+        const overFields = decl.fields.filter((f) => f.name !== intoKey);
+        const overElemTy = mapOverElemType(comp, n, typedNodes, plan);
+        const fn = mapElemMaterializerName(n.id);
+        const elemRowGo = rawElemStructName(comp.name, n.id);
+        const intoRowRef = mapElemRowRef(n, arrRef, plan);
+        const inits = [];
+        // Copy scalars (i64/f64/bool) copy directly; String/named/arr/opt clone (clippy clone_on_copy clean).
+        for (const f of overFields) {
+            const isCopy = f.type.kind === "scalar" && (f.type.scalar === "int" || f.type.scalar === "float" || f.type.scalar === "bool");
+            inits.push(`        ${rustFieldName(f.name)}: over.${rustFieldName(f.name)}${isCopy ? "" : ".clone()"},`);
+        }
+        // move the into field off the concrete element row (named → struct literal; scalar/arr/opt → .val).
+        const intoValue = intoRowRef.kind === "named"
+            ? `${intoRowRef.name} { ${findDecl(plan, intoRowRef.name).fields.map((f) => `${rustFieldName(f.name)}: into.${rustFieldName(f.name)}`).join(", ")} }`
+            : `into.val`;
+        parts.push(`#[allow(dead_code)]
+fn ${fn}(over: &${overElemTy}, into: ${elemRowGo}) -> ${elemRef.name} {
+    ${elemRef.name} {
+${inits.join("\n")}
+        ${rustFieldName(intoKey)}: ${intoValue},
+    }
+}`);
+        void intoField;
+    }
+    return parts.join("\n\n");
+}
+/**
+ * mapOverElemInfo — resolve a covered map's `over` collection element TypeRef + the OWNED Rust
+ * expression that yields the over Vec (#108, rust twin): prior-node arr field (cell clone) or an input
+ * array port with elemType (`in_.<field>.clone()`). Fail-closed for an input array without elemType.
+ */
+function mapOverElemInfo(comp, node, typedNodes, plan) {
+    const m = node.map;
+    const e = classifyExpr(m.over);
+    if (e.kind === "ref" && e.path.length >= 1 && typedNodes.has(e.path[0])) {
+        const baseRef = typedNodes.get(e.path[0]);
+        const { ref } = typedFieldAccess(`${typedCell(e.path[0])}.borrow()`, baseRef, e.path.slice(1), plan);
+        if (ref.kind === "arr") {
+            const fieldPath = e.path.slice(1).map((p) => `.${rustFieldName(p)}`).join("");
+            return { elemRef: ref.elem, overExpr: `${typedCell(e.path[0])}.borrow()${fieldPath}.clone()` };
+        }
+    }
+    if (e.kind === "ref" && e.path.length === 1) {
+        const schema = comp.inputPorts?.[e.path[0]];
+        const et = schema?.elemType;
+        if (et !== undefined)
+            return { elemRef: deriveTypeRef(et, plan), overExpr: `in_.${rustFieldName(e.path[0])}.clone()` };
+    }
+    throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust combined map (#108): map '${node.id}' 'over' must be a ref to a prior node's typed arr field OR an input array port with a declared elemType. BC does not infer input-array element types (consumer-interface C3).`);
+}
+/** The Rust type of the over-element (back-compat shim). */
+function mapOverElemType(comp, node, typedNodes, plan) {
+    return renderTypeRef(mapOverElemInfo(comp, node, typedNodes, plan).elemRef);
+}
+// ── eligibility ─────────────────────────────────────────────────────────────────────
+function reconstructR(e) {
+    switch (e.kind) {
+        case "str":
+            return e.value;
+        case "bool":
+            return e.value;
+        case "null":
+            return null;
+        case "ref":
+            return { [e.opt ? "refOpt" : "ref"]: e.path };
+        case "concat":
+            return { concat: e.parts.map(reconstructR) };
+        case "dynamic":
+            return e.node;
+    }
+}
+/**
+ * numLiteralRustExpr — a BARE numeric port literal (JSON number, e.g. the `limit: 20` Query port).
+ * `classifyExpr` leaves a bare number `dynamic` (its checked int/float range rules are the evaluate
+ * SSoT), so it never reaches the static str/bool/null branch — but a number literal IS statically
+ * resolvable to a native `Value`: the SAME range check the runtime applies (integral literal in the
+ * safe 2^53-1 window → Value::Int; a fractional/exponent literal → the checked Value::Float) is
+ * performed HERE at generation time. Returns the Rust expression for the literal's Value, or null
+ * when the node is not a bare number OR an integral literal is out of the safe window (keeping the
+ * runtime INVALID_LITERAL semantics — the port is not covered natively, the component falls through).
+ * Mirrors behavior_contracts eval of a bare number literal exactly.
+ */
+const NUM_SAFE_INT_R = 9007199254740991; // 2^53 - 1 (expr safeInt)
+function numLiteralRustExpr(node) {
+    if (typeof node !== "number" || !Number.isFinite(node))
+        return null;
+    if (Number.isInteger(node)) {
+        if (node < -NUM_SAFE_INT_R || node > NUM_SAFE_INT_R)
+            return null; // out of safe window → not covered
+        return `Value::Int(${node}i64)`;
+    }
+    // fractional / exponent literal → checked f64 (finite, guaranteed above).
+    return `Value::Float(${node}f64)`;
+}
+/** A port node is static (literal / ref / concat of those / static arr / bare number literal) —
+ * resolvable to a native Value with no Obj / no evaluate interpreter. */
+function portIsStatic(node) {
+    const arr = staticArrElems(node);
+    if (arr !== null)
+        return arr.every(portIsStatic);
+    if (numLiteralRustExpr(node) !== null)
+        return true; // bare number literal (e.g. Query `limit`)
+    const e = classifyExpr(node);
+    switch (e.kind) {
+        case "str":
+        case "bool":
+        case "null":
+        case "ref":
+            return true;
+        case "concat":
+            return e.parts.every((p) => portIsStatic(reconstructR(p)));
+        default:
+            return false;
+    }
+}
+/** The output must lower to a typed struct/value with no scope read: a ref to a BODY NODE, an
+ * obj/arr of such, or a concat. A ref to an input param / non-concat operator is not lowerable. */
+function outputIsNativeLowerable(comp) {
+    const bodyIds = new Set(comp.body.map((n) => n.id));
+    const walk = (node) => {
+        const arr = staticArrElems(node);
+        if (arr !== null)
+            return arr.every(walk);
+        if (node !== null && typeof node === "object" && !Array.isArray(node)) {
+            const keys = Object.keys(node);
+            if (keys.length === 1 && keys[0] === "obj") {
+                const obj = node.obj;
+                return Object.keys(obj).every((k) => walk(obj[k]));
+            }
+            if (keys.length === 1 && keys[0] === "arr")
+                return true;
+        }
+        const e = classifyExpr(node);
+        if (e.kind === "str" || e.kind === "bool" || e.kind === "null")
+            return true;
+        if (e.kind === "ref")
+            return bodyIds.has(e.path[0]);
+        if (e.kind === "concat")
+            return e.parts.every((p) => walk(reconstructR(p)));
+        return false;
+    };
+    return walk(comp.output);
+}
+/**
+ * coveredMapNode — the #86 part 2 covered map shape (nestedBatchGet), rust twin of the go predicate.
+ */
+function coveredMapNode(n, bodyIds, comp) {
+    if (n === null || typeof n !== "object" || !("map" in n))
+        return false;
+    const m = n.map;
+    // #108 (rust twin of the go predicate): a guarded map (`when`) IS covered with NO `into` (guard+into
+    // is heterogeneous — fail-closed). over element type must be statically resolvable: prior-node arr
+    // field, or an input array port carrying `elemType` (BC does not infer — consumer-interface C3).
+    if (m.when !== undefined && m.into !== undefined)
+        return false;
+    if (m.policy !== undefined && m.policy !== "fail")
+        return false;
+    if (m.relationKind !== undefined && m.relationKind !== "single" && m.relationKind !== "connection")
+        return false;
+    const overE = classifyExpr(m.over);
+    if (overE.kind !== "ref")
+        return false;
+    const head = overE.path[0];
+    if (!bodyIds.has(head)) {
+        if (overE.path.length !== 1)
+            return false;
+        const schema = comp.inputPorts?.[head];
+        if (schema === undefined || schema.elemType === undefined)
+            return false;
+    }
+    const ports = m.ports;
+    for (const p of Object.keys(ports))
+        if (!portIsStatic(ports[p]))
+            return false;
+    return true;
+}
+/** A covered read SHAPE with static ports + native-lowerable output (+ covered map...into), OR a
+ * real-concurrency staged plan (bc#87) whose parallel-stage members are plain componentRef point reads. */
+function isSequentialComponentRefRead(comp) {
+    return coverageRejectReason(comp) === null;
+}
+/**
+ * coverageRejectReason — the DIAGNOSTIC twin of isSequentialComponentRefRead (bc#86/#89), rust twin of
+ * the go predicate. Returns null when the component IS a covered native read; otherwise a SPECIFIC
+ * human-readable reason naming the exact disqualifier and the offending node id. The predicate logic is
+ * IDENTICAL to isSequentialComponentRefRead (defined as `coverageRejectReason(c) === null`) so the two
+ * can never disagree. This is the message the fail-closed dispatch surfaces per non-native component.
+ */
+function coverageRejectReason(comp) {
+    const ep = execPlan(comp);
+    if (ep === null)
+        return "component is not a straight-line/staged sequential exec plan (no static exec plan)";
+    for (const [i] of ep.parallelStageOf) {
+        const n = comp.body[i];
+        if (!("component" in n))
+            return `node '${n.id}' is a non-componentRef member of a parallel stage (not native-covered)`;
+        if (n.bindField !== undefined)
+            return `node '${n.id}' is a bindField relation child inside a parallel stage (not native-covered)`;
+    }
+    const bodyIds = new Set(comp.body.map((b) => b.id));
+    for (const n of comp.body) {
+        if ("cond" in n) {
+            // #108: a cond node is native-covered (its if/then/else compile via the runtime-free
+            // NativeExprCompiler; an uncovered expr fails closed at emit). cond requires outType.
+            if (n.outType === undefined)
+                return `node '${n.id}' cond has no outType (required to de-box the branch join)`;
+            continue;
+        }
+        if ("map" in n) {
+            if (!coveredMapNode(n, bodyIds, comp))
+                return `node '${n.id}' is a non-covered map shape (guard+into heterogeneous, or over an input array without elemType)`;
+            continue;
+        }
+        if (!("component" in n))
+            return `node '${n.id}' is not a componentRef, map, or cond node (not native-covered)`;
+        const cr = n;
+        if (cr.policy !== undefined && cr.policy !== "fail")
+            return `node '${n.id}' componentRef policy '${cr.policy}' (produced-aware output not yet native-covered)`;
+        if (cr.bindField !== undefined && cr.relationKind !== "single" && cr.relationKind !== "connection")
+            return `node '${n.id}' relationKind '${cr.relationKind ?? "point"}' not native-covered (bindField only supports single|connection)`;
+        if (cr.relationKind !== undefined && cr.relationKind !== "single" && cr.relationKind !== "connection")
+            return `relationKind '${cr.relationKind}' not native-covered (node '${n.id}')`;
+        for (const p of Object.keys(cr.ports))
+            if (portIsStatic(cr.ports[p]) === false)
+                return `node '${n.id}' port '${p}' is not statically resolvable`;
+    }
+    if (!outputIsNativeLowerable(comp))
+        return "output is not natively lowerable";
+    return null;
+}
+function isFullyTyped(comp) {
+    if (comp.outputType === undefined)
+        return false;
+    for (const n of comp.body)
+        if (n.outType === undefined)
+            return false;
+    return true;
+}
+function isNativeRaw(comp) {
+    return isSequentialComponentRefRead(comp) && isFullyTyped(comp);
+}
+function assertTypedCoverage(comp) {
+    if (!isSequentialComponentRefRead(comp))
+        return;
+    if (isFullyTyped(comp))
+        return;
+    throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust combined read (bc#77): component '${comp.name}' is a sequential componentRef read but lacks outType/outputType on every node — the combined emitter de-boxes the RESULT into the node's outType struct, so a covered read MUST be fully typed (bc#45). Add outType annotations, or regenerate on rust-straightline-native (boxed result).`);
+}
+// ── typed input struct (InNR<Comp>) + NATIVE scalar port lowering ────────────────────────────
+/** Rust type for an input port's declared type (scalar → concrete; array+elemType → Vec<ElemT>; else Value). */
+function inputPortRustType(schema, plan) {
+    switch (schema?.type) {
+        case "string":
+            return "String";
+        case "int":
+            return "i64";
+        case "float":
+            return "f64";
+        case "bool":
+            return "bool";
+        case "array":
+        case "arr": {
+            // #108: an input ARRAY port with a declared elemType lowers to a native Vec<ElemT>.
+            const et = schema.elemType;
+            if (et !== undefined && plan !== undefined)
+                return `Vec<${renderTypeRef(deriveTypeRef(et, plan))}>`;
+            return "Value";
+        }
+        default:
+            return "Value";
+    }
+}
+/** The scalar kind an input port declares, or undefined if it is not a native scalar. */
+function inputScalarKind(schema) {
+    switch (schema?.type) {
+        case "string":
+            return "String";
+        case "int":
+            return "i64";
+        case "float":
+            return "f64";
+        case "bool":
+            return "bool";
+        default:
+            return undefined;
+    }
+}
+/** emitInStruct — the concrete input struct declaration for a covered component (fields = inputPorts).
+ * Empty inputPorts => empty struct. Derives Default so a consumer/test can build it field-by-field. */
+function emitInStruct(comp, plan) {
+    const name = inStructName(comp.name);
+    const ports = Object.keys(comp.inputPorts ?? {});
+    if (ports.length === 0) {
+        return `// ${name} — the CONCRETE input for '${comp.name}' (no input ports).\n#[derive(Default)]\npub struct ${name};`;
+    }
+    const fields = ports
+        .map((p) => `    pub ${rustFieldName(p)}: ${inputPortRustType(comp.inputPorts[p], plan)}, // ${JSON.stringify(p)}`)
+        .join("\n");
+    return `// ${name} — the CONCRETE input for '${comp.name}' (fields = inputPorts; typed, consumer-built —
+// NO generic Value slice, NO per-field boxing crosses the covered read boundary).
+#[derive(Default)]
+pub struct ${name} {
+${fields}
+}`;
+}
+/**
+ * emitNativeScalar — lower a static port expr to a NATIVE Rust expression of the concrete `want` scalar
+ * type, or null if it cannot be statically proven that type. A string literal is native for
+ * `want==="string"`, a bool literal for `want==="bool"`. A ref resolves via `resolveRef`. A concat lowers
+ * ONLY into `string` and only when EVERY part is a native string, emitting a single `format!("{}{}…", …)`.
+ */
+function emitNativeScalar(node, want, resolveRef) {
+    if (staticArrElems(node) !== null)
+        return null;
+    const e = classifyExpr(node);
+    switch (e.kind) {
+        case "str":
+            return want === "String" ? `${rustStrLit(e.value)}.to_string()` : null;
+        case "bool":
+            return want === "bool" ? (e.value ? "true" : "false") : null;
+        case "null":
+            return null;
+        case "ref": {
+            const sc = resolveRef(e.path[0], e.path.slice(1), e.opt);
+            if (sc === null || sc.scalar !== want)
+                return null;
+            return sc.expr;
+        }
+        case "concat": {
+            if (want !== "String")
+                return null;
+            // a single-part concat is just the owned String of that part.
+            if (e.parts.length === 1)
+                return emitNativeScalar(reconstructR(e.parts[0]), "String", resolveRef);
+            // multi-part: fold into ONE format! (statically strings only — the concat's strings-only
+            // TYPE_MISMATCH can never fire, so dropping the check is sound). To stay clippy-clean
+            // (to_string_in_format_args), a string-literal part is baked into the format STRING itself
+            // (escaped) rather than passed as a `{}` arg; a ref part becomes a `{}` arg (Display on String).
+            let fmt = "";
+            const args = [];
+            for (const p of e.parts) {
+                const sub = classifyExpr(reconstructR(p));
+                if (sub.kind === "str") {
+                    fmt += sub.value.replace(/[{}]/g, (c) => c + c); // escape { } for the format string
+                    continue;
+                }
+                const arg = emitNativeScalar(reconstructR(p), "String", resolveRef);
+                if (arg === null)
+                    return null;
+                fmt += "{}";
+                args.push(arg);
+            }
+            if (args.length === 0)
+                return `${rustStrLit(fmt)}.to_string()`;
+            return `format!(${rustStrLit(fmt)}, ${args.join(", ")})`;
+        }
+        default:
+            return null;
+    }
+}
+// bc#90 / runtime-free: the old `emitStaticR` / `inputLeafR` / `valueLeafR` port lowering (which built
+// `Value` leaves via the primitives::* helpers and struct-field serializers) is REMOVED — every covered
+// port now lowers to a FULLY NATIVE Rust value in emitPortInit (string / bool / static-string-array /
+// number literal), and a genuinely-dynamic port fails closed. There is no boxed-Value fallback on the
+// covered read plane.
+/**
+ * emitPortInit — emit the port field build for one port as a FULLY NATIVE Rust expression (bc#90 /
+ * runtime-free). Every covered port lowers to a concrete Rust value assigned straight into the ports
+ * struct field — NO `Value`, NO fallback path, NO `match`:
+ *   - a static string array (projection) → `vec!["a", "b", ...]` (change #2);
+ *   - a bare int/float number literal (e.g. Query `limit: 20`) → `20i64` / `<n>f64`;
+ *   - a string/bool/scalar-input port → the native scalar expression (emitNativeScalar).
+ * A port that CANNOT lower natively FAILS CLOSED (there is no boxed Value fallback on the covered plane —
+ * a boxed escape would re-introduce the bc-runtime coupling this module removes). `fieldRustType` is the
+ * ports-struct field type (from portFieldRustType); `resolveRef` resolves a ref head for the scalar path.
+ */
+function emitPortInit(pn, expr, fieldRustType, resolveRef) {
+    const field = portFieldName(pn);
+    // change #2: a static string array (projection) → a native `vec![...]` of &'static str.
+    const strArr = staticStringArrElems(expr);
+    if (strArr !== null) {
+        if (fieldRustType !== "Vec<&'static str>") {
+            throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust combined read (bc#90): port '${pn}' is a static string array but its field type is '${fieldRustType}' (expected Vec<&'static str>).`);
+        }
+        return `${field}: vec![${strArr.map((s) => rustStrLit(s)).join(", ")}]`;
+    }
+    // a bare number literal (e.g. Query `limit: 20`): the SSoT range check ran in numLiteralRustExpr —
+    // emit the concrete native i64/f64 (unwrap the Value::Int/Float box: it was only there for the old
+    // boxed path; the range check is what matters, and it already passed).
+    const num = numLiteralRustExpr(expr);
+    if (num !== null) {
+        if (fieldRustType === "i64")
+            return `${field}: ${expr}i64`;
+        if (fieldRustType === "f64")
+            return `${field}: ${expr}f64`;
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust combined read (bc#90): port '${pn}' is a number literal but its field type is '${fieldRustType}'.`);
+    }
+    // string / bool / scalar-input / concat → native scalar expression (no Value, no `match`).
+    const native = emitNativeScalar(expr, fieldRustType, resolveRef);
+    if (native !== null) {
+        return `${field}: ${native}`;
+    }
+    // FAIL CLOSED: the covered read plane is runtime-free — no boxed Value fallback (that would re-couple
+    // the covered module to bc-runtime). If a genuinely-dynamic port reaches here, the component is not
+    // native-eligible and must regenerate on the boxed straight-line path.
+    throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust combined read (bc#90 / runtime-free): port '${pn}' (${JSON.stringify(expr)}) does not lower to a native Rust value of type '${fieldRustType}'. The covered read plane admits NO boxed Value escape — regenerate on the boxed straight-line path if this port is genuinely dynamic.`);
+}
+// ── the combined runner (STRUCT-returning; INLINE sequential; native ports in; concrete row out) ──
+/** resolveRefAt for the top-level runner: a ref head is a PRIOR NODE (its typed scalar field) or an
+ * INPUT PORT (in_.<field>). A REQUIRED scalar resolves to an OWNED native Rust expression; opt / non-
+ * scalar / refOpt → null (fall back to the Value path). */
+function runnerResolveRef(priorNodeAt, atPos, typedNodes, plan, inputPorts) {
+    return (head, restPath, opt) => {
+        if (opt)
+            return null;
+        if (priorNodeAt(head, atPos)) {
+            const baseRef = typedNodes.get(head);
+            let acc;
+            let expr;
+            try {
+                const r = typedFieldAccess(`${typedCell(head)}.borrow()`, baseRef, restPath, plan);
+                expr = r.expr;
+                acc = r.ref;
+            }
+            catch {
+                return null;
+            }
+            if (acc.kind !== "scalar" || acc.scalar === "null")
+                return null;
+            // OWNED: a string field is cloned; int/float/bool are Copy (deref off the Ref).
+            const owned = acc.scalar === "string" ? `(${expr}).clone()` : `*(${expr})`;
+            return { expr: owned, scalar: rustScalar(acc.scalar) };
+        }
+        if (restPath.length !== 0)
+            return null;
+        const scalar = inputScalarKind(inputPorts?.[head]);
+        if (scalar === undefined)
+            return null;
+        const field = `in_.${rustFieldName(head)}`;
+        const owned = scalar === "String" ? `${field}.clone()` : field;
+        return { expr: owned, scalar };
+    };
+}
+function rustScalar(s) {
+    return s === "string" ? "String" : s === "int" ? "i64" : s === "float" ? "f64" : "bool";
+}
+function emitNativeRawRunner(comp, plan, ap) {
+    const ep = execPlan(comp);
+    const order = ep.order;
+    const hasConcurrency = ep.parallelStageOf.size > 0;
+    const fn = sanitize(comp.name);
+    const isAsync = ap.runnerIsAsync;
+    // bc#97: the async runner awaits each async handler at its call site (derived per-node). A real-
+    // concurrency stage (bc#87) dispatches handlers from scoped std threads — that mechanism cannot host
+    // `.await` (a std thread is not an async task). Fail closed LOUDLY (rather than emit code that won't
+    // compile) iff the runner is async AND has a concurrency stage. NOTE: with per-node granularity a
+    // consumer CAN keep a concurrency-stage component sync (declare only its OTHER terminals async) — only
+    // a component that both concurrency-stages AND awaits is rejected. Async + concurrent-stage (issuing
+    // the stage's futures with join!) is a documented follow-up.
+    if (isAsync && hasConcurrency) {
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust typed-native async (bc#97): component '${comp.name}' has a bc#87 real-concurrency stage AND an async terminal handler, but a scoped-std-thread stage cannot host \`.await\`. Async + concurrent-stage (join! over the stage's futures) is a follow-up — declare this component's terminals sync, or split the concurrency stage.`);
+    }
+    const typedNodes = new Map();
+    for (const n of comp.body)
+        typedNodes.set(n.id, deriveTypeRef(n.outType, plan));
+    const idToIndex = new Map();
+    comp.body.forEach((n, i) => idToIndex.set(n.id, i));
+    const opsLiteral = comp.body.map((n) => {
+        const cr = n;
+        const pid = cr.parent;
+        return { id: n.id, parent: pid !== undefined ? idToIndex.get(pid) ?? null : null, policy: cr.policy, bindField: cr.bindField };
+    });
+    const metas = analyzeSequentialOps(opsLiteral, order);
+    const idToPos = new Map();
+    order.forEach((opIdx, k) => idToPos.set(comp.body[opIdx].id, k));
+    const priorNodeAt = (head, atPos) => {
+        const p = idToPos.get(head);
+        return p !== undefined && p < atPos;
+    };
+    const outRef = comp.outputType !== undefined ? deriveTypeRef(comp.outputType, plan) : undefined;
+    const outTy = outRef ? renderTypeRef(outRef) : "Value";
+    // Does any expression read an input param? If not, `in_` is unused — bind `_in_` to stay clippy-clean.
+    // #108: this must recurse ALL expression operators (cond if/then/else, map when + ports, arith/compare/…),
+    // not just ref/concat — a cond `if:{gt:[{add:[{ref:["x"]}…]}]}` reads `in_.x` through nested operators.
+    const readsInput = (() => {
+        // walk any Expression IR node; `bound` = names bound in this scope (a map $as) that are NOT input.
+        const walk = (node, atPos, bound) => {
+            if (node === null || typeof node === "boolean" || typeof node === "string" || typeof node === "number")
+                return false;
+            if (Array.isArray(node))
+                return node.some((el) => walk(el, atPos, bound));
+            const rec = node;
+            const keys = Object.keys(rec);
+            if (keys.length === 1 && (keys[0] === "ref" || keys[0] === "refOpt")) {
+                const path = rec[keys[0]];
+                const head = path[0];
+                return !bound.has(head) && !priorNodeAt(head, atPos);
+            }
+            // any other single-key operator (obj/arr/concat/add/gt/cond/…): recurse into every child value.
+            return keys.some((k) => walk(rec[k], atPos, bound));
+        };
+        return [...order.keys()].some((k) => {
+            const nd = comp.body[order[k]];
+            if ("map" in nd) {
+                const m = nd.map;
+                const bound = new Set([m.as]);
+                // the map's OVER is evaluated in the outer scope (may read input); ports + when in element scope.
+                if (walk(m.over, k, new Set()))
+                    return true;
+                if (m.when !== undefined && walk(m.when, k, bound))
+                    return true;
+                return Object.values(m.ports).some((pn) => walk(pn, k, bound));
+            }
+            if ("cond" in nd) {
+                const c = nd.cond;
+                return walk(c.if, k, new Set()) || walk(c.then, k, new Set()) || walk(c.else, k, new Set());
+            }
+            const cr = nd;
+            return Object.values(cr.ports).some((pn) => walk(pn, k, new Set()));
+        });
+    })();
+    const inParam = readsInput ? "in_" : "_in_";
+    const lines = [];
+    lines.push(`// run_native_raw_struct_${fn} — the STRUCT-RETURNING combined read (bc#77/#87/#94): the fully`);
+    lines.push(`// de-plumbed CONCRETE path. Generic over the per-component CONCRETE ${handlerTraitName(comp.name)} trait,`);
+    lines.push(`// whose node_* methods take the node's native ports struct and return the concrete per-node row`);
+    lines.push(`// struct (typed fields = the outType). The runner builds each ports struct by direct native`);
+    lines.push(`// construction (a simple string port lowers to a native Rust expr), dispatches the concrete`);
+    lines.push(`// node_* method, and reads row.<field> DIRECTLY into the node's outType struct cell — no boxed`);
+    lines.push(`// handler result, no generic enum crossing, no dispatch on a dynamic value on the covered plane. Node`);
+    lines.push(`// results are typed struct cells; a relation child reads the parent's REAL struct result via`);
+    lines.push(`// direct field access (child-present decision from the real parent value — relationSingle /`);
+    lines.push(`// connection converge). A real-concurrency stage (bc#87) is static parallel orchestration —`);
+    lines.push(`// scoped worker threads (bounded by the static plan.concurrency) call the concrete node_*`);
+    lines.push(`// method; preflight + interpret are committed in ascending index order so the value / op`);
+    lines.push(`// multiset / failure precedence byte-match run_behavior. The output is a typed struct/value`);
+    lines.push(`// assembled by struct literal + field access — the consumer keeps it native.`);
+    const bound = hasConcurrency ? `<H: ${handlerTraitName(comp.name)} + Sync>` : `<H: ${handlerTraitName(comp.name)}>`;
+    // bc#97: async propagation (uniform) — if the terminal handlers are async, every handler call awaits,
+    // so the runner is itself `async fn` and returns a future the (already-async) consumer awaits. Sync
+    // default emits `pub fn` exactly as before (byte-identical).
+    const fnKw = isAsync ? "pub async fn" : "pub fn";
+    // #108: a component whose body is ALL cond nodes dispatches NO handler — bind `_handlers` (clippy-clean).
+    const dispatchesHandler = comp.body.some((n) => "map" in n || "component" in n);
+    lines.push(`${fnKw} run_native_raw_struct_${fn}${bound}(`);
+    lines.push(`    ${dispatchesHandler ? "handlers" : "_handlers"}: &H,`);
+    lines.push(`    ${inParam}: ${inStructName(comp.name)},`);
+    lines.push(`) -> Result<${outTy}, BehaviorError> {`);
+    for (const k of order.keys()) {
+        const id = comp.body[order[k]].id;
+        lines.push(`    let ${typedCell(id)}: RefCell<${renderTypeRef(typedNodes.get(id))}> = RefCell::new(Default::default());`);
+        lines.push(`    let produced_${sanitize(id)} = std::cell::Cell::new(false);`);
+        lines.push(`    let _ = &produced_${sanitize(id)};`);
+    }
+    for (let k = 0; k < order.length; k++) {
+        const i = order[k];
+        const stage = ep.parallelStageOf.get(i);
+        if (stage !== undefined && stage[0] === i) {
+            lines.push(emitParallelStageArm(comp, stage, k, ep.concurrency, metas, typedNodes, plan, priorNodeAt));
+            k += stage.length - 1;
+            continue;
+        }
+        if ("map" in comp.body[i]) {
+            lines.push(emitMapArm(comp, comp.body[i], k, typedNodes, plan, priorNodeAt, ap.nodeIsAsync(comp.body[i].id)));
+            continue;
+        }
+        // #108: a cond node — pure Expression (no handler). Compile via the runtime-free NativeExprCompiler.
+        if ("cond" in comp.body[i]) {
+            lines.push(emitCondArm(comp, comp.body[i], k, typedNodes, plan, priorNodeAt));
+            continue;
+        }
+        const node = comp.body[i];
+        const meta = metas[i];
+        const s = sanitize(node.id);
+        const structName = portsStructName(comp.name, node.id);
+        const portNames = Object.keys(node.ports);
+        const ref = typedNodes.get(node.id);
+        lines.push(`    // ── op '${node.id}' (${node.component}${node.relationKind ? ", relationKind:" + node.relationKind : ""}${node.parent ? ", parent:" + node.parent : ""}) ──`);
+        let indent = "    ";
+        const closers = [];
+        if (node.parent !== undefined && priorNodeAt(node.parent, k)) {
+            lines.push(`${indent}if produced_${sanitize(node.parent)}.get() {`);
+            closers.unshift(`${indent}}`);
+            indent += "    ";
+            if (node.bindField !== undefined) {
+                // bind (change #3 — typed produced-aware bound): read the parent struct field DIRECTLY (typed
+                // access — no serialize). `bound_<s>` is a typed `Option<K>` — None => UNPRODUCED/skip, Some =>
+                // produced (an empty string is a VALID produced value, `Some("")`). This is the EXACT `!= Null`
+                // skip-gate ≡ run_behavior's preflightOp, now runtime-free (NO Value).
+                const parentRef = typedNodes.get(node.parent);
+                const { expr: bfExpr, ref: bfRef } = typedFieldAccess(`${typedCell(node.parent)}.borrow()`, parentRef, [node.bindField], plan);
+                if (bfRef.kind === "opt") {
+                    // an opt bindField is ALREADY an Option<T>: None => skip, Some => produced. Clone it directly.
+                    lines.push(`${indent}let bound_${s}: ${boundRustType(node, typedNodes, plan)} = ${bfExpr}.clone();`);
+                }
+                else {
+                    // a required scalar bindField is always PRESENT (never skips on null): wrap in Some so the
+                    // produced Option is never None, preserving the "produced" semantics of the old guard.
+                    const owned = bfRef.kind === "scalar" && bfRef.scalar === "string" ? `(${bfExpr}).clone()` : `*(${bfExpr})`;
+                    lines.push(`${indent}let bound_${s}: ${boundRustType(node, typedNodes, plan)} = Some(${owned});`);
+                }
+                lines.push(`${indent}if bound_${s}.is_some() {`);
+                closers.unshift(`${indent}}`);
+                indent += "    ";
+            }
+        }
+        const resolveRef = runnerResolveRef(priorNodeAt, k, typedNodes, plan, comp.inputPorts);
+        const inits = [];
+        for (const pn of portNames) {
+            const expr = node.ports[pn];
+            const ty = portFieldRustType(expr, comp.inputPorts, `port '${pn}' of node '${node.id}'`);
+            inits.push(emitPortInit(pn, expr, ty, resolveRef));
+        }
+        const boundArg = node.bindField !== undefined ? `bound_${s}` : "None";
+        // bc#97: derived per-node await — this point-read's future is awaited HERE (its result-consumption
+        // point) iff THIS node's terminal handler is async. A sync handler in the same async runner is called
+        // directly (no `.await`). The runner being `async fn` does not force every call site to await.
+        const awaitSfx = ap.nodeIsAsync(node.id) ? ".await" : "";
+        lines.push(`${indent}let ports_${s} = ${structName} { ${inits.join(", ")} };`);
+        lines.push(`${indent}let row_${s} = match handlers.${nodeMethodName(node.id)}(&ports_${s}, ${boundArg})${awaitSfx} {`);
+        lines.push(`${indent}    Some(r) => r,`);
+        lines.push(`${indent}    None => return Err(unknown_component(${rustStrLit(node.component)})),`);
+        lines.push(`${indent}};`);
+        if (meta.policy === "continue") {
+            lines.push(`${indent}if !row_${s}.is_error {`);
+            lines.push(`${indent}    ${emitRowMove(`*${typedCell(node.id)}.borrow_mut()`, `row_${s}`, ref, plan)}`);
+            lines.push(`${indent}    produced_${s}.set(true);`);
+            lines.push(`${indent}}`);
+        }
+        else {
+            const label = meta.policy === "retry" ? "retry' policy (exhausted)" : "fail' policy";
+            lines.push(`${indent}if row_${s}.is_error {`);
+            lines.push(`${indent}    return Err(BehaviorError::new("OP_FAILED", format!("operation '{}' failed under '${label}: {}", ${rustStrLit(node.id)}, row_${s}.err)));`);
+            lines.push(`${indent}}`);
+            lines.push(`${indent}${emitRowMove(`*${typedCell(node.id)}.borrow_mut()`, `row_${s}`, ref, plan)}`);
+            lines.push(`${indent}produced_${s}.set(true);`);
+        }
+        for (const c of closers)
+            lines.push(c);
+    }
+    // output: assemble a TYPED struct/value (struct literal + typed field access — ZERO Value::Obj).
+    const skippable = new Set();
+    const skippableKind = new Map();
+    for (const k of order.keys()) {
+        if (metas[order[k]].canSkip) {
+            const bodyNode = comp.body[order[k]];
+            skippable.add(bodyNode.id);
+            const rk = "map" in bodyNode ? bodyNode.map.relationKind : bodyNode.relationKind;
+            skippableKind.set(bodyNode.id, rk);
+        }
+    }
+    const out = skippable.size > 0
+        ? emitProducedAwareValue(comp.output, outRef, typedNodes, plan, skippable, skippableKind)
+        : emitTypedValue(comp.output, outRef, typedNodes, plan);
+    lines.push(`    let __out = ${out.expr};`);
+    lines.push(`    Ok(__out)`);
+    lines.push(`}`);
+    return lines.join("\n");
+}
+/**
+ * emitParallelStageArm (bc#87/#94, rust CONCRETE) — EXPLICIT static parallel orchestration for a real-
+ * concurrency stage. Reproduces run_plan_parallel's deterministic protocol so the observed value / op
+ * multiset / failure precedence byte-match run_behavior:
+ *   1. PREFLIGHT (ascending): parent-produced gate + build each member's CONCRETE ports struct.
+ *   2. DISPATCH (bounded scoped threads): share `&H` (the concrete trait; `H: Sync`), pull runnable
+ *      members from a shared atomic cursor in ascending order, call the concrete node_* method. Each
+ *      concrete row lands in a per-member Mutex slot (None = unknown component).
+ *   3. COMMIT (ascending index): interpret policy + move the concrete row into the outType cell —
+ *      lowest-index failure wins.
+ */
+function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes, plan, priorNodeAt) {
+    const lines = [];
+    const ids = stage.map((i) => comp.body[i].id);
+    lines.push(`    // ── bc#87 real-concurrency stage {${ids.map((x) => rustStrLit(x)).join(", ")}} — static parallel`);
+    lines.push(`    // orchestration (scoped threads, bound=${concurrency}); preflight+commit in ascending index order.`);
+    lines.push(`    {`);
+    // 1) PREFLIGHT (ascending): build each member's CONCRETE ports struct into a stage-scoped Option local.
+    for (const i of stage) {
+        const node = comp.body[i];
+        const s = sanitize(node.id);
+        const structName = portsStructName(comp.name, node.id);
+        const gated = node.parent !== undefined && priorNodeAt(node.parent, atPos);
+        let ind = "        ";
+        const closers = [];
+        if (gated) {
+            lines.push(`        let mut ports_${s}: Option<${structName}> = None;`);
+            lines.push(`${ind}if produced_${sanitize(node.parent)}.get() {`);
+            closers.unshift(`${ind}}`);
+            ind += "    ";
+        }
+        const resolveRef = runnerResolveRef(priorNodeAt, atPos, typedNodes, plan, comp.inputPorts);
+        const inits = [];
+        for (const pn of Object.keys(node.ports)) {
+            const expr = node.ports[pn];
+            const ty = portFieldRustType(expr, comp.inputPorts, `port '${pn}' of node '${node.id}'`);
+            inits.push(emitPortInit(pn, expr, ty, resolveRef));
+        }
+        if (gated) {
+            lines.push(`${ind}ports_${s} = Some(${structName} { ${inits.join(", ")} });`);
+        }
+        else {
+            lines.push(`${ind}let ports_${s}: Option<${structName}> = Some(${structName} { ${inits.join(", ")} });`);
+        }
+        for (const c of closers)
+            lines.push(c);
+    }
+    // 2) DISPATCH (bounded scoped threads). Share `&H` (concrete trait; H: Sync). Each worker calls the
+    // concrete node_* method for its member's CONCRETE ports and stores the concrete row in its slot.
+    const nMembers = stage.length;
+    const boundN = Math.min(concurrency, nMembers);
+    const jobsVar = `jobs_${sanitize(comp.name)}`;
+    for (const i of stage) {
+        const s = sanitize(comp.body[i].id);
+        const rowT = rawRowStructName(comp.name, comp.body[i].id);
+        lines.push(`        let slot_${s}: std::sync::Mutex<Option<Option<${rowT}>>> = std::sync::Mutex::new(None);`);
+    }
+    lines.push(`        let mut ${jobsVar}: Vec<usize> = Vec::new();`);
+    stage.forEach((i, slot) => {
+        const s = sanitize(comp.body[i].id);
+        lines.push(`        if ports_${s}.is_some() { ${jobsVar}.push(${slot}); }`);
+    });
+    lines.push(`        let cursor = std::sync::atomic::AtomicUsize::new(0);`);
+    lines.push(`        let workers = ${boundN}usize.min(${jobsVar}.len());`);
+    lines.push(`        std::thread::scope(|scope| {`);
+    lines.push(`            for _ in 0..workers {`);
+    lines.push(`                scope.spawn(|| loop {`);
+    lines.push(`                    let j = cursor.fetch_add(1, std::sync::atomic::Ordering::SeqCst);`);
+    lines.push(`                    if j >= ${jobsVar}.len() { break; }`);
+    lines.push(`                    let slot = ${jobsVar}[j];`);
+    lines.push(`                    match slot {`);
+    stage.forEach((i, slot) => {
+        const node = comp.body[i];
+        const s = sanitize(node.id);
+        lines.push(`                        ${slot} => {`);
+        lines.push(`                            let ports = ports_${s}.as_ref().expect("runnable member has ports");`);
+        lines.push(`                            let row = handlers.${nodeMethodName(node.id)}(ports, None);`);
+        lines.push(`                            *slot_${s}.lock().unwrap() = Some(row);`);
+        lines.push(`                        }`);
+    });
+    lines.push(`                        _ => unreachable!(),`);
+    lines.push(`                    };`);
+    lines.push(`                });`);
+    lines.push(`            }`);
+    lines.push(`        });`);
+    // 3) COMMIT (ascending index): interpret + move the concrete row into the outType cell.
+    stage.forEach((i) => {
+        const node = comp.body[i];
+        const meta = metas[i];
+        const s = sanitize(node.id);
+        const ref = typedNodes.get(node.id);
+        lines.push(`        if ports_${s}.is_some() {`);
+        lines.push(`            let row_${s} = match slot_${s}.lock().unwrap().take() {`);
+        lines.push(`                Some(Some(r)) => r,`);
+        lines.push(`                _ => return Err(unknown_component(${rustStrLit(node.component)})),`);
+        lines.push(`            };`);
+        if (meta.policy === "continue") {
+            lines.push(`            if !row_${s}.is_error {`);
+            lines.push(`                ${emitRowMove(`*${typedCell(node.id)}.borrow_mut()`, `row_${s}`, ref, plan)}`);
+            lines.push(`                produced_${s}.set(true);`);
+            lines.push(`            }`);
+        }
+        else {
+            const label = meta.policy === "retry" ? "retry' policy (exhausted)" : "fail' policy";
+            lines.push(`            if row_${s}.is_error {`);
+            lines.push(`                return Err(BehaviorError::new("OP_FAILED", format!("operation '{}' failed under '${label}: {}", ${rustStrLit(node.id)}, row_${s}.err)));`);
+            lines.push(`            }`);
+            lines.push(`            ${emitRowMove(`*${typedCell(node.id)}.borrow_mut()`, `row_${s}`, ref, plan)}`);
+            lines.push(`            produced_${s}.set(true);`);
+        }
+        lines.push(`        }`);
+    });
+    lines.push(`    }`);
+    return lines.join("\n");
+}
+// bc#90 / runtime-free: the old `emitMapStaticR` map-element port lowering (a Value fallback) is REMOVED
+// — covered map element ports lower to a fully native Rust value in emitPortInit (the map resolveRef
+// reads the $as element / prior-node / input typed fields directly), with a fail-closed on a dynamic port.
+/**
+ * emitMapArm — the struct-native exec of a covered map node (rust CONCRETE). Three shapes:
+ *   - #86 pt2: BATCHED map...into — dispatch once (concrete batch row), augmented-element materializer.
+ *   - #93 shape 2: NON-batched map...into — dispatch ONCE PER ELEMENT (N physical requests), into per element.
+ *   - #93 shape 3: BATCHED map NO into — dispatch once, collect each element from the concrete element row.
+ */
+function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, 
+// bc#97: whether THIS map node's terminal handler is async (derived per-node) — awaits the batched /
+// per-element handler call at its consumption point iff true. Sync map handlers are called directly.
+isAsync = false) {
+    const m = node.map;
+    const awaitSfx = isAsync ? ".await" : "";
+    const batched = m.batched === true;
+    const hasInto = m.into !== undefined;
+    const hasGuard = m.when !== undefined;
+    const s = sanitize(node.id);
+    const structName = portsStructName(comp.name, node.id);
+    const batch = `${structName}Batch`;
+    // #108: over element type + the OWNED over-Vec expression (prior-node arr OR input array w/ elemType).
+    const { elemRef: overElemRef, overExpr } = mapOverElemInfo(comp, node, typedNodes, plan);
+    const elemMat = mapElemMaterializerName(node.id);
+    const priorHere = (head) => priorNodeAt(head, atPos);
+    const asName = m.as;
+    const portNames = Object.keys(m.ports);
+    const elemArrRef = typedNodes.get(node.id);
+    const elemName = renderTypeRef(elemArrRef.elem);
+    const resolveRef = (head, restPath, opt) => {
+        if (opt)
+            return null;
+        let baseExpr;
+        let baseRef;
+        if (head === asName) {
+            baseExpr = `oel_${s}`;
+            baseRef = overElemRef;
+        }
+        else if (priorHere(head)) {
+            baseExpr = `${typedCell(head)}.borrow()`;
+            baseRef = typedNodes.get(head);
+        }
+        else {
+            if (restPath.length !== 0)
+                return null;
+            const scalar = inputScalarKind(comp.inputPorts?.[head]);
+            if (scalar === undefined)
+                return null;
+            const field = `in_.${rustFieldName(head)}`;
+            return { expr: scalar === "String" ? `${field}.clone()` : field, scalar };
+        }
+        let acc;
+        let expr;
+        try {
+            const r = typedFieldAccess(baseExpr, baseRef, restPath, plan);
+            expr = r.expr;
+            acc = r.ref;
+        }
+        catch {
+            return null;
+        }
+        if (acc.kind !== "scalar" || acc.scalar === "null")
+            return null;
+        // OWNED value. When restPath is EMPTY, `expr` is a bare REFERENCE (`oel_${s}` = &Elem-scalar, or
+        // `cell.borrow()` = Ref<scalar>) — deref with `*` (Copy) / `.clone()` via deref (String). When a
+        // `.field` was appended, `expr` is a value PLACE (auto-deref) — read it directly (`.clone()` String).
+        const isBareRef = restPath.length === 0;
+        let owned;
+        if (acc.scalar === "string") {
+            owned = isBareRef ? `(*${expr}).clone()` : `${expr}.clone()`;
+        }
+        else {
+            owned = isBareRef ? `*${expr}` : expr;
+        }
+        return { expr: owned, scalar: rustScalar(acc.scalar) };
+    };
+    // build the per-element CONCRETE native ports struct. `il` = indent inside the element loop.
+    const buildPorts = (il) => {
+        const out = [];
+        const inits = [];
+        const asBinding = { name: asName, ref: overElemRef, plan };
+        for (const pn of portNames) {
+            const ty = portFieldRustType(m.ports[pn], comp.inputPorts, `map port '${pn}' of node '${node.id}'`, asBinding);
+            inits.push(emitPortInit(pn, m.ports[pn], ty, resolveRef));
+        }
+        out.push(`${il}let ep_${s} = ${structName} { ${inits.join(", ")} };`);
+        return out;
+    };
+    // #108 guard: compile `when` to a native bool over an element-scoped resolveHead ($as element value,
+    // prior node, input port). On skip: `continue` (element excluded — matches run_behavior's keep-gate).
+    const emitGuard = (il) => {
+        if (!hasGuard)
+            return [];
+        const resolveHead = (head) => {
+            if (head === asName)
+                return { expr: `oel_${s}.clone()`, ref: overElemRef };
+            if (priorHere(head))
+                return { expr: `${typedCell(head)}.borrow().clone()`, ref: typedNodes.get(head) };
+            return rustInputHeadRef(head, comp, plan);
+        };
+        const g = new NativeExprCompiler(makeRustExprBackend(resolveHead, plan)).compileBool(m.when);
+        const out = [];
+        for (const st of g.stmts)
+            out.push(`${il}${st}`);
+        // bind the keep flag to a var so clippy's nonminimal_bool doesn't rewrite `!(a > b)` (the `when`
+        // expr must stay verbatim = run_behavior's `{cond:[when,true,false]}` strict-bool keep-gate).
+        out.push(`${il}let __keep = ${rustStripOuterParens(g.expr)};`);
+        out.push(`${il}if !__keep { continue; }`);
+        return out;
+    };
+    const lines = [];
+    const closers = [];
+    lines.push(`    // ── map '${node.id}' (${m.component}, ${batched ? "batched" : "per-element"}, into:${JSON.stringify(m.into ?? null)}${hasGuard ? ", guarded" : ""}${m.relationKind ? ", relationKind:" + m.relationKind : ""}${m.parent ? ", parent:" + m.parent : ""}) ──`);
+    let indent = "    ";
+    if (m.parent !== undefined && priorNodeAt(m.parent, atPos)) {
+        lines.push(`${indent}if produced_${sanitize(m.parent)}.get() {`);
+        closers.unshift(`${indent}}`);
+        indent += "    ";
+    }
+    lines.push(`${indent}let over_${s} = ${overExpr};`);
+    lines.push(`${indent}let mut built_${s}: Vec<${elemName}> = Vec::with_capacity(over_${s}.len());`);
+    if (batched) {
+        // build kept-element ports (+ kept over elements for into). Batched into is never guarded (rejected).
+        lines.push(`${indent}let mut items_${s}: Vec<${structName}> = Vec::with_capacity(over_${s}.len());`);
+        if (hasInto)
+            lines.push(`${indent}let mut kept_${s}: Vec<${renderTypeRef(overElemRef)}> = Vec::with_capacity(over_${s}.len());`);
+        lines.push(`${indent}for oel_${s} in over_${s}.iter() {`);
+        for (const l of emitGuard(indent + "    "))
+            lines.push(l);
+        for (const l of buildPorts(indent + "    "))
+            lines.push(l);
+        lines.push(`${indent}    items_${s}.push(ep_${s});`);
+        if (hasInto)
+            lines.push(`${indent}    kept_${s}.push(oel_${s}.clone());`);
+        lines.push(`${indent}}`);
+        lines.push(`${indent}if !items_${s}.is_empty() {`);
+        lines.push(`${indent}    let want_${s} = items_${s}.len();`);
+        lines.push(`${indent}    let bp_${s} = ${batch} { items: items_${s} };`);
+        lines.push(`${indent}    let row_${s} = match handlers.${nodeMethodName(node.id)}(&bp_${s}, None)${awaitSfx} {`);
+        lines.push(`${indent}        Some(r) => r,`);
+        lines.push(`${indent}        None => return Err(unknown_component(${rustStrLit(m.component)})),`);
+        lines.push(`${indent}    };`);
+        lines.push(`${indent}    if row_${s}.is_error {`);
+        lines.push(`${indent}        return Err(BehaviorError::new("OP_FAILED", format!("operation '{}' failed under 'fail' policy: {}", ${rustStrLit(node.id)}, row_${s}.err)));`);
+        lines.push(`${indent}    }`);
+        lines.push(`${indent}    if row_${s}.rows.len() != want_${s} {`);
+        lines.push(`${indent}        return Err(BehaviorError::new("MAP_BATCH_RESULT_MISMATCH", format!("map '{}': batched handler must return a list aligned to items (want {})", ${rustStrLit(node.id)}, want_${s})));`);
+        lines.push(`${indent}    }`);
+        if (hasInto) {
+            // zip the aligned batch rows onto each KEPT over element (into materializer).
+            lines.push(`${indent}    let mut rows_iter_${s} = row_${s}.rows.into_iter();`);
+            lines.push(`${indent}    for over_el_${s} in kept_${s}.iter() {`);
+            lines.push(`${indent}        let er_${s} = rows_iter_${s}.next().expect("aligned batch row");`);
+            lines.push(`${indent}        built_${s}.push(${elemMat}(over_el_${s}, er_${s}));`);
+            lines.push(`${indent}    }`);
+        }
+        else {
+            // no-into: collect each element DIRECTLY from the aligned per-element row (result = kept rows).
+            lines.push(`${indent}    for er_${s} in row_${s}.rows.into_iter() {`);
+            lines.push(`${indent}        ${emitElemMove(`let el_${s}`, `er_${s}`, elemArrRef.elem, plan)}`);
+            lines.push(`${indent}        built_${s}.push(el_${s});`);
+            lines.push(`${indent}    }`);
+        }
+        lines.push(`${indent}}`);
+    }
+    else {
+        // #93 shape 2 / #108: NON-batched map — dispatch ONCE PER KEPT ELEMENT.
+        lines.push(`${indent}for oel_${s} in over_${s}.iter() {`);
+        for (const l of emitGuard(indent + "    "))
+            lines.push(l);
+        for (const l of buildPorts(indent + "    "))
+            lines.push(l);
+        lines.push(`${indent}    let er_${s} = match handlers.${nodeMethodName(node.id)}(&ep_${s}, None)${awaitSfx} {`);
+        lines.push(`${indent}        Some(r) => r,`);
+        lines.push(`${indent}        None => return Err(unknown_component(${rustStrLit(m.component)})),`);
+        lines.push(`${indent}    };`);
+        lines.push(`${indent}    if er_${s}.is_error {`);
+        lines.push(`${indent}        return Err(BehaviorError::new("OP_FAILED", format!("operation '{}' failed under 'fail' policy: {}", ${rustStrLit(node.id)}, er_${s}.err)));`);
+        lines.push(`${indent}    }`);
+        if (hasInto) {
+            lines.push(`${indent}    built_${s}.push(${elemMat}(oel_${s}, er_${s}));`);
+        }
+        else {
+            lines.push(`${indent}    let _ = &oel_${s};`);
+            lines.push(`${indent}    ${emitElemMove(`let el_${s}`, `er_${s}`, elemArrRef.elem, plan)}`);
+            lines.push(`${indent}    built_${s}.push(el_${s});`);
+        }
+        lines.push(`${indent}}`);
+    }
+    lines.push(`${indent}*${typedCell(node.id)}.borrow_mut() = built_${s};`);
+    lines.push(`${indent}produced_${sanitize(node.id)}.set(true);`);
+    for (const c of closers)
+        lines.push(c);
+    return lines.join("\n");
+}
+/** #108: resolve an INPUT port head for a native-expr ref (rust). Scalar → `in_.<field>` (owned: String
+ * cloned, Copy as-is); array WITH elemType → `in_.<field>.clone()` of Vec<ElemT> (for `len`); else null. */
+function rustInputHeadRef(head, comp, plan) {
+    const schema = comp.inputPorts?.[head];
+    if (schema === undefined)
+        return null;
+    const sc = inputScalarKind(schema);
+    if (sc !== undefined) {
+        const scalarRef = { kind: "scalar", scalar: sc === "i64" ? "int" : sc === "f64" ? "float" : sc === "String" ? "string" : "bool" };
+        const field = `in_.${rustFieldName(head)}`;
+        return { expr: sc === "String" ? `${field}.clone()` : field, ref: scalarRef };
+    }
+    const et = schema.elemType;
+    if ((schema.type === "array" || schema.type === "arr") && et !== undefined) {
+        // no clone: the only array use inside a cond/guard expr is `len`, which BORROWS (`&in_.xs`).
+        return { expr: `in_.${rustFieldName(head)}`, ref: { kind: "arr", elem: deriveTypeRef(et, plan) } };
+    }
+    return null;
+}
+/**
+ * emitCondArm — the struct-native exec of a covered cond node (#108, rust). Mirrors run_behavior's cond
+ * lower: compile `if` to a native bool, materialize the TAKEN branch to the node's outType (only the
+ * taken branch evaluated), assign the node's typed cell + set produced. NO handler dispatch. Compiles
+ * via the runtime-free NativeExprCompiler (byte-equal to `evaluate`); an uncovered expr fails closed.
+ */
+function emitCondArm(comp, node, atPos, typedNodes, plan, priorNodeAt) {
+    const c = node.cond;
+    const s = sanitize(node.id);
+    const nodeRef = typedNodes.get(node.id);
+    const priorHere = (head) => priorNodeAt(head, atPos);
+    const resolveHead = (head) => {
+        if (priorHere(head))
+            return { expr: `${typedCell(head)}.borrow().clone()`, ref: typedNodes.get(head) };
+        return rustInputHeadRef(head, comp, plan);
+    };
+    const compiler = new NativeExprCompiler(makeRustExprBackend(resolveHead, plan));
+    const resolveDecl = (name) => findDecl(plan, name).fields;
+    const cond = compiler.compileBool(c.if);
+    const thenC = compiler.compileTo(c.then, nodeRef, resolveDecl);
+    const elseC = compiler.compileTo(c.else, nodeRef, resolveDecl);
+    const lines = [];
+    lines.push(`    // ── cond '${node.id}'${c.parent ? " (parent:" + c.parent + ")" : ""} — pure Expression (no handler) ──`);
+    let indent = "    ";
+    const closers = [];
+    if (c.parent !== undefined && priorNodeAt(c.parent, atPos)) {
+        lines.push(`${indent}if produced_${sanitize(c.parent)}.get() {`);
+        closers.unshift(`${indent}}`);
+        indent += "    ";
+    }
+    for (const st of cond.stmts)
+        lines.push(`${indent}${st}`);
+    lines.push(`${indent}if ${rustStripOuterParens(cond.expr)} {`);
+    for (const st of thenC.stmts)
+        lines.push(`${indent}    ${st}`);
+    lines.push(`${indent}    *${typedCell(node.id)}.borrow_mut() = ${thenC.expr};`);
+    lines.push(`${indent}} else {`);
+    for (const st of elseC.stmts)
+        lines.push(`${indent}    ${st}`);
+    lines.push(`${indent}    *${typedCell(node.id)}.borrow_mut() = ${elseC.expr};`);
+    lines.push(`${indent}}`);
+    lines.push(`${indent}produced_${s}.set(true);`);
+    for (const cl of closers)
+        lines.push(cl);
+    return lines.join("\n");
+}
+/** emitElemMove — move a concrete element row (RawElemNR, error already handled) into a fresh `let` local
+ * of the element outType. Named → struct literal from moved fields; scalar/arr/opt → .val. */
+function emitElemMove(letBind, rowExpr, ref, plan) {
+    if (ref.kind === "named") {
+        const decl = findDecl(plan, ref.name);
+        const inits = decl.fields.map((f) => `${rustFieldName(f.name)}: ${rowExpr}.${rustFieldName(f.name)}`).join(", ");
+        return `${letBind} = ${ref.name} { ${inits} };`;
+    }
+    return `${letBind} = ${rowExpr}.val;`;
+}
+/**
+ * emitProducedAwareValue — the #86 part 1 produced-aware output lowering (rust twin of the go one).
+ */
+function emitProducedAwareValue(node, expected, typedNodes, plan, skippable, skippableKind) {
+    const e = classifyExpr(node);
+    if (e.kind === "ref" && e.path.length >= 1 && typedNodes.has(e.path[0])) {
+        const head = e.path[0];
+        const baseRef = typedNodes.get(head);
+        if (skippable.has(head)) {
+            const base = `${typedCell(head)}.borrow().clone()`;
+            const { expr, ref } = typedFieldAccess(base, baseRef, e.path.slice(1), plan);
+            const producedExpr = valueLeafProduced(expr, ref, expected);
+            const isConn = skippableKind.get(head) === "connection" && e.path.length === 1;
+            let unproduced;
+            if (isConn) {
+                const connTy = expected && expected.kind === "opt" ? renderTypeRef(expected.inner) : renderTypeRef(expected ?? ref);
+                unproduced = expected && expected.kind === "opt" ? `Some(${connTy}::default())` : `${connTy}::default()`;
+            }
+            else {
+                unproduced = expected && expected.kind === "opt" ? "None" : "Default::default()";
+            }
+            return {
+                expr: `if produced_${sanitize(head)}.get() { ${producedExpr} } else { ${unproduced} }`,
+                ref: expected ?? ref,
+            };
+        }
+        const isBareCopyScalar = e.path.length === 1 && baseRef.kind === "scalar" && (baseRef.scalar === "int" || baseRef.scalar === "float" || baseRef.scalar === "bool");
+        const base = isBareCopyScalar ? `*${typedCell(head)}.borrow()` : `${typedCell(head)}.borrow().clone()`;
+        const { expr, ref } = typedFieldAccess(base, baseRef, e.path.slice(1), plan);
+        return { expr, ref };
+    }
+    if (node !== null && typeof node === "object" && !Array.isArray(node)) {
+        const keys = Object.keys(node);
+        if (keys.length === 1 && keys[0] === "obj" && expected && expected.kind === "named") {
+            const decl = findDecl(plan, expected.name);
+            const fields = node.obj;
+            const inits = decl.fields.map((f) => {
+                const sub = emitProducedAwareValue(fields[f.name], f.type, typedNodes, plan, skippable, skippableKind);
+                return `${rustFieldName(f.name)}: ${sub.expr}`;
+            });
+            return { expr: `${expected.name} { ${inits.join(", ")} }`, ref: expected };
+        }
+    }
+    return emitTypedValue(node, expected, typedNodes, plan);
+}
+function valueLeafProduced(expr, ref, expected) {
+    if (expected && expected.kind === "opt") {
+        if (ref.kind === "opt")
+            return expr;
+        return `Some(${expr})`;
+    }
+    return expr;
+}
+// bc#90 / runtime-free: the old `valueLeafInner` (which serialized a bindField to a boxed `Value` for the
+// binding check) is REMOVED — the bound value is now a typed `Option<K>` built by direct field access
+// (Some(field.clone()) / the opt field's Option), and the produced gate is `Option::is_some()`.
+// ── struct dispatch surface (STRUCT-only — no Value bind, no serializer) ─────────────────
+function emitStructSurface(native) {
+    const names = native.map((c) => rustStrLit(c.name));
+    return `// COMPONENT_NAMES_NATIVE_RAW — covered reads exposed on the combined struct-native path. Each is
+// driven via run_native_raw_struct_<comp>(handlers, in_) -> Result<T, BehaviorError>: a STRUCT return
+// (the consumer builds the CONCRETE InNR_<comp> input + implements the CONCRETE HandlerNR<comp> trait).
+// See INTEGRATION.md §6.
+pub const COMPONENT_NAMES_NATIVE_RAW: [&str; ${names.length}] = [${names.join(", ")}];`;
+}
+// ── unknown_component helper (self-contained; the module carries no straight-line body) ──
+const UNKNOWN_COMPONENT_HELPER = `#[allow(dead_code)]
+fn unknown_component(component: &str) -> BehaviorError {
+    BehaviorError::new("UNKNOWN_COMPONENT", format!("component '{component}' has no handler (fail-closed)"))
+}`;
+// ── module assembly ──────────────────────────────────────────────────────────────────
+function emit(ctx) {
+    // bc#97 (increment 2): the SSoT language-agnostic propagation pass derives, PER COMPONENT + PER NODE,
+    // which handler-call boundaries must be awaited (bottom-up over the declared async terminal handlers).
+    // rust CONSUMES this annotation (async fn + .await where derived); go ignores it. per-node granularity
+    // is a strict generalization of increment-1's uniform ioModel:'async' (= every terminal async).
+    const asyncPlans = buildAsyncPlans(ctx.ir, ctx.ioModel);
+    for (const c of ctx.ir.components)
+        assertTypedCoverage(c);
+    const native = ctx.ir.components.filter(isNativeRaw);
+    const nonNative = ctx.ir.components.filter((c) => !isNativeRaw(c));
+    // FAIL CLOSED (bc#86/#89): the --typed-native (native codegen) surface is native-only. Previously a
+    // non-covered component was SILENTLY DROPPED (emitted only as a comment note), concealing that it
+    // never got native codegen. We now throw a LOUD GeneratorFailure naming every uncovered component +
+    // its specific reject reason. A fully-covered module is unchanged.
+    if (nonNative.length > 0) {
+        const rejects = nonNative
+            .map((c) => `  - component '${c.name}': ${coverageRejectReason(c) ?? "not a covered native read"}`)
+            .join("\n");
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust typed-native (native codegen) surface: ${nonNative.length} component(s) are NOT a covered native read:\n${rejects}\n\n` +
+            `The --typed-native (native codegen) surface is native-only and fail-closed: it does not silently ` +
+            `box uncovered shapes. Implement native coverage for this shape, fix the spec if the shape is ` +
+            `genuinely runtime-dynamic, or generate this component on the --ir dynamic interpreter surface.`);
+    }
+    if (native.length === 0) {
+        // an empty native surface (no covered read) carries no runner and no failure — nothing references
+        // bc-runtime, so it stays runtime-free (bc#90) with only the component-names const.
+        return `#![allow(dead_code, unused_imports)]
+${emitStructSurface([])}
+`;
+    }
+    const plan = buildTypePlan(ctx.ir);
+    // The typed-native module is a de-boxed CONSUMER artifact: the covered runner RETURNS these outType
+    // structs and the consumer reads their fields natively. So the decls (and their FIELDS) are pub — the
+    // consumer keeps the model native (mirrors Go's exported outType struct fields on the covered path).
+    const decls = emitTypeDecls(plan)
+        .replace(/\nstruct /g, "\npub struct ")
+        .replace(/^struct /gm, "pub struct ")
+        .replace(/^( {4})([a-z_][A-Za-z0-9_]*: )/gm, "$1pub $2")
+        .replace(/^( {4})(r#[a-z_][A-Za-z0-9_]*: )/gm, "$1pub $2");
+    const defaults = emitDefaults(plan);
+    // #108: reset the native-expr helper-usage accumulator (set by the cond/guard compiler).
+    rustExprUsed.helpers = false;
+    const structs = [];
+    const rowStructs = [];
+    const handlerTraits = [];
+    const inStructs = [];
+    const elemMaterializers = [];
+    for (const c of native) {
+        const typedNodes = new Map();
+        // build the full typed-node map FIRST so a map's over-element resolution can see every node.
+        for (const n of c.body)
+            typedNodes.set(n.id, deriveTypeRef(n.outType, plan));
+        for (const n of c.body) {
+            if ("map" in n)
+                structs.push(emitMapPortsStructs(c, n, typedNodes, plan));
+            else if ("cond" in n) {
+                // #108: a cond node has NO ports struct (pure Expression — no handler dispatch).
+            }
+            else
+                structs.push(emitPortsStruct(c, n));
+        }
+        rowStructs.push(emitRawRowStructs(c, typedNodes, plan));
+        handlerTraits.push(emitHandlerTrait(c, typedNodes, plan, asyncPlans.get(c.name)));
+        inStructs.push(emitInStruct(c, plan));
+        const mm = emitMapElemMaterializers(c, typedNodes, plan);
+        if (mm)
+            elemMaterializers.push(mm);
+    }
+    const runners = native.map((c) => emitNativeRawRunner(c, plan, asyncPlans.get(c.name))).join("\n\n");
+    const structSurface = emitStructSurface(native);
+    // (nonNative.length === 0 is guaranteed here — the fail-closed guard above threw otherwise.)
+    const banner = `#![allow(dead_code, unused_imports, non_snake_case)]
+// GENERATED by behavior-contracts (bc#90, rust-typed-native — the RUNTIME-FREE read de-box; STRUCT-ONLY,
+// FULLY-NATIVE). A covered read is a strictly-sequential typed componentRef chain (point reads +
+// relationKind:single children), emitted ONLY as a STRUCT-returning runner GENERIC over a per-component
+// CONCRETE handler trait (HandlerNR<comp>): native ports struct IN (direct construction — every port is a
+// CONCRETE Rust value: String / bool / Vec<&str> projection / i64 limit — NO boxed Value, NO by-name
+// accessor); the handler takes a typed produced-aware 'bound' Option and returns the node's CONCRETE row
+// struct (typed fields = the projected outType), and the runner reads row.<field> DIRECTLY into the node's
+// outType struct. The covered plane carries NO bc-runtime reference at all — failures use the LOCAL
+// BehaviorError (same codes, byte-equal to run_behavior). INLINE sequential (no plan driver) so a relation
+// child reads the parent's REAL struct result via direct field access and the child-present decision is
+// made from the real parent value — relationSingle / connection converge with run_behavior (fixes
+// #323/#74). The exposed API is run_native_raw_struct_<comp>(handlers, in_) over the CONCRETE InNR_<comp>
+// input struct + the CONCRETE HandlerNR<comp> trait (the consumer builds/implements both, keeping the
+// model native). This module is FULLY NATIVE: a naive grep for boxing primitives OR for the bc-runtime
+// crate finds nothing, by design (bc#90 / runtime-free).
+use std::cell::RefCell;`;
+    const sections = [
+        banner,
+        `// Local concrete failure type (runtime-free) — a covered runner returns Result<T, BehaviorError> over\n// THIS local type instead of a bc-runtime failure, so the fully-covered module imports ZERO bc runtime.\n${emitBehaviorErrorType()}`,
+        decls || undefined,
+        defaults || undefined,
+        UNKNOWN_COMPONENT_HELPER,
+        rustExprUsed.helpers
+            ? `// #108 native-expr helper library (runtime-free; byte-equal to expr-eval.ts core) — used by\n// cond / map-guard checked arithmetic. NO bc-runtime reference (failures use the LOCAL BehaviorError).\n${emitExprHelpersRust()}`
+            : undefined,
+        structs.some((r) => r.trim().length > 0)
+            ? `// Native ports structs (one per componentRef node; typed per the static port type — CONCRETE).\n${structs.filter((r) => r.trim().length > 0).join("\n\n")}`
+            : undefined,
+        rowStructs.some((r) => r.trim().length > 0)
+            ? `// CONCRETE per-node row structs (typed fields = the node's outType; + error signal).\n${rowStructs.filter((r) => r.trim().length > 0).join("\n\n")}`
+            : undefined,
+        `// CONCRETE per-component input structs (fields = inputPorts).\n${inStructs.join("\n\n")}`,
+        `// CONCRETE per-component handler traits (one node_* method per node — native ports IN, row OUT).\n${handlerTraits.join("\n\n")}`,
+        elemMaterializers.length
+            ? `// map augmented-element copiers (pure struct field assignment — no dynamic value read).\n${elemMaterializers.join("\n\n")}`
+            : undefined,
+        `// Combined read runners (STRUCT-returning — the fully de-plumbed CONCRETE path).\n${runners}`,
+        structSurface,
+    ];
+    return `${sections.filter((x) => !!x).join("\n\n")}\n`;
+}
+/**
+ * rustTypedNativeObserve — the TEST-ONLY observe companion (a submodule string the test harness writes
+ * alongside the covered module). It carries the typed->Value serializers (ser_*) + a CONCRETE scripted
+ * handler (ScriptedNativeRaw) that implements every HandlerNR<comp> trait by decoding a scripted Value
+ * into the concrete per-node row, + an observe_native_raw dispatch that decodes the generic input into the
+ * concrete InNR_<comp>, drives the module-private struct runner, and serializes its result to a canonical
+ * Value for the equivalence pin. Lives OUTSIDE the covered module so the module stays literal whole-file
+ * zero (the ser_* / decode helpers are test glue, never on the consumer's read hot path).
+ */
+export function rustTypedNativeObserve(ir, ioModel = "sync") {
+    const components = ir.components;
+    const native = components.filter(isNativeRaw);
+    const plan = buildTypePlan(ir);
+    const needSync = native.some((c) => concurrencyPlan(c) !== null);
+    const serializers = emitSerializers(plan);
+    const marshallers = emitMarshallers(plan);
+    // bc#97: the observe glue must MATCH the covered module's per-node async-ness — the scripted handler's
+    // node_* methods are `async fn` exactly where the trait's are, and observe_native_raw awaits an async
+    // runner. Built from the SAME SSoT propagation pass the covered emitter used, so glue never drifts.
+    const asyncPlans = buildAsyncPlans(ir, ioModel);
+    const anyAsyncRunner = native.some((c) => asyncPlans.get(c.name).runnerIsAsync);
+    // ── per-component input decoders: generic &[(String,Value)] -> concrete InNR_<comp> (test glue). ──
+    const inDecoders = native.map((c) => emitInDecoder(c, plan)).join("\n\n");
+    // ── concrete scripted handler: implements every HandlerNR<comp> trait by decoding a scripted Value
+    // into the concrete per-node row (the generic scripted-source queue meets the concrete seam). ──
+    const decodeFns = [];
+    const emittedDecode = new Set();
+    const traitImpls = [];
+    for (const c of native) {
+        const ap = asyncPlans.get(c.name);
+        // the scripted impl's node_* is `async fn` iff the trait's is (same per-node derivation).
+        const fnKwFor = (nodeId) => (ap.nodeIsAsync(nodeId) ? "async fn" : "fn");
+        const typedNodes = new Map();
+        for (const n of c.body)
+            typedNodes.set(n.id, deriveTypeRef(n.outType, plan));
+        const methods = [];
+        for (const n of c.body) {
+            if ("cond" in n)
+                continue; // #108: a cond node has no handler method (pure Expression) — no scripted impl.
+            const ref = typedNodes.get(n.id);
+            const fnKw = fnKwFor(n.id);
+            // bc#90 / runtime-free: the scripted impl's `_bound` param mirrors the trait's typed produced-aware
+            // Option<K> (NOT a boxed Value) — computed per node so the impl signature matches the trait.
+            const bt = boundRustType(n, typedNodes, plan);
+            if ("map" in n) {
+                const m = n.map;
+                const batched = m.batched === true;
+                const arrRef = ref;
+                const elemRowRef = mapElemRowRef(n, arrRef, plan);
+                const elemT = rawElemStructName(c.name, n.id);
+                const batchT = rawRowStructName(c.name, n.id);
+                const elemDecode = emitDecodeRow(c.name, n.id, elemT, elemRowRef, plan, emittedDecode, decodeFns, "Elem");
+                const portsT = batched ? `${portsStructName(c.name, n.id)}Batch` : portsStructName(c.name, n.id);
+                const retT = batched ? batchT : elemT;
+                if (batched) {
+                    methods.push(`    ${fnKw} ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Option<${batchT}> {
+        let (is_err, err, ok) = self.next(${rustStrLit(m.component)})?;
+        if is_err {
+            return Some(${batchT} { is_error: true, err, ..Default::default() });
+        }
+        let arr = match ok { Some(Value::Arr(a)) => a, _ => Vec::new() };
+        let rows = arr.iter().map(${elemDecode}).collect();
+        Some(${batchT} { rows, ..Default::default() })
+    }`);
+                }
+                else {
+                    methods.push(`    ${fnKw} ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Option<${elemT}> {
+        let (is_err, err, ok) = self.next(${rustStrLit(m.component)})?;
+        if is_err {
+            return Some(${elemT} { is_error: true, err, ..Default::default() });
+        }
+        let v = ok.unwrap_or(Value::Null);
+        Some(${elemDecode}(&v))
+    }`);
+                }
+                void retT;
+                continue;
+            }
+            const node = n;
+            const rowT = rawRowStructName(c.name, node.id);
+            const decode = emitDecodeRow(c.name, node.id, rowT, ref, plan, emittedDecode, decodeFns, "");
+            methods.push(`    ${fnKw} ${nodeMethodName(node.id)}(&self, _ports: &${portsStructName(c.name, node.id)}, _bound: ${bt}) -> Option<${rowT}> {
+        let (is_err, err, ok) = self.next(${rustStrLit(node.component)})?;
+        if is_err {
+            return Some(${rowT} { is_error: true, err, ..Default::default() });
+        }
+        let v = ok.unwrap_or(Value::Null);
+        Some(${decode}(&v))
+    }`);
+        }
+        traitImpls.push(`impl ${handlerTraitName(c.name)} for ScriptedNativeRaw {\n${methods.join("\n")}\n}`);
+    }
+    const arms = native
+        .map((c) => {
+        const outRef = c.outputType !== undefined ? deriveTypeRef(c.outputType, plan) : undefined;
+        const ser = outRef ? serializeTyped("tv", outRef, plan) : "tv";
+        // bc#90 / runtime-free: the covered runner returns the module-LOCAL `BehaviorError` (via super::*);
+        // bridge it to the bc-runtime `behavior_contracts::BehaviorError` at the observe boundary (same
+        // code/message) so the conformance harness (main.rs) reads the stable code without the covered
+        // module ever touching bc runtime. decode_* is test glue and returns the local error too.
+        // bc#97: an async runner returns a Future — drive it to completion with the std-only block-on
+        // (bc_block_on) so observe_native_raw keeps its SYNC external signature (the harness is unchanged).
+        // The scripted async node_* return ready values, so the future needs no real executor / no runtime.
+        const runnerCall = `super::run_native_raw_struct_${sanitize(c.name)}(handlers, in_)`;
+        const driven = asyncPlans.get(c.name).runnerIsAsync ? `bc_block_on(${runnerCall})` : runnerCall;
+        return `        ${rustStrLit(c.name)} => {\n            let in_ = decode_${inStructName(c.name)}(input).map_err(to_rt_err)?;\n            let tv = ${driven}.map_err(to_rt_err)?;\n            Ok(${ser})\n        }`;
+    })
+        .join("\n");
+    // the scripted handler is passed as `&ScriptedNativeRaw`; the observe entry takes `&ScriptedNativeRaw`
+    // directly (the harness constructs it). Sync is inherent (the queues live behind a Mutex, seen behind
+    // an atomic) so a concurrency stage runs it in parallel.
+    const adapter = `// ScriptedNativeRaw — the CONCRETE test handler: it satisfies every HandlerNR<comp> trait by draining a
+// per-COMPONENT scripted-outcome queue and decoding the scripted ok Value into the concrete row struct.
+// The decode (decode_row_*) is generated (it knows the concrete row type), so the runner stays fully
+// concrete. Sync (queues behind a Mutex, the probe counter an atomic) so a bc#87 stage parallelizes it.
+pub struct ScriptedNativeRaw {
+    queues: std::sync::Mutex<std::collections::HashMap<String, (Vec<serde_json::Value>, bool)>>,
+    #[allow(dead_code)]
+    seen: std::sync::atomic::AtomicUsize,
+}
+
+impl ScriptedNativeRaw {
+    // build from the JSON handlers spec: { "<component>": {ok|error} | [ {ok|error}, … ] }.
+    pub fn new(spec: &serde_json::Map<String, serde_json::Value>) -> Self {
+        let mut queues = std::collections::HashMap::new();
+        for (name, raw) in spec {
+            let (items, single) = match raw {
+                serde_json::Value::Array(a) => (a.clone(), false),
+                other => (vec![other.clone()], true),
+            };
+            queues.insert(name.clone(), (items, single));
+        }
+        ScriptedNativeRaw {
+            queues: std::sync::Mutex::new(queues),
+            seen: std::sync::atomic::AtomicUsize::new(0),
+        }
+    }
+
+    // drain one scripted outcome for a component (last entry repeats — mirrors the reference scripted
+    // handlers); None when the component has no scripted queue (fail-closed). Returns (is_error, err,
+    // ok_value). The bc#87 parallel-stage runner calls node_* from multiple threads, so the drain is
+    // Mutex-guarded.
+    fn next(&self, component: &str) -> Option<(bool, String, Option<Value>)> {
+        self.seen.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+        let mut queues = self.queues.lock().unwrap();
+        let (queue, single) = queues.get_mut(component)?;
+        let raw = if *single || queue.len() <= 1 { queue[0].clone() } else { queue.remove(0) };
+        if let Some(okv) = raw.get("ok") {
+            let v = behavior_contracts::decode_value(okv).expect("decode ok");
+            Some((false, String::new(), Some(v)))
+        } else {
+            let e = raw.get("error").and_then(|e| e.as_str()).unwrap_or("").to_string();
+            Some((true, e, None))
+        }
+    }
+}`;
+    const observeBound = needSync ? "" : "";
+    void observeBound;
+    return `// GENERATED test-only observe companion (bc#77/#94) — NOT part of the covered module. Serializes the
+// struct-native runner's result to a canonical Value for the equivalence pin, and carries the CONCRETE
+// scripted test handler (ScriptedNativeRaw) that satisfies every HandlerNR<comp> trait by decoding a
+// scripted Value into the concrete per-node row. The consumer never uses this (it keeps the model native
+// + implements HandlerNR<comp> over its own wire payload); it exists only so the test harness can
+// byte-compare the STRUCT-only covered read against run_behavior. A submodule of the covered module
+// (reads its pub run_native_raw_struct_* + the CONCRETE structs/traits — incl. the LOCAL BehaviorError —
+// via super::*). bc#90 / runtime-free: the covered module's BehaviorError is LOCAL, so this test-glue
+// companion refers to it via super::* (as \`BehaviorError\`) and refers to the bc-runtime failure type
+// FULLY-QUALIFIED (\`behavior_contracts::BehaviorError\`) only where it bridges at the observe boundary.
+#![allow(dead_code, unused_imports)]
+use behavior_contracts::Value;
+use super::*;
+
+// bridge the covered module's LOCAL BehaviorError (super::BehaviorError) to the bc-runtime failure type
+// the conformance harness reads (same code + message) — the ONLY place the two meet (test glue).
+fn to_rt_err(e: BehaviorError) -> behavior_contracts::BehaviorError {
+    behavior_contracts::BehaviorError::new(e.code, e.message)
+}
+${anyAsyncRunner
+        ? `// bc#97 (TEST glue) — a minimal std-only block-on that drives an async runner Future to completion so
+// observe_native_raw stays sync-callable (the harness never changes). The covered async fn's futures are
+// ready (the scripted handler does no real I/O), so a no-op waker + spin poll resolves in one step. This
+// lives ONLY in the observe companion — the covered module itself imports zero runtime.
+fn bc_block_on<F: std::future::Future>(mut fut: F) -> F::Output {
+    use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
+    fn noop(_: *const ()) {}
+    fn clone(_: *const ()) -> RawWaker {
+        RawWaker::new(std::ptr::null(), &VTABLE)
+    }
+    static VTABLE: RawWakerVTable = RawWakerVTable::new(clone, noop, noop, noop);
+    let waker = unsafe { Waker::from_raw(RawWaker::new(std::ptr::null(), &VTABLE)) };
+    let mut cx = Context::from_waker(&waker);
+    // SAFETY: fut is owned on the stack and never moved after pinning (it is dropped at scope end).
+    let mut fut = unsafe { std::pin::Pin::new_unchecked(&mut fut) };
+    loop {
+        match fut.as_mut().poll(&mut cx) {
+            Poll::Ready(v) => return v,
+            Poll::Pending => std::thread::yield_now(),
+        }
+    }
+}`
+        : ""}
+
+${serializers}
+
+// Value -> typed struct marshallers for the concrete-row decode (TEST glue only).
+${marshallers}
+
+${emitMarshalHelpers()}
+
+// per-node concrete-row decoders (scripted Value -> RawRowNR_/RawElemNR_ struct).
+${decodeFns.join("\n\n")}
+
+// input decoders (generic &[(String,Value)] -> concrete InNR_<comp>; TEST glue, one decode at the boundary).
+${inDecoders}
+
+${adapter}
+
+// scripted handler trait impls (one per covered component — the concrete node_* seam, test glue).
+${traitImpls.join("\n\n")}
+
+// observe_native_raw drives the CONCRETE struct-native runner and serializes to a canonical Value (test
+// only). Takes the CONCRETE &ScriptedNativeRaw handler so each enclosed run_native_raw_struct_* call is
+// instantiated at the concrete handler type (direct per-node method calls), not at a trait object.
+pub fn observe_native_raw(
+    name: &str,
+    handlers: &ScriptedNativeRaw,
+    input: &[(String, Value)],
+) -> Result<Value, behavior_contracts::BehaviorError> {
+    match name {
+${arms}
+        other => Err(behavior_contracts::BehaviorError::new("UNKNOWN_ENTRY", format!("component '{other}' is not a covered read (fail-closed)"))),
+    }
+}
+`;
+}
+/** emitInDecoder — a TEST-glue decoder `decode_InNR_<comp>(input) -> Result<InNR_<comp>, BehaviorError>`.
+ * Reads each declared input port from the generic &[(String,Value)] into the concrete field (scalar →
+ * typed read; Value-typed → the raw Value clone). A missing key leaves Default (every covered input is
+ * required + supplied by the corpus). Lives ONLY in the observe companion. */
+function emitInDecoder(comp, plan) {
+    const name = inStructName(comp.name);
+    const ports = Object.keys(comp.inputPorts ?? {});
+    const lines = [];
+    lines.push(`fn decode_${name}(input: &[(String, Value)]) -> Result<${name}, BehaviorError> {`);
+    lines.push(`    let mut in_ = ${name}::default();`);
+    if (ports.length === 0 || comp.inputPorts === undefined) {
+        lines.push(`    let _ = input;`);
+        lines.push(`    Ok(in_)`);
+        lines.push(`}`);
+        return lines.join("\n");
+    }
+    // an if/else-if chain (clippy-clean regardless of port count — a single-arm `match` trips single_match).
+    lines.push(`    for (k, v) in input {`);
+    ports.forEach((p, i) => {
+        const field = rustFieldName(p);
+        const schema = comp.inputPorts[p];
+        const scalar = inputScalarKind(schema);
+        const et = schema.elemType;
+        const head = i === 0 ? "        if" : "        } else if";
+        lines.push(`${head} k == ${rustStrLit(p)} {`);
+        if ((schema?.type === "array" || schema?.type === "arr") && et !== undefined) {
+            // #108: decode the boxed Value::Arr into the native Vec<ElemT> (test glue — materialize each elem).
+            const elemRef = deriveTypeRef(et, plan);
+            const elemTy = renderTypeRef(elemRef);
+            const mat = materializeExpr("ev", elemRef, plan);
+            lines.push(`            match v {`);
+            lines.push(`                Value::Arr(a) => {`);
+            lines.push(`                    let mut dec: Vec<${elemTy}> = Vec::with_capacity(a.len());`);
+            lines.push(`                    for ev in a.iter() { dec.push(${mat}); }`);
+            lines.push(`                    in_.${field} = dec;`);
+            lines.push(`                }`);
+            lines.push(`                other => return Err(marshal_type_error(${rustStrLit(`decode input ${p}: expected array, got `)}, other.type_name())),`);
+            lines.push(`            }`);
+        }
+        else if (scalar === undefined) {
+            lines.push(`            in_.${field} = v.clone();`);
+        }
+        else {
+            const pat = scalar === "String" ? "Value::Str(sv)" : scalar === "i64" ? "Value::Int(sv)" : scalar === "f64" ? "Value::Float(sv)" : "Value::Bool(sv)";
+            const label = scalar === "String" ? "string" : scalar === "i64" ? "int" : scalar === "f64" ? "float" : "bool";
+            const bind = scalar === "String" ? "sv.clone()" : "*sv";
+            // bc#90 / runtime-free: build the module-LOCAL BehaviorError (TYPE_MISMATCH) via the local
+            // marshal_type_error helper — decode_* returns the local error, bridged at the observe boundary.
+            lines.push(`            match v { ${pat} => in_.${field} = ${bind}, other => return Err(marshal_type_error(${rustStrLit(`decode input ${p}: expected ${label}, got `)}, other.type_name())) }`);
+        }
+    });
+    lines.push(`        }`);
+    lines.push(`    }`);
+    lines.push(`    Ok(in_)`);
+    lines.push(`}`);
+    return lines.join("\n");
+}
+/** emitDecodeRow — emit (once, deduped) a decoder `decode_row_<comp>_<node><suffix>(v: &Value) -> <rowT>`
+ * that materializes the scripted ok Value into the concrete row struct. Named: reuse the Value->struct
+ * marshaller + move fields; scalar/arr/opt: materialize into .val. TEST glue only. */
+function emitDecodeRow(compName, nodeId, rowT, ref, plan, emitted, out, suffix) {
+    const fn = `decode_row_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}${suffix.toLowerCase()}`;
+    if (emitted.has(fn))
+        return fn;
+    emitted.add(fn);
+    const lines = [];
+    lines.push(`fn ${fn}(v: &Value) -> ${rowT} {`);
+    if (ref.kind === "named") {
+        const decl = findDecl(plan, ref.name);
+        lines.push(`    let t = marshal_${ref.name}(v).expect("scripted row decode");`);
+        const inits = decl.fields.map((f) => `${rustFieldName(f.name)}: t.${rustFieldName(f.name)}`).join(", ");
+        lines.push(`    ${rowT} { ${inits}, ..Default::default() }`);
+    }
+    else {
+        const mat = materializeExpr("v", ref, plan);
+        lines.push(`    let val = (|| -> Result<${renderTypeRef(ref)}, BehaviorError> { Ok(${mat}) })().expect("scripted row decode");`);
+        lines.push(`    ${rowT} { val, ..Default::default() }`);
+    }
+    lines.push(`}`);
+    out.push(lines.join("\n"));
+    return fn;
+}
+export const rustTypedNativeEmitter = {
+    language: "rust-typed-native",
+    fileExtension: ".rs",
+    defaultRuntimeImport: "behavior_contracts",
+    filenameHint: "behaviors_typed_native_generated.rs",
+    emit,
+};
+//# sourceMappingURL=emit-typed-native-rust.js.map