behavior-contracts 0.5.0 → 0.7.0

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

@@ -1,8 +1,10 @@
 import { GeneratorFailure } from "./core.js";
-import { rustStraightlineInternals } from "./emit-straightline-rust.js";
-import { rustTypedInternals } from "./emit-straightline-typed-rust.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
@@ -84,7 +86,32 @@ function staticArrElems(node) {
     const arg = node.arr;
     return Array.isArray(arg) ? arg : null;
 }
-function inferPortType(node, inputPorts) {
+/**
+ * portArrayElemRef (#110) — resolve a componentRef input port that binds a RUNTIME ARRAY (an IN-list /
+ * array-bound WHERE head) to its native element TypeRef, or null when not a covered array. The covered
+ * shape is a SINGLE-SEGMENT, non-opt `ref` into an INPUT ARRAY port carrying a resolvable `elemType`
+ * (PortSchema.elemType — BC does NOT infer, consumer-interface C3). The port lowers to a native
+ * `Vec<ElemT>` fed from `in_.<field>.clone()`. Reuses the bc#108 elemType lowering, extended from the
+ * `map…over` element-source path to a plain componentRef port. A static string array is a different
+ * covered shape (Vec<&'static str>) — handled ahead of this. No resolvable elemType / opt / multi-segment
+ * ref / non-array schema / no plan → null (caller keeps its existing fail-closed behaviour). */
+function portArrayElemRef(node, inputPorts, plan) {
+    if (plan === undefined)
+        return null;
+    if (staticStringArrElems(node) !== null)
+        return null;
+    const e = classifyExpr(node);
+    if (e.kind !== "ref" || e.opt || e.path.length !== 1)
+        return null;
+    const schema = inputPorts?.[e.path[0]];
+    if (schema === undefined || (schema.type !== "array" && schema.type !== "arr"))
+        return null;
+    const et = schema.elemType;
+    if (et === undefined)
+        return null;
+    return deriveTypeRef(et, plan);
+}
+function inferPortType(node, inputPorts, asBinding) {
     if (staticArrElems(node) !== null)
         return "Value";
     const e = classifyExpr(node);
@@ -95,6 +122,18 @@ function inferPortType(node, inputPorts) {
         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) {
@@ -139,13 +178,17 @@ function staticStringArrElems(node) {
  * 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") {
+function portFieldRustType(node, inputPorts, where = "port", asBinding, plan) {
     if (staticStringArrElems(node) !== null)
         return "Vec<&'static str>";
+    // #110: a componentRef port bound to a runtime array input port (with a resolvable elemType) → Vec<ElemT>.
+    const arrElem = portArrayElemRef(node, inputPorts, plan);
+    if (arrElem !== null)
+        return `Vec<${renderTypeRef(arrElem)}>`;
     const num = numLiteralRustExpr(node);
     if (num !== null)
         return typeof node === "number" && Number.isInteger(node) ? "i64" : "f64";
-    const ft = inferPortType(node, inputPorts);
+    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.`);
     }
@@ -158,13 +201,13 @@ function portFieldRustType(node, inputPorts, where = "port") {
  * 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) {
+function emitPortsStruct(comp, node, asBinding, plan) {
     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}'`));
+    const types = portNames.map((p) => portFieldRustType(node.ports[p], comp.inputPorts, `port '${p}' of node '${node.id}'`, asBinding, plan));
     const fields = portNames
         .map((p, i) => `    pub ${portFieldName(p)}: ${types[i]}, // ${JSON.stringify(p)}`)
         .join("\n");
@@ -181,11 +224,14 @@ ${fields}
  * 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) {
+function emitMapPortsStructs(comp, node, typedNodes, plan) {
     const m = node.map;
     const name = portsStructName(comp.name, node.id);
     const batch = `${name}Batch`;
-    const elemStruct = emitPortsStruct(comp, { id: node.id, component: m.component, ports: m.ports });
+    // #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, plan);
     return `${elemStruct}
 
 // ${batch} — CONCRETE batched ports for map '${node.id}': the Vec of per-element CONCRETE ports structs
@@ -196,6 +242,188 @@ 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
@@ -209,6 +437,8 @@ pub struct ${batch} {
 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;
@@ -291,12 +521,14 @@ function boundRustType(node, typedNodes, plan) {
  * struct (per-element). This is the fully-concrete, runtime-free replacement for the NativeRawComponentExec
  * seam.
  */
-function emitHandlerTrait(comp, typedNodes, plan, isAsync = false) {
-    // bc#97: async I/O model (uniform) — every terminal handler method is an `async fn` so a consumer's
-    // async node_* returns a future that the (async) runner awaits at the call site. Default = plain `fn`
-    // (byte-identical to the pre-#97 sync output). `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.
-    const fnKw = isAsync ? "async fn" : "fn";
+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`);
@@ -304,7 +536,10 @@ function emitHandlerTrait(comp, typedNodes, plan, isAsync = false) {
     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;
@@ -368,8 +603,11 @@ function emitMapElemMaterializers(comp, typedNodes, plan) {
         const elemRowGo = rawElemStructName(comp.name, n.id);
         const intoRowRef = mapElemRowRef(n, arrRef, plan);
         const inits = [];
-        for (const f of overFields)
-            inits.push(`        ${rustFieldName(f.name)}: over.${rustFieldName(f.name)}.clone(),`);
+        // 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(", ")} }`
@@ -385,17 +623,33 @@ ${inits.join("\n")}
     }
     return parts.join("\n\n");
 }
-/** The Rust type of the over-element for a covered map node (parent collection element type). */
-function mapOverElemType(comp, node, typedNodes, plan) {
+/**
+ * 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")
-            return renderTypeRef(ref.elem);
+        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 (#86 pt2): map '${node.id}' 'over' must be a ref to a prior node's typed arr field.`);
+    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) {
@@ -489,19 +743,30 @@ function outputIsNativeLowerable(comp) {
 /**
  * coveredMapNode — the #86 part 2 covered map shape (nestedBatchGet), rust twin of the go predicate.
  */
-function coveredMapNode(n, bodyIds) {
+function coveredMapNode(n, bodyIds, comp) {
     if (n === null || typeof n !== "object" || !("map" in n))
         return false;
     const m = n.map;
-    if (m.when !== undefined)
+    // #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" || !bodyIds.has(overE.path[0]))
+    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]))
@@ -533,11 +798,16 @@ function coverageRejectReason(comp) {
     }
     const bodyIds = new Set(comp.body.map((b) => b.id));
     for (const n of comp.body) {
-        if ("cond" in n)
-            return `node '${n.id}' is a cond branch (not yet native-covered)`;
+        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))
-                return `node '${n.id}' is a non-covered map shape (guarded/over-input)`;
+            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))
@@ -576,8 +846,8 @@ function assertTypedCoverage(comp) {
     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; anything else → Value). */
-function inputPortRustType(schema) {
+/** 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";
@@ -587,6 +857,14 @@ function inputPortRustType(schema) {
             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";
     }
@@ -608,14 +886,14 @@ function inputScalarKind(schema) {
 }
 /** 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) {
+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])}, // ${JSON.stringify(p)}`)
+        .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).
@@ -695,8 +973,16 @@ function emitNativeScalar(node, want, resolveRef) {
  * 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) {
+function emitPortInit(pn, expr, fieldRustType, resolveRef, inputPorts, plan) {
     const field = portFieldName(pn);
+    // #110: a componentRef port bound to a runtime array input port (with elemType) → the native Vec<ElemT>,
+    // cloned out of the concrete input struct (`in_.<field>.clone()`) — ZERO boxed Value on the read hot path.
+    if (inputPorts !== undefined && portArrayElemRef(expr, inputPorts, plan) !== null) {
+        const e = classifyExpr(expr);
+        if (e.kind === "ref" && e.path.length === 1) {
+            return `${field}: in_.${rustFieldName(e.path[0])}.clone()`;
+        }
+    }
     // change #2: a static string array (projection) → a native `vec![...]` of &'static str.
     const strArr = staticStringArrElems(expr);
     if (strArr !== null) {
@@ -765,18 +1051,21 @@ function runnerResolveRef(priorNodeAt, atPos, typedNodes, plan, inputPorts) {
 function rustScalar(s) {
     return s === "string" ? "String" : s === "int" ? "i64" : s === "float" ? "f64" : "bool";
 }
-function emitNativeRawRunner(comp, plan, isAsync = false) {
+function emitNativeRawRunner(comp, plan, ap) {
     const ep = execPlan(comp);
     const order = ep.order;
     const hasConcurrency = ep.parallelStageOf.size > 0;
     const fn = sanitize(comp.name);
-    // bc#97 (uniform-rust-async slice): the async runner awaits each async handler at its call site. 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), and mixing it with an async terminal handler is
-    // a per-node-propagation problem outside THIS slice. Fail closed LOUDLY rather than emit code that
-    // won't compile.
+    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, which dispatches handlers on scoped std threads and cannot await async handlers. Async + concurrent-stage is a per-node-propagation follow-up (out of this uniform-async slice) — generate this component with io-model=sync, or split the concurrency stage.`);
+        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)
@@ -797,39 +1086,44 @@ function emitNativeRawRunner(comp, plan, isAsync = false) {
     };
     const outRef = comp.outputType !== undefined ? deriveTypeRef(comp.outputType, plan) : undefined;
     const outTy = outRef ? renderTypeRef(outRef) : "Value";
-    // Does any port read an input param? If not, `in_` is unused — bind it as `_in_` to stay clippy-clean.
+    // 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 = (() => {
-        const walk = (node, atPos) => {
-            const arr = staticArrElems(node);
-            if (arr !== null)
-                return arr.some((el) => walk(el, atPos));
-            const e = classifyExpr(node);
-            if (e.kind === "ref")
-                return !priorNodeAt(e.path[0], atPos);
-            if (e.kind === "concat")
-                return e.parts.some((p) => walk(reconstructR(p), atPos));
-            return false;
+        // 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 asName = m.as;
-                const walkMap = (node) => {
-                    const arr = staticArrElems(node);
-                    if (arr !== null)
-                        return arr.some(walkMap);
-                    const e = classifyExpr(node);
-                    if (e.kind === "ref")
-                        return e.path[0] !== asName && !priorNodeAt(e.path[0], k);
-                    if (e.kind === "concat")
-                        return e.parts.some((p) => walkMap(reconstructR(p)));
-                    return false;
-                };
-                return Object.values(m.ports).some((pn) => walkMap(pn));
+                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));
+            return Object.values(cr.ports).some((pn) => walk(pn, k, new Set()));
         });
     })();
     const inParam = readsInput ? "in_" : "_in_";
@@ -853,8 +1147,10 @@ function emitNativeRawRunner(comp, plan, isAsync = false) {
     // 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(`    handlers: &H,`);
+    lines.push(`    ${dispatchesHandler ? "handlers" : "_handlers"}: &H,`);
     lines.push(`    ${inParam}: ${inStructName(comp.name)},`);
     lines.push(`) -> Result<${outTy}, BehaviorError> {`);
     for (const k of order.keys()) {
@@ -872,7 +1168,12 @@ function emitNativeRawRunner(comp, plan, isAsync = false) {
             continue;
         }
         if ("map" in comp.body[i]) {
-            lines.push(emitMapArm(comp, comp.body[i], k, typedNodes, plan, priorNodeAt, isAsync));
+            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];
@@ -914,11 +1215,14 @@ function emitNativeRawRunner(comp, plan, isAsync = false) {
         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 ty = portFieldRustType(expr, comp.inputPorts, `port '${pn}' of node '${node.id}'`, undefined, plan);
+            inits.push(emitPortInit(pn, expr, ty, resolveRef, comp.inputPorts, plan));
         }
         const boundArg = node.bindField !== undefined ? `bound_${s}` : "None";
-        const awaitSfx = isAsync ? ".await" : "";
+        // 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,`);
@@ -995,8 +1299,8 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
         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));
+            const ty = portFieldRustType(expr, comp.inputPorts, `port '${pn}' of node '${node.id}'`, undefined, plan);
+            inits.push(emitPortInit(pn, expr, ty, resolveRef, comp.inputPorts, plan));
         }
         if (gated) {
             lines.push(`${ind}ports_${s} = Some(${structName} { ${inits.join(", ")} });`);
@@ -1084,26 +1388,26 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
  *   - #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, isAsync = false) {
+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`;
-    const overE = classifyExpr(m.over);
-    const overParent = overE.kind === "ref" ? overE.path[0] : "";
-    const overBaseRef = typedNodes.get(overParent);
-    const { ref: overRef } = typedFieldAccess(`${typedCell(overParent)}.borrow()`, overBaseRef, overE.kind === "ref" ? overE.path.slice(1) : [], plan);
-    const overElemRef = overRef.elem;
-    const overFieldPath = overE.kind === "ref" ? overE.path.slice(1).map((p) => `.${rustFieldName(p)}`).join("") : "";
+    // #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 = elemArrRef.elem.name;
+    const elemName = renderTypeRef(elemArrRef.elem);
     const resolveRef = (head, restPath, opt) => {
         if (opt)
             return null;
@@ -1138,37 +1442,77 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, isAsync =
         }
         if (acc.kind !== "scalar" || acc.scalar === "null")
             return null;
-        const owned = acc.scalar === "string" ? `(${expr}).clone()` : `*(${expr})`;
+        // 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}'`);
-            inits.push(emitPortInit(pn, m.ports[pn], ty, resolveRef));
+            const ty = portFieldRustType(m.ports[pn], comp.inputPorts, `map port '${pn}' of node '${node.id}'`, asBinding, plan);
+            inits.push(emitPortInit(pn, m.ports[pn], ty, resolveRef, comp.inputPorts, plan));
         }
         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)}${m.relationKind ? ", relationKind:" + m.relationKind : ""}${m.parent ? ", parent:" + m.parent : ""}) ──`);
+    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} = ${typedCell(overParent)}.borrow()${overFieldPath}.clone();`);
+    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();`);
@@ -1183,23 +1527,28 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, isAsync =
         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}    }`);
-        lines.push(`${indent}    let mut rows_iter_${s} = row_${s}.rows.into_iter();`);
-        lines.push(`${indent}    for over_el_${s} in over_${s}.iter() {`);
-        lines.push(`${indent}        let er_${s} = rows_iter_${s}.next().expect("aligned batch row");`);
         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 {
-            lines.push(`${indent}        let _ = &over_el_${s};`);
+            // 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}    }`);
         lines.push(`${indent}}`);
     }
     else {
-        // #93 shape 2: NON-batched map...into — dispatch ONCE PER ELEMENT.
+        // #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} {`);
@@ -1213,6 +1562,7 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, isAsync =
             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});`);
         }
@@ -1224,6 +1574,71 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, isAsync =
         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) {
@@ -1306,8 +1721,11 @@ fn unknown_component(component: &str) -> BehaviorError {
 }`;
 // ── module assembly ──────────────────────────────────────────────────────────────────
 function emit(ctx) {
-    // bc#97: uniform I/O model for THIS generation — async terminal handlers ⇒ async fn + .await.
-    const isAsync = ctx.ioModel === "async";
+    // 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);
@@ -1342,6 +1760,8 @@ ${emitStructSurface([])}
         .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 = [];
@@ -1349,21 +1769,26 @@ ${emitStructSurface([])}
     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));
+                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));
-            typedNodes.set(n.id, deriveTypeRef(n.outType, plan));
+                structs.push(emitPortsStruct(c, n, undefined, plan));
         }
         rowStructs.push(emitRawRowStructs(c, typedNodes, plan));
-        handlerTraits.push(emitHandlerTrait(c, typedNodes, plan, isAsync));
-        inStructs.push(emitInStruct(c));
+        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, isAsync)).join("\n\n");
+    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)]
@@ -1389,8 +1814,15 @@ use std::cell::RefCell;`;
         decls || undefined,
         defaults || undefined,
         UNKNOWN_COMPONENT_HELPER,
-        `// Native ports structs (one per componentRef node; typed per the static port type — CONCRETE).\n${structs.join("\n\n")}`,
-        `// CONCRETE per-node row structs (typed fields = the node's outType; + error signal).\n${rowStructs.join("\n\n")}`,
+        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
@@ -1410,13 +1842,18 @@ use std::cell::RefCell;`;
  * 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) {
+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
@@ -1425,12 +1862,18 @@ export function rustTypedNativeObserve(ir) {
     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);
@@ -1445,7 +1888,7 @@ export function rustTypedNativeObserve(ir) {
                 const portsT = batched ? `${portsStructName(c.name, n.id)}Batch` : portsStructName(c.name, n.id);
                 const retT = batched ? batchT : elemT;
                 if (batched) {
-                    methods.push(`    fn ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Option<${batchT}> {
+                    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() });
@@ -1456,7 +1899,7 @@ export function rustTypedNativeObserve(ir) {
     }`);
                 }
                 else {
-                    methods.push(`    fn ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Option<${elemT}> {
+                    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() });
@@ -1471,7 +1914,7 @@ export function rustTypedNativeObserve(ir) {
             const node = n;
             const rowT = rawRowStructName(c.name, node.id);
             const decode = emitDecodeRow(c.name, node.id, rowT, ref, plan, emittedDecode, decodeFns, "");
-            methods.push(`    fn ${nodeMethodName(node.id)}(&self, _ports: &${portsStructName(c.name, node.id)}, _bound: ${bt}) -> Option<${rowT}> {
+            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() });
@@ -1490,7 +1933,12 @@ export function rustTypedNativeObserve(ir) {
         // 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.
-        return `        ${rustStrLit(c.name)} => {\n            let in_ = decode_${inStructName(c.name)}(input).map_err(to_rt_err)?;\n            let tv = super::run_native_raw_struct_${sanitize(c.name)}(handlers, in_).map_err(to_rt_err)?;\n            Ok(${ser})\n        }`;
+        // 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`
@@ -1562,6 +2010,30 @@ use super::*;
 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}
 
@@ -1601,7 +2073,6 @@ ${arms}
  * 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) {
-    void plan;
     const name = inStructName(comp.name);
     const ports = Object.keys(comp.inputPorts ?? {});
     const lines = [];
@@ -1617,10 +2088,26 @@ function emitInDecoder(comp, plan) {
     lines.push(`    for (k, v) in input {`);
     ports.forEach((p, i) => {
         const field = rustFieldName(p);
-        const scalar = inputScalarKind(comp.inputPorts[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 (scalar === undefined) {
+        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 {