behavior-contracts 0.8.4 → 0.8.6

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

@@ -20,25 +20,71 @@ function rustErr(code, msgExpr) {
  * 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
+    return `// ErrorKind — what went wrong (the closed set of scp-error.md). A concrete enum: the covered plane
+// carries no strings-as-tags and no dynamic kind lookup.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ErrorKind {
+    TypeMismatch,
+    MissingField,
+    Overflow,
+}
+
+impl ErrorKind {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            ErrorKind::TypeMismatch => "typeMismatch",
+            ErrorKind::MissingField => "missingField",
+            ErrorKind::Overflow => "overflow",
+        }
+    }
+}
+
+// ErrorDetail — the structured, recoverable payload a failure carries (scp-error.md "The Error
+// Value"). The LEAF produces it at the wire boundary (it is the only party holding both the declared
+// type and the raw wire datum); the runner transports it verbatim. Concrete fields — no boxed Value,
+// no serialized blob in a string: \`expected_type\` is Portable Type Notation, a rendering of a
+// STATICALLY DECLARED type, so nothing walks a type at runtime.
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct ErrorDetail {
+    pub kind: Option<ErrorKind>,
+    pub model: Option<String>,
+    pub field: Option<String>,
+    pub expected_type: Option<String>,
+    pub actual_wire_type: Option<String>,
+    pub raw_value: Option<String>,
+    pub context: std::collections::BTreeMap<String, String>,
+}
+
+// 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.
+// (byte-equal). \`detail\` carries the leaf's structured Error Value across the seam so a caller can
+// log / skip / repair / migrate rather than parse a message. The observe companion (test glue, a
+// super:: submodule) bridges this local error to the bc-runtime failure at the observe boundary —
+// the covered module itself stays runtime-free.
 #[derive(Debug, Clone)]
 pub struct BehaviorError {
     pub code: String,
     pub message: String,
+    pub detail: Option<Box<ErrorDetail>>,
 }
 
 impl BehaviorError {
     pub fn new(code: impl Into<String>, message: impl Into<String>) -> Self {
-        BehaviorError { code: code.into(), message: message.into() }
+        BehaviorError { code: code.into(), message: message.into(), detail: None }
+    }
+    /// The same failure carrying the leaf's structured Error Value.
+    pub fn with_detail(code: impl Into<String>, message: impl Into<String>, detail: ErrorDetail) -> Self {
+        BehaviorError { code: code.into(), message: message.into(), detail: Some(Box::new(detail)) }
     }
     /// The stable failure code (byte-equal to run_behavior) WITHOUT a bc-runtime type.
     pub fn code(&self) -> &str {
         &self.code
     }
+    /// The structured payload, if this failure is about a datum.
+    pub fn detail(&self) -> Option<&ErrorDetail> {
+        self.detail.as_deref()
+    }
 }
 
 impl std::fmt::Display for BehaviorError {
@@ -46,7 +92,75 @@ impl std::fmt::Display for BehaviorError {
         write!(f, "{}: {}", self.code, self.message)
     }
 }
-impl std::error::Error for BehaviorError {}`;
+impl std::error::Error for BehaviorError {}
+
+// op_failed — wrap a leaf failure as the node's Failure under its Error Policy Kind, carrying the
+// leaf's structured detail through unchanged (the runner transports the Error Value; it does not
+// synthesize or re-interpret it).
+#[allow(dead_code)]
+fn op_failed(node: &str, policy: &str, e: BehaviorError) -> BehaviorError {
+    BehaviorError {
+        code: "OP_FAILED".to_string(),
+        message: format!("operation '{node}' failed under '{policy}' policy: {}", e.message),
+        detail: e.detail,
+    }
+}
+
+// de_type_mismatch / de_missing_field / de_overflow — the de-box mismatch failures the generated decode
+// produces (scp-error.md "The Error Value"). Codes are byte-equal to the runtime outType check
+// (TYPE_MISMATCH / MISSING_PROP) so the covered read stays equivalent to run_behavior; detail.kind
+// distinguishes typeMismatch / missingField / overflow.
+#[allow(dead_code)]
+fn de_type_mismatch(model: &str, field: &str, expected: &str, actual_wire: String, raw: String) -> BehaviorError {
+    BehaviorError::with_detail(
+        "TYPE_MISMATCH",
+        format!("node '{model}': {field}: expected {expected}, got {actual_wire}"),
+        ErrorDetail {
+            kind: Some(ErrorKind::TypeMismatch),
+            model: Some(model.to_string()),
+            field: Some(field.to_string()),
+            expected_type: Some(expected.to_string()),
+            actual_wire_type: Some(actual_wire),
+            raw_value: Some(raw),
+            context: std::collections::BTreeMap::new(),
+        },
+    )
+}
+
+#[allow(dead_code)]
+fn de_missing_field(model: &str, field: &str, expected: &str) -> BehaviorError {
+    BehaviorError::with_detail(
+        "MISSING_PROP",
+        format!("node '{model}': {field}: required field is absent"),
+        ErrorDetail {
+            kind: Some(ErrorKind::MissingField),
+            model: Some(model.to_string()),
+            field: Some(field.to_string()),
+            expected_type: Some(expected.to_string()),
+            actual_wire_type: None,
+            raw_value: None,
+            context: std::collections::BTreeMap::new(),
+        },
+    )
+}
+
+#[allow(dead_code)]
+fn de_overflow(model: &str, field: &str, expected: &str, actual_wire: String, raw: String) -> BehaviorError {
+    let message = format!("node '{model}': {field}: {raw} is outside the range of {expected}");
+    BehaviorError::with_detail(
+        "TYPE_MISMATCH",
+        message,
+        ErrorDetail {
+            kind: Some(ErrorKind::Overflow),
+            model: Some(model.to_string()),
+            field: Some(field.to_string()),
+            expected_type: Some(expected.to_string()),
+            actual_wire_type: Some(actual_wire),
+            raw_value: Some(raw),
+            context: std::collections::BTreeMap::new(),
+        },
+    )
+}`;
 }
 function portFieldName(wire) {
     const safe = wire.replace(/[^A-Za-z0-9_]/g, "_").toLowerCase();
@@ -78,250 +192,499 @@ function nodeMethodName(nodeId) {
 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 recordTop(ref) {
+    if (ref.kind === "named")
+        return { kind: "named", innerName: ref.name };
+    if (ref.kind === "arr" && ref.elem.kind === "named")
+        return { kind: "arr", innerName: ref.elem.name };
+    if (ref.kind === "opt" && ref.inner.kind === "named")
+        return { kind: "opt", innerName: ref.inner.name };
+    if (ref.kind === "map" && ref.value.kind === "named")
+        return { kind: "map", innerName: ref.value.name };
+    return null;
 }
-/**
- * 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);
+/** deBoxEligible — a componentRef node whose result is a record-containing top (named / arr(named) /
+ * opt(named) / map(named)). Its handler returns the wire; the generated decode probes each record. */
+function deBoxEligible(ref) {
+    return recordTop(ref) !== null;
+}
+/** rustWireTypeForTop — the Rust handler return type (over the associated Self::Wire) for a record top. */
+function rustWireTypeForTop(top) {
+    switch (top.kind) {
+        case "named":
+            return "Self::Wire";
+        case "arr":
+            return "Vec<Self::Wire>";
+        case "opt":
+            return "Option<Self::Wire>";
+        case "map":
+            return "std::collections::BTreeMap<String, Self::Wire>";
+    }
+}
+/** notationOfRef — the Portable Type Notation of a TypeRef (scp-error.md), resolving a named ref to its
+ * obj notation via the plan. Baked as the `expectedType` literal (a rendering of the STATICALLY declared
+ * type — nothing walks a type at runtime). */
+function notationOfRef(ref, plan) {
+    switch (ref.kind) {
+        case "scalar":
+            return ref.scalar;
+        case "opt":
+            return `opt(${notationOfRef(ref.inner, plan)})`;
+        case "arr":
+            return `arr(${notationOfRef(ref.elem, plan)})`;
+        case "map":
+            return `map(${notationOfRef(ref.value, plan)})`;
+        case "named": {
+            const decl = findDecl(plan, ref.name);
+            return `obj{${decl.fields.map((f) => `${f.name}:${notationOfRef(f.type, plan)}`).join(",")}}`;
+        }
+    }
+}
+/** emitRustProbeWireTypes — the once-per-module probe enums + WireRow/WireList seam traits. Concrete
+ * enums; monomorphized traits (mutual Row/List associated types keep nesting concrete, no dyn/Box). */
+function emitRustProbeWireTypes() {
+    return `// Probe<T> / NumProbe — the outcome of classifying one wire attribute against a declared type. Got carries
+// the matched value (a NumProbe's raw numeric text, which the de-box parses + range-checks so overflow is
+// BC's to detect); actual_wire_type is the producer's own wire tag (a free string, e.g. a DynamoDB
+// "S"/"N"/"BOOL"); raw_value is the offending value stringified. Concrete enums — no boxed Value.
+pub enum Probe<T> {
+    Got(T),
+    Wrong { actual_wire_type: String, raw_value: String },
+    Null { actual_wire_type: String, raw_value: String },
+    Absent,
 }
-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";
-            }
-            // a ref to a REQUIRED scalar input port → that scalar. An OPTIONAL port has no required-scalar
-            // kind (its native type is Option<T>) and is lowered by the opt lane ahead of this — reaching here
-            // with one means the shape is uncovered, and "Value" routes it to the caller's loud fail-closed.
-            if (e.path.length === 1) {
-                const sc = inputScalarKind(inputPorts[e.path[0]]);
-                if (sc !== undefined)
-                    return sc;
-            }
-            return "Value";
-        }
-        default:
-            return "Value";
-    }
+
+pub enum NumProbe {
+    Got { raw: String, actual_wire_type: String },
+    Wrong { actual_wire_type: String, raw_value: String },
+    Null { actual_wire_type: String, raw_value: String },
+    Absent,
 }
-/** 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);
+
+// WireRow / WireList — the consumer's wire item / wire array, probed per declared field / element by the
+// generated de-box. The consumer implements them over its wire payload (a DynamoDB AttributeValue map)
+// and classifies each attribute's variant; the de-box owns strictness. Monomorphized (Row/List mutual
+// associated types) — no dyn, no Box, no boxed Value crosses the seam.
+pub trait WireRow: Sized {
+    type List: WireList<Row = Self>;
+    // the attribute keys present (the entries of a wire map / DynamoDB "M") — iterated to decode a map(V).
+    fn keys(&self) -> Vec<String>;
+    fn probe_string(&self, field: &str) -> Probe<String>;
+    fn probe_number(&self, field: &str) -> NumProbe;
+    fn probe_bool(&self, field: &str) -> Probe<bool>;
+    fn probe_row(&self, field: &str) -> Probe<Self>;
+    fn probe_list(&self, field: &str) -> Probe<Self::List>;
+}
+
+pub trait WireList: Sized {
+    type Row: WireRow<List = Self>;
+    fn len(&self) -> usize;
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    fn elem_string(&self, i: usize) -> Probe<String>;
+    fn elem_number(&self, i: usize) -> NumProbe;
+    fn elem_bool(&self, i: usize) -> Probe<bool>;
+    fn elem_row(&self, i: usize) -> Probe<Self::Row>;
+    fn elem_list(&self, i: usize) -> Probe<Self>;
+}`;
+}
+/** rustDecodeNamedName — the decode function name for a named type (deduped across the module). */
+function rustDecodeNamedName(name) {
+    return `decode_wire_${name.replace(/[^A-Za-z0-9_]/g, "_").toLowerCase()}`;
+}
+/**
+ * emitRustDecodeNamed — emit (once, deduped) `decode_wire_<name><W: WireRow>(w: &W) -> Result<Name,
+ * BehaviorError>`: probe each declared field from the type SSoT (via the single rustDecodeValue
+ * recursion) and build the struct, failing closed with the structured Error Value on a mismatch.
+ */
+function emitRustDecodeNamed(name, plan, emitted, out) {
+    const fn = rustDecodeNamedName(name);
+    if (emitted.has(fn))
+        return fn;
+    emitted.add(fn);
+    const decl = findDecl(plan, name);
+    const lines = [];
+    lines.push(`// ${fn} — the strict de-box for '${name}': probe each declared field, fail closed on a`);
+    lines.push(`// wire mismatch with the structured Error Value (byte-equal codes to run_behavior).`);
+    lines.push(`fn ${fn}<W: WireRow>(w: &W) -> Result<${name}, BehaviorError> {`);
+    const ctr = { n: 0 };
+    const binds = [];
+    for (const f of decl.fields) {
+        const rf = rustFieldName(f.name);
+        const expr = rustDecodeValue(f.type, "w", rustStrLit(f.name), "row", name, f.name, plan, emitted, out, ctr, 1);
+        lines.push(`    let ${rf} = ${expr};`);
+        binds.push(rf);
+    }
+    lines.push(`    Ok(${name} { ${binds.join(", ")} })`);
+    lines.push(`}`);
+    out.push(lines.join("\n"));
+    return fn;
+}
+/**
+ * rustDecodeValue — the SINGLE recursive decode over the full TypeRef grammar (scalar / opt(scalar) /
+ * named / arr / map). Returns a Rust expression (a match block) that evaluates to the decoded value of
+ * `ref`, obtained by probing `srcExpr` at `keyExpr` (a WireRow field via `probe_*`, srcKind "row"; or a
+ * WireList element via `elem_*`, srcKind "list"). Every nested position (arr element, map value, obj
+ * field) recurses through THIS function, so arbitrary nesting works by construction. A mismatch does
+ * `return Err(<structured error>)`; no panic, no boxed value.
+ */
+function rustDecodeValue(ref, srcExpr, keyExpr, srcKind, model, fieldRaw, plan, emitted, out, ctr, indent) {
+    const I = "    ".repeat(indent);
+    const I1 = "    ".repeat(indent + 1);
+    const ml = rustStrLit(model);
+    const fl = rustStrLit(fieldRaw);
+    const nl = rustStrLit(notationOfRef(ref, plan));
+    const id = ctr.n++;
+    const prefix = srcKind === "row" ? "probe_" : "elem_";
+    const mismatch = `return Err(de_type_mismatch(${ml}, ${fl}, ${nl}, actual_wire_type, raw_value))`;
+    const missing = `return Err(de_missing_field(${ml}, ${fl}, ${nl}))`;
+    if (ref.kind === "opt" && ref.inner.kind === "scalar" && ref.inner.scalar !== "null") {
+        const inner = ref.inner.scalar;
+        if (inner === "int" || inner === "float") {
+            const rustT = inner === "int" ? "i64" : "f64";
+            return `match ${srcExpr}.${prefix}number(${keyExpr}) {
+${I1}NumProbe::Got { raw, actual_wire_type } => match raw.parse::<${rustT}>() {
+${I1}    Ok(n) => Some(n),
+${I1}    Err(_) => return Err(de_overflow(${ml}, ${fl}, ${nl}, actual_wire_type, raw)),
+${I1}},
+${I1}NumProbe::Wrong { actual_wire_type, raw_value } => ${mismatch},
+${I1}NumProbe::Null { .. } | NumProbe::Absent => None,
+${I}}`;
+        }
+        const meth = inner === "string" ? "string" : "bool";
+        return `match ${srcExpr}.${prefix}${meth}(${keyExpr}) {
+${I1}Probe::Got(v) => Some(v),
+${I1}Probe::Wrong { actual_wire_type, raw_value } => ${mismatch},
+${I1}Probe::Null { .. } | Probe::Absent => None,
+${I}}`;
+    }
+    if (ref.kind === "scalar" && ref.scalar !== "null") {
+        if (ref.scalar === "int" || ref.scalar === "float") {
+            const rustT = ref.scalar === "int" ? "i64" : "f64";
+            return `match ${srcExpr}.${prefix}number(${keyExpr}) {
+${I1}NumProbe::Got { raw, actual_wire_type } => match raw.parse::<${rustT}>() {
+${I1}    Ok(n) => n,
+${I1}    Err(_) => return Err(de_overflow(${ml}, ${fl}, ${nl}, actual_wire_type, raw)),
+${I1}},
+${I1}NumProbe::Wrong { actual_wire_type, raw_value }
+${I1}| NumProbe::Null { actual_wire_type, raw_value } => ${mismatch},
+${I1}NumProbe::Absent => ${missing},
+${I}}`;
+        }
+        const meth = ref.scalar === "string" ? "string" : "bool";
+        return `match ${srcExpr}.${prefix}${meth}(${keyExpr}) {
+${I1}Probe::Got(v) => v,
+${I1}Probe::Wrong { actual_wire_type, raw_value }
+${I1}| Probe::Null { actual_wire_type, raw_value } => ${mismatch},
+${I1}Probe::Absent => ${missing},
+${I}}`;
     }
-    return out;
+    if (ref.kind === "named") {
+        const dec = emitRustDecodeNamed(ref.name, plan, emitted, out);
+        const rowMeth = srcKind === "row" ? "probe_row" : "elem_row";
+        return `match ${srcExpr}.${rowMeth}(${keyExpr}) {
+${I1}Probe::Got(sub) => ${dec}(&sub)?,
+${I1}Probe::Wrong { actual_wire_type, raw_value }
+${I1}| Probe::Null { actual_wire_type, raw_value } => ${mismatch},
+${I1}Probe::Absent => ${missing},
+${I}}`;
+    }
+    if (ref.kind === "arr") {
+        const listMeth = srcKind === "row" ? "probe_list" : "elem_list";
+        const elemExpr = rustDecodeValue(ref.elem, `l${id}`, `i${id}`, "list", model, fieldRaw, plan, emitted, out, ctr, indent + 2);
+        return `match ${srcExpr}.${listMeth}(${keyExpr}) {
+${I1}Probe::Got(l${id}) => {
+${I1}    let mut acc = Vec::with_capacity(l${id}.len());
+${I1}    for i${id} in 0..l${id}.len() {
+${I1}        acc.push(${elemExpr});
+${I1}    }
+${I1}    acc
+${I1}}
+${I1}Probe::Wrong { actual_wire_type, raw_value }
+${I1}| Probe::Null { actual_wire_type, raw_value } => ${mismatch},
+${I1}Probe::Absent => ${missing},
+${I}}`;
+    }
+    if (ref.kind === "map") {
+        // a declared map(V): the wire value is a producer map (a DynamoDB "M"); enumerate its keys and decode
+        // each value as V through THIS same recursion (so map-of-map / map-of-arr nest by construction).
+        const rowMeth = srcKind === "row" ? "probe_row" : "elem_row";
+        const valExpr = rustDecodeValue(ref.value, `m${id}`, `&k${id}`, "row", model, fieldRaw, plan, emitted, out, ctr, indent + 2);
+        return `match ${srcExpr}.${rowMeth}(${keyExpr}) {
+${I1}Probe::Got(m${id}) => {
+${I1}    let mut acc = std::collections::BTreeMap::new();
+${I1}    for k${id} in m${id}.keys() {
+${I1}        let v${id} = ${valExpr};
+${I1}        acc.insert(k${id}, v${id});
+${I1}    }
+${I1}    acc
+${I1}}
+${I1}Probe::Wrong { actual_wire_type, raw_value }
+${I1}| Probe::Null { actual_wire_type, raw_value } => ${mismatch},
+${I1}Probe::Absent => ${missing},
+${I}}`;
+    }
+    throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust strict de-box: '${fieldRaw}' of '${model}' has type ${JSON.stringify(ref)} which the generated de-box does not decode (supported: scalar / opt(scalar) / named / arr / map).`);
+}
+/** rustDecodeElemName — the element de-box function name for a map/fanout node. */
+function rustDecodeElemName(compName, nodeId) {
+    return `decode_wire_elem_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_").toLowerCase()}`;
+}
+/** mapFanoutElemRef — the element ROW TypeRef a map/fanout node decodes (the per-element record). */
+function mapFanoutElemRef(node, typedNodes, plan) {
+    const ref = typedNodes.get(node.id);
+    if ("fanout" in node)
+        return fanoutItemsElemRef(node, ref, plan);
+    return mapElemRowRef(node, ref, plan);
+}
+/** mapFanoutElemDeBoxEligible — a map/fanout node whose element ROW is a named record de-boxes each
+ * element through the generated decode_wire_elem_* (closing the scan-row silent-default hole). */
+function mapFanoutElemDeBoxEligible(node, typedNodes, plan) {
+    return mapFanoutElemRef(node, typedNodes, plan).kind === "named";
 }
 /**
- * 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.
+ * emitRustDecodeElemRow — emit (once) `decode_wire_elem_<comp>_<node><W: WireRow>(w: &W) ->
+ * Result<RawElemNR<comp><node>, BehaviorError>` for a map/fanout node whose element ROW is a named
+ * record: probe each declared field via the SAME rustDecodeValue recursion as record reads and build the
+ * concrete RawElemNR struct, failing closed with the structured Error Value on a mismatch.
  */
-function portFieldRustType(node, inputPorts, where = "port", asBinding, plan, typedNodes) {
-    // A port reading an OPTIONAL input port lowers through the shared native-expr compiler (the
-    // Option<T> pass-through / the coalesce default). It runs FIRST so an optional input can never fall
-    // into the required-scalar inference below (which has no way to say "absent").
-    const optPort = optPortCompileR(node, inputPorts, where, plan);
-    if (optPort !== null)
-        return renderTypeRef(optPort.ref);
-    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)}>`;
-    // #129: a leaf port that is a ref into a PRIOR NODE's typed arr outType (node→leaf array dataflow) → Vec<ElemT>.
-    const priorArr = priorNodeArrElemInfo(node, typedNodes, plan);
-    if (priorArr !== null)
-        return `Vec<${renderTypeRef(priorArr.elemRef)}>`;
-    const num = numLiteralRustExpr(node);
-    if (num !== null)
-        return typeof node === "number" && Number.isInteger(node) ? "i64" : "f64";
-    // a ref to a `$as` element field (or an input port) whose type is a MAP or NAMED struct (NOT a bare
-    // scalar) → the native map/struct type. #108-map: a `{map:V}`-typed field (e.g. a nested
-    // `map<map<obj>>` write port) lowers to BTreeMap; a named field lowers to its struct. Reuses the same
-    // typedFieldAccess resolution as the scalar path; a genuinely-untyped ref still falls through.
-    const composite = portCompositeRef(node, inputPorts, asBinding, plan);
-    if (composite !== null)
-        return renderTypeRef(composite);
-    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. ${RUST_STATIC_PORT_FORMS} Regenerate on the boxed straight-line path if this port is genuinely dynamic.`);
-    }
-    return ft;
+function emitRustDecodeElemRow(comp, node, elemRowRef, plan, emitted, out) {
+    const nodeId = node.id;
+    const fn = rustDecodeElemName(comp.name, nodeId);
+    if (emitted.has(fn))
+        return fn;
+    emitted.add(fn);
+    const retType = rawElemStructName(comp.name, nodeId);
+    const decl = findDecl(plan, elemRowRef.name);
+    const lines = [];
+    lines.push(`// ${fn} — the strict de-box for a '${nodeId}' element row: probe each declared field, fail`);
+    lines.push(`// closed on a wire mismatch with the structured Error Value (byte-equal codes to run_behavior).`);
+    lines.push(`fn ${fn}<W: WireRow>(w: &W) -> Result<${retType}, BehaviorError> {`);
+    const ctr = { n: 0 };
+    const binds = [];
+    for (const f of decl.fields) {
+        const rf = rustFieldName(f.name);
+        const expr = rustDecodeValue(f.type, "w", rustStrLit(f.name), "row", elemRowRef.name, f.name, plan, emitted, out, ctr, 1);
+        lines.push(`    let ${rf} = ${expr};`);
+        binds.push(rf);
+    }
+    lines.push(`    Ok(${retType} { ${binds.join(", ")} })`);
+    lines.push(`}`);
+    out.push(lines.join("\n"));
+    return fn;
+}
+/** emitRustNodeDecodeFns — emit the decode functions for every de-box-eligible node: a componentRef
+ * record read (decode_wire_<name>) OR a map/fanout element row (decode_wire_elem_<comp>_<node>). */
+/** rustDecodeResultName — the top-result decode function name for a de-box componentRef node. */
+function rustDecodeResultName(compName, nodeId) {
+    return `decode_wire_result_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_").toLowerCase()}`;
 }
 /**
- * optPortCompileR — the OPTIONAL-input port lane (rust). A component may declare an input port
- * `{opt:T}` (PortSchema `required:false`); the only native representation of "the value is absent" is
- * `Option<T>`, so such a port never lowers through the required-scalar inference. This lane compiles the
- * port expression with the SHARED runtime-free native-expr compiler (native-expr.ts — the same traversal,
- * type-inference and fail-closed discipline the go twin uses, so the two agree by construction):
- *
- *   - `opt($.x)` / `$.x` at port position  → `Option<T>` (the leaf receives the absent value as null,
- *     exactly as run_behavior's `evalPorts` passes it).
- *   - `coalesce(opt($.x), <literal>)`      → `in_.x.unwrap_or(<literal>)` — a native `T`, no boxed Value.
- *   - `ne(opt($.x), null)` / `eq(…, null)` → the native presence test (`is_some()` / `is_none()`).
- *
- * Returns null when the port expression reads NO optional input (the caller keeps its existing lowering).
- * A port that DOES read one but does not compile — or that compiles to a fallible expression, which this
- * position cannot hoist — FAILS CLOSED loudly rather than degrade to a required type or a zero value.
+ * emitRustDecodeWireResult — emit (once) `decode_wire_result_<comp>_<node><W: WireRow>(wire: <WireArg>)
+ * -> Result<<ResultType>, BehaviorError>` for a componentRef node whose result is a record-containing
+ * top: it decodes each record via decode_wire_<name> and assembles the top (record / Vec / Option /
+ * BTreeMap). One path covers named / arr(named) / opt(named) / map(named).
  */
-function optPortCompileR(node, inputPorts, where, plan) {
-    if (plan === undefined)
-        return null;
-    if (!exprReadsOptionalInput(node, inputPorts))
-        return null;
-    const resolveHead = (head) => rustInputHeadRef(head, { inputPorts }, plan);
-    let c;
-    try {
-        c = new NativeExprCompiler(makeRustExprBackend(resolveHead, plan)).compilePort(node);
+function emitRustDecodeWireResult(comp, node, ref, plan, emitted, out) {
+    const top = recordTop(ref);
+    const fn = rustDecodeResultName(comp.name, node.id);
+    if (emitted.has(fn))
+        return fn;
+    emitted.add(fn);
+    const innerDecode = emitRustDecodeNamed(top.innerName, plan, emitted, out);
+    const resultType = renderTypeRef(ref);
+    const lines = [];
+    lines.push(`// ${fn} — decode the node's record-containing '${top.kind}' result from the wire (each record`);
+    lines.push(`// via ${innerDecode}); a de-box mismatch fails closed with the structured Error Value.`);
+    switch (top.kind) {
+        case "named":
+            lines.push(`fn ${fn}<W: WireRow>(wire: W) -> Result<${resultType}, BehaviorError> {`);
+            lines.push(`    ${innerDecode}(&wire)`);
+            break;
+        case "arr":
+            lines.push(`fn ${fn}<W: WireRow>(wire: Vec<W>) -> Result<${resultType}, BehaviorError> {`);
+            lines.push(`    let mut out = Vec::with_capacity(wire.len());`);
+            lines.push(`    for w in wire {`);
+            lines.push(`        out.push(${innerDecode}(&w)?);`);
+            lines.push(`    }`);
+            lines.push(`    Ok(out)`);
+            break;
+        case "opt":
+            lines.push(`fn ${fn}<W: WireRow>(wire: Option<W>) -> Result<${resultType}, BehaviorError> {`);
+            lines.push(`    match wire {`);
+            lines.push(`        Some(w) => Ok(Some(${innerDecode}(&w)?)),`);
+            lines.push(`        None => Ok(None),`);
+            lines.push(`    }`);
+            break;
+        case "map":
+            lines.push(`fn ${fn}<W: WireRow>(wire: std::collections::BTreeMap<String, W>) -> Result<${resultType}, BehaviorError> {`);
+            lines.push(`    let mut out = std::collections::BTreeMap::new();`);
+            lines.push(`    for (k, w) in wire {`);
+            lines.push(`        out.insert(k, ${innerDecode}(&w)?);`);
+            lines.push(`    }`);
+            lines.push(`    Ok(out)`);
+            break;
     }
-    catch (e) {
-        if (!(e instanceof GeneratorFailure))
-            throw e;
-        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust typed-native (runtime-free): ${where} ${JSON.stringify(node)} reads an OPTIONAL input port but does not lower to a native Rust value: ${e.message}`);
+    lines.push(`}`);
+    out.push(lines.join("\n"));
+    return fn;
+}
+function emitRustNodeDecodeFns(comp, typedNodes, plan, emitted, out) {
+    for (const n of comp.body) {
+        if ("cond" in n)
+            continue;
+        if ("map" in n || "fanout" in n) {
+            const node = n;
+            if (!mapFanoutElemDeBoxEligible(node, typedNodes, plan))
+                continue;
+            emitRustDecodeElemRow(comp, node, mapFanoutElemRef(node, typedNodes, plan), plan, emitted, out);
+            continue;
+        }
+        const ref = typedNodes.get(n.id);
+        if (ref === undefined)
+            continue;
+        const top = recordTop(ref);
+        if (top === null)
+            continue;
+        // a NAMED top decodes in place via decode_wire_<name>; an arr/opt/map top assembles via
+        // decode_wire_result_* (which recurses into decode_wire_<name> per record).
+        if (top.kind === "named")
+            emitRustDecodeNamed(top.innerName, plan, emitted, out);
+        else
+            emitRustDecodeWireResult(comp, n, ref, plan, emitted, out);
     }
-    if (c.stmts.length > 0)
-        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust typed-native (runtime-free): ${where} ${JSON.stringify(node)} reads an OPTIONAL input port through a FALLIBLE expression (one that can raise INT_OVERFLOW / NAN_OR_INF / MOD_ZERO / PRECISION_LOSS). Such an expression lowers to STATEMENTS carrying an early error-return, and a port is built inline in the ports-struct literal — a position that cannot host them. (A cond/guard position CAN host them, so the same expression is covered there — the boundary is the POSITION, not the operator.) Use a non-fallible port expression.`);
-    return c;
-}
-/** exprReadsOptionalInput — does this port expression reference an OPTIONAL (`required:false`) input
- * port? Language-neutral scan for `ref`/`refOpt` heads bound to an optional port. Decides ONLY which
- * lane a port takes; the lane itself then proves the lowering (or fails closed). */
-function exprReadsOptionalInput(node, inputPorts) {
-    if (node === null || typeof node !== "object")
-        return false;
-    if (Array.isArray(node))
-        return node.some((el) => exprReadsOptionalInput(el, inputPorts));
-    const rec = node;
-    const keys = Object.keys(rec);
-    if (keys.length === 1 && (keys[0] === "ref" || keys[0] === "refOpt")) {
-        const path = rec[keys[0]];
-        return Array.isArray(path) && typeof path[0] === "string" && inputPortIsOptional(inputPorts?.[path[0]]);
-    }
-    return keys.some((k) => exprReadsOptionalInput(rec[k], inputPorts));
-}
-/** portCompositeRef — the full TypeRef of a port that is a `{ref:[...]}` into a `$as` element field OR
- * an input port whose type is a MAP or NAMED struct (a non-scalar covered field). Returns null when the
- * node is not such a ref (so the caller falls through to the scalar/array inference). #108-map: enables a
- * `{map:V}`-typed field port (e.g. a nested map write port) to lower to the native BTreeMap. */
-function portCompositeRef(node, inputPorts, asBinding, plan) {
-    const e = classifyExpr(node);
-    if (e.kind !== "ref" || plan === undefined)
-        return null;
-    let ref = null;
-    if (asBinding !== undefined && e.path[0] === asBinding.name) {
-        try {
-            ref = typedFieldAccess(asBinding.name, asBinding.ref, e.path.slice(1), asBinding.plan).ref;
+}
+/** containsNamed — whether a TypeRef transitively contains a named record (through arr / opt / map). */
+function containsNamed(ref) {
+    switch (ref.kind) {
+        case "scalar":
+            return false;
+        case "named":
+            return true;
+        case "opt":
+            return containsNamed(ref.inner);
+        case "arr":
+            return containsNamed(ref.elem);
+        case "map":
+            return containsNamed(ref.value);
+    }
+}
+/**
+ * assertDeBoxableResults — fail closed (never a silent trust) for a covered node whose de-boxable result
+ * is a NON-named top (arr / opt / map) that transitively contains a record: the generated de-box decodes
+ * records only under a NAMED top (decode_wire_* / decode_wire_elem_*), so a record inside a non-named top
+ * would be materialized on the trusting `.val` path and silently default its wire fields. That is the
+ * silent-default red line forbids, so it is a loud generation-time error (native-codegen-standard
+ * §2). A NAMED top (de-boxed) or a pure-scalar non-named top (no records to de-box) is fine.
+ */
+/** readsAPriorNode — a componentRef node is a DATAFLOW consumer iff at least one input port is a ref
+ * headed by a PRIOR BODY NODE (it reads a prior node's already-native result, #129), rather than a fresh
+ * external wire read whose ports come from input params / static / an element ($as) binding. Same
+ * head-is-a-body-node signal priorNodeArrElemInfo (#129) uses to lower a prior-node array feed. */
+function readsAPriorNode(node, typedNodes) {
+    for (const expr of Object.values(node.ports ?? {})) {
+        const e = classifyExpr(expr);
+        if (e.kind === "ref" && e.path.length >= 1 && typedNodes.has(e.path[0]))
+            return true;
+    }
+    return false;
+}
+function assertDeBoxableResults(comp, typedNodes, plan) {
+    for (const n of comp.body) {
+        if ("cond" in n)
+            continue;
+        const isMapFanout = "map" in n || "fanout" in n;
+        const ref = isMapFanout ? mapFanoutElemRef(n, typedNodes, plan) : typedNodes.get(n.id);
+        const deBoxed = isMapFanout ? ref.kind === "named" : recordTop(ref) !== null;
+        if (deBoxed)
+            continue;
+        const nodeId = n.id;
+        if (containsNamed(ref)) {
+            throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust strict de-box: node '${nodeId}' shape ${JSON.stringify(ref)} contains a record the de-box does not decode (a deeper nesting than a direct named / arr / opt / map of a named record). It would trust the record's wire fields (silent default) — the silent-default red line forbids. Fail closed: reshape so the record is a direct de-box top, or extend the recursion for this nesting.`);
         }
-        catch {
-            return null;
+        // a map/fanout element is ALWAYS a per-element wire read; only a named record is de-boxed
+        // (decode_wire_elem_*). A scalar / scalar-collection element materializes from the trusting per-element
+        // path — a wrong wire value silent-defaults. Fail closed.
+        if (isMapFanout) {
+            throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust strict de-box: map/fanout node '${nodeId}' element ${JSON.stringify(ref)} is a scalar / scalar-collection per-element wire read that materializes on the trusting typed path — a wrong wire value would silent-default (diverging from run_behavior's outType check). Fail closed: declare the element as a record (de-boxed).`);
         }
-    }
-    else if (e.path.length >= 1) {
-        const s = inputPorts[e.path[0]];
-        // a whole-port ref to an input MAP port carrying an elemType → its BTreeMap type (mirrors
-        // inputPortRustType); a deeper path into an input port is not resolved here (no field type source).
-        if (s !== undefined && s.type === "map" && e.path.length === 1) {
-            const et = s.elemType;
-            if (et !== undefined)
-                return { kind: "map", value: deriveTypeRef(et, plan) };
+        // a pure-scalar / scalar-collection top on a HANDLER-BACKED componentRef wire read trusts the typed
+        // materialization (a wrong wire value silent-defaults). A DATAFLOW consumer (a port fed by a prior
+        // node) computes from already-native data and generates.
+        if (!readsAPriorNode(n, typedNodes)) {
+            throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust strict de-box: node '${nodeId}' result top ${JSON.stringify(ref)} is a handler-backed scalar / scalar-collection read that materializes on the trusting typed path — a wrong wire value would silent-default (diverging from run_behavior's outType check). Fail closed: declare the result as a record (de-boxed) or feed it as dataflow from a prior node.`);
         }
-        return null;
     }
-    if (ref === null)
-        return null;
-    // only MAP / NAMED composite fields here — scalars/arrays keep their existing dedicated paths.
-    if (ref.kind === "map" || ref.kind === "named")
-        return ref;
-    return null;
 }
-/** emitCompositePortValue — the OWNED native value expr for a port that is a ref to a `$as` element
- * MAP/NAMED field (or an input map port): a typed field access `.clone()` (the concrete BTreeMap/struct,
- * ZERO boxed Value). `elemBaseExpr` is the map arm's element base (`oel_<mapId>`) for a `$as`-headed ref;
- * omitted at the top level (only input-port composite refs resolve there). Returns null otherwise. */
-function emitCompositePortValue(node, inputPorts, asBinding, plan, elemBaseExpr) {
-    const e = classifyExpr(node);
-    if (e.kind !== "ref")
+function staticArrElems(node) {
+    if (node === null || typeof node !== "object" || Array.isArray(node))
         return null;
-    if (asBinding !== undefined && elemBaseExpr !== undefined && e.path[0] === asBinding.name) {
-        let acc;
-        try {
-            acc = typedFieldAccess(elemBaseExpr, asBinding.ref, e.path.slice(1), plan);
-        }
-        catch {
-            return null;
-        }
-        if (acc.ref.kind !== "map" && acc.ref.kind !== "named")
+    const keys = Object.keys(node);
+    if (keys.length !== 1 || keys[0] !== "arr")
+        return null;
+    const arg = node.arr;
+    return Array.isArray(arg) ? arg : null;
+}
+/**
+ * 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.
+/** rustOwn — the ownership renderer native-expr applies at a resolved ref LEAF: an array field is cloned
+ * (owned) when `ownArrays` (a port) or borrowed (a cond `len`); a Copy scalar behind a guard is deref'd
+ * (unless a field was already accessed by value); anything else clones. */
+function rustOwn(guard, ownArrays) {
+    return (expr, ref, fieldAccessed) => {
+        if (ref.kind === "arr")
+            return ownArrays ? `${expr}.clone()` : expr;
+        if (typeRefIsCopy(ref))
+            return guard && !fieldAccessed ? `*${expr}` : expr;
+        return `${expr}.clone()`;
+    };
+}
+/** nativeResolveHead — the ONE ref-head resolver the runtime-free native-expr compiler reads (cond `if`/
+ * branches, a map/fanout `when` guard, AND a port). A head is a `$as` element binding, a prior body node's
+ * typed cell (behind a RefCell borrow guard), or an input port (a by-value struct field). #139: the input
+ * ref comes from the inputPortTypeRef SSoT so an OPTIONAL port resolves as `{opt:…}` (native Option<T>). */
+function nativeResolveHead(comp, plan, typedNodes, isPrior, opts) {
+    const ownArrays = opts?.ownArrays === true;
+    return (head) => {
+        if (opts?.asBinding !== undefined && opts.asBase !== undefined && head === opts.asBinding.name) {
+            return { expr: opts.asBase, ref: opts.asBinding.ref, own: rustOwn(true, ownArrays) };
+        }
+        if (isPrior(head)) {
+            const ref = typedNodes.get(head);
+            return { expr: `${typedCell(head)}.borrow()`, ref, own: rustOwn(true, ownArrays) };
+        }
+        const ref = inputPortTypeRef(comp.inputPorts?.[head], plan);
+        if (ref === undefined)
             return null;
-        return `${acc.expr}.clone()`;
+        return { expr: `in_.${rustFieldName(head)}`, ref, own: rustOwn(false, ownArrays) };
+    };
+}
+/** compilePortNode — lower a port expression to its native ports-struct field via the runtime-free
+ * native-expr compiler: the ONE port lowering. The port's field TYPE is the compiled `ref`, its
+ * initializer the compiled `expr` — derived from a SINGLE lowering, so they cannot disagree. A port that
+ * cannot lower FAILS CLOSED; a FALLIBLE lowering (hoists statements) is returned as-is (only emitPortInit
+ * rejects it). Reuses the same nativeResolveHead cond/guard/port share, with `ownArrays` (a port owns). */
+function compilePortNode(node, comp, plan, typedNodes, isPrior, where, opts) {
+    const resolveHead = nativeResolveHead(comp, plan, typedNodes, isPrior, { ...opts, ownArrays: true });
+    try {
+        return new NativeExprCompiler(makeRustExprBackend(resolveHead, plan)).compilePort(node);
     }
-    // a WHOLE-port ref to an input MAP port (with elemType) — valid at top level OR inside a map node (a
-    // ref head that is NOT the `$as` element binding). Clones the native BTreeMap off the input struct.
-    if ((asBinding === undefined || e.path[0] !== asBinding.name) && e.path.length === 1) {
-        const s = inputPorts[e.path[0]];
-        if (s !== undefined && s.type === "map" && s.elemType !== undefined) {
-            return `in_.${rustFieldName(e.path[0])}.clone()`;
-        }
+    catch (e) {
+        if (!(e instanceof GeneratorFailure))
+            throw e;
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust typed-native (runtime-free): ${where} ${JSON.stringify(node)} does not lower to a native Rust value: ${e.message}`);
     }
-    return null;
+}
+/**
+ * portFieldRustType — the NATIVE Rust type for a covered port field, read off the ONE port lowering
+ * (compilePortNode / native-expr). Field type = the compiled TypeRef, so it can never disagree with the
+ * initializer (emitPortInit), which reads the SAME lowering for its value. `where` names the site.
+ */
+function portFieldRustType(node, comp, plan, typedNodes, where = "port", opts) {
+    const c = compilePortNode(node, comp, plan, typedNodes, (h) => typedNodes.has(h), where, opts);
+    return c.renderedType ?? renderTypeRef(c.ref);
 }
 /**
  * emitPortsStruct — the CONCRETE native ports struct for a componentRef node. Typed fields per the
@@ -336,7 +699,12 @@ function emitPortsStruct(comp, node, asBinding, plan, typedNodes) {
     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, plan, typedNodes));
+    // a node WITH ports always resolves through the one port lowering, which needs the type plan + the
+    // prior-node map (both are supplied by every caller — narrow the optional params for the fields below).
+    if (plan === undefined || typedNodes === undefined) {
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust typed-native: ports struct for node '${node.id}' needs a type plan + prior-node map`);
+    }
+    const types = portNames.map((p) => portFieldRustType(node.ports[p], comp, plan, typedNodes, `port '${p}' of node '${node.id}'`, asBinding !== undefined ? { asBinding, asBase: asBinding.name } : undefined));
     const fields = portNames
         .map((p, i) => `    pub ${portFieldName(p)}: ${types[i]}, // ${JSON.stringify(p)}`)
         .join("\n");
@@ -360,7 +728,7 @@ function emitMapPortsStructs(comp, node, typedNodes, plan) {
     // #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);
+    const elemStruct = emitPortsStruct(comp, { id: node.id, component: m.component, ports: m.ports }, asBinding, plan, typedNodes);
     return `${elemStruct}
 
 // ${batch} — CONCRETE batched ports for map '${node.id}': the Vec of per-element CONCRETE ports structs
@@ -378,7 +746,7 @@ function emitFanoutPortsStructs(comp, node, typedNodes, plan) {
     const batch = `${name}Batch`;
     const { elemRef } = fanoutOverElemInfo(comp, node, typedNodes, plan);
     const asBinding = { name: f.as, ref: elemRef, plan };
-    const elemStruct = emitPortsStruct(comp, { id: node.id, component: f.component, ports: f.ports }, asBinding, plan);
+    const elemStruct = emitPortsStruct(comp, { id: node.id, component: f.component, ports: f.ports }, asBinding, plan, typedNodes);
     return `${elemStruct}
 
 // ${batch} — CONCRETE batched ports for fanout '${node.id}': the Vec of per-id CONCRETE ports structs.
@@ -398,6 +766,20 @@ 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 };
+/** rustBlockBody — the body of a block-expression that runs `stmts` then yields `expr`. A trailing
+ * `let t = E; t` collapses to `E` (clippy `let_and_return`). */
+function rustBlockBody(stmts, expr) {
+    const last = stmts[stmts.length - 1];
+    const m = last !== undefined ? /^let\s+([A-Za-z0-9_]+)(?::\s*[^=]+)?\s*=\s*(.+);$/.exec(last) : null;
+    if (m !== null && m[1] === expr)
+        return [...stmts.slice(0, -1), m[2]].join(" ");
+    return [...stmts, rustStripOuterParens(expr)].join(" ");
+}
+/** Drop a TRAILING `.clone()` — for a position that only reads the value (a presence test), so an owning
+ * clone added by a head resolver is pure waste. Only a clone at the very END is dropped. */
+function rustStripTrailingClone(expr) {
+    return expr.endsWith(".clone()") ? expr.slice(0, -".clone()".length) : expr;
+}
 /** 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 `?`. */
@@ -441,44 +823,39 @@ function makeRustExprBackend(resolveHead, plan) {
         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 }`,
-        // an opt (`Option<T>`) NONE literal. Annotate as `Option::<T>::None` so it type-infers in ANY
-        // position (a bare `None` can be ambiguous; the explicit turbofish keeps it a fully-typed value).
-        optNone: (innerTy) => `Option::<${innerTy}>::None`,
-        // opt (`Option<T>`) null-presence test: present = `expr.is_some()`, absent = `expr.is_none()`.
-        // A presence test only READS the discriminant, so an owning clone of the operand (which a head
-        // resolver adds so the value can be moved into a port) is dropped here — testing `Option<String>`
-        // must not heap-allocate. Mirrors the go twin's zero-cost `!= nil`.
-        optIsSome: (expr) => `${rustStripTrailingClone(expr)}.is_some()`,
-        optIsNone: (expr) => `${rustStripTrailingClone(expr)}.is_none()`,
-        // opt (`Option<T>`) defaulted to a PURE default — it cannot fail and has no effect, so its
-        // evaluation order is UNOBSERVABLE and both forms below are correct (a FALLIBLE default, where
-        // laziness IS observable, goes to optCoalesceGuard instead). `unwrap_or` is EAGER — fine for a plain
-        // literal/copy. A default that allocates (an owned `String`, a struct/vec literal) uses
-        // `unwrap_or_else`, whose closure defers the allocation to the absent branch: not a semantic
-        // requirement here, but pointless work otherwise — and what clippy `or_fun_call` asks for.
+        // a projection port of static string literals — `vec!["a", "b"]` infers `&'static str` (the field is
+        // Vec<&'static str>), ZERO heap allocation.
+        staticStrArr: (literals) => ({ expr: `vec![${literals.map((s) => rustStrLit(s)).join(", ")}]`, type: "Vec<&'static str>" }),
+        // opt (Option<T>) defaulted to a PURE default — eager unwrap_or for a plain copy/path, else the lazy
+        // unwrap_or_else closure (defers an allocating default to the absent branch; clippy or_fun_call).
         optUnwrapOr: (optExpr, defaultExpr, _innerTy) => /^[A-Za-z0-9_.:]+$/.test(defaultExpr) ? `${optExpr}.unwrap_or(${defaultExpr})` : `${optExpr}.unwrap_or_else(|| ${defaultExpr})`,
         // opt defaulted to a FALLIBLE default — a `match`, NOT a closure: the default's hoisted `?` early
-        // returns must propagate out of the ENCLOSING fn, which `unwrap_or_else`'s closure would swallow
-        // (it would try to return from the closure). Only the None arm evaluates the default.
+        // returns must propagate out of the ENCLOSING fn. Only the None arm evaluates the default.
         optCoalesceGuard: (temp, ty, optExpr, bindTemp, dStmts, dExpr) => [
             `let ${temp}: ${ty} = match ${optExpr} {`,
             `    Some(${bindTemp}) => ${bindTemp},`,
             `    None => { ${rustBlockBody(dStmts, dExpr)} }`,
             `};`,
         ],
+        // an opt (`Option<T>`) NONE literal. Annotate as `Option::<T>::None` so it type-infers in ANY
+        // position (a bare `None` can be ambiguous; the explicit turbofish keeps it a fully-typed value).
+        optNone: (innerTy) => `Option::<${innerTy}>::None`,
+        // opt (`Option<T>`) null-presence test: present = `expr.is_some()`, absent = `expr.is_none()`.
+        optIsSome: (expr) => `${rustStripTrailingClone(expr)}.is_some()`,
+        optIsNone: (expr) => `${rustStripTrailingClone(expr)}.is_none()`,
         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 = `{ ${rustBlockBody(rStmts, rExpr)} }`;
+            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 = `{ ${rustBlockBody(tStmts, tExpr)} }`;
-            const eblock = `{ ${rustBlockBody(eStmts, eExpr)} }`;
+            const tblock = `{ ${tStmts.join(" ")} ${rustStripOuterParens(tExpr)} }`;
+            const eblock = `{ ${eStmts.join(" ")} ${rustStripOuterParens(eExpr)} }`;
             return [`let ${temp}: ${ty} = if ${rustStripOuterParens(cond)} ${tblock} else ${eblock};`];
         },
     };
@@ -487,17 +864,6 @@ function makeRustExprBackend(resolveHead, plan) {
 function rustSnake(name) {
     return name.replace(/([a-z])([A-Z0-9])/g, "$1_$2").replace(/([0-9])([a-z])/g, "$1_$2").toLowerCase();
 }
-/** rustBlockBody — the body of a block-expression that runs `stmts` then yields `expr`. A trailing
- * `let t = E; t` is collapsed to `E`: binding a temp only to return it on the next line is clippy's
- * `let_and_return` (an error under `-D warnings`), and the hoisted-fallible shape produces exactly that
- * whenever the block's tail IS the hoisted temp. */
-function rustBlockBody(stmts, expr) {
-    const last = stmts[stmts.length - 1];
-    const m = last !== undefined ? /^let\s+([A-Za-z0-9_]+)(?::\s*[^=]+)?\s*=\s*(.+);$/.exec(last) : null;
-    if (m !== null && m[1] === expr)
-        return [...stmts.slice(0, -1), m[2]].join(" ");
-    return [...stmts, rustStripOuterParens(expr)].join(" ");
-}
 /** 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) {
@@ -515,12 +881,6 @@ function rustStripOuterParens(expr) {
     }
     return expr.slice(1, -1);
 }
-/** Drop a TRAILING `.clone()` from an expression — for a position that only reads the value (no move),
- * so an owning clone added by a head resolver is pure waste. Only a clone at the very END is dropped: a
- * `.clone()` mid-path (`t_x.borrow().clone().field`) still owns the field access that follows it. */
-function rustStripTrailingClone(expr) {
-    return expr.endsWith(".clone()") ? expr.slice(0, -".clone()".length) : expr;
-}
 /** Rust float literal (finite; integral gets `.0`). */
 function rustFloatLitExpr(n) {
     if (Number.isInteger(n))
@@ -614,13 +974,14 @@ fn bc_expr_str_ge(a: &str, b: &str) -> bool { bc_expr_cmp_cp(a, b) != std::cmp::
 // ── 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
+// outType fields (typed, flattened). A row models a SUCCESS: failure travels the Result's Err arm as a
+// concrete BehaviorError carrying the leaf's structured Error Value. 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). */
+ * `RawElemNR<Comp><Node>` for a covered map). A row models a SUCCESS; failure is the Result's Err arm. */
 function emitRawRowStructs(comp, typedNodes, plan) {
     const parts = [];
     for (const n of comp.body) {
@@ -631,7 +992,7 @@ function emitRawRowStructs(comp, typedNodes, plan) {
             const elemRowRef = fanoutItemsElemRef(n, ref, plan);
             parts.push(emitOneRowStruct(rawElemStructName(comp.name, n.id), elemRowRef, plan));
             parts.push(`// ${rawRowStructName(comp.name, n.id)} — the BATCH row for fanout '${n.id}': the aligned per-body 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}`);
+                `#[derive(Default)]\npub struct ${rawRowStructName(comp.name, n.id)} {\n    pub rows: Vec<${rawElemStructName(comp.name, n.id)}>,\n}`);
             continue;
         }
         if ("map" in n) {
@@ -639,22 +1000,20 @@ function emitRawRowStructs(comp, typedNodes, plan) {
             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}`);
+                `#[derive(Default)]\npub struct ${rawRowStructName(comp.name, n.id)} {\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`). */
+/** Emit one concrete row struct: flatten a named outType to typed fields, else a single `val` payload.
+ * A row models a SUCCESS — failure is the Result's Err arm, so no in-band error signal. */
 function emitOneRowStruct(name, ref, plan) {
     const lines = [];
-    lines.push(`// ${name} — CONCRETE handler-result row (typed fields = the node's outType; + error signal).`);
+    lines.push(`// ${name} — CONCRETE handler-result row (typed fields = the node's outType).`);
     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) {
@@ -729,6 +1088,19 @@ function emitHandlerTrait(comp, typedNodes, plan, ap) {
     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)} {`);
+    // a record-read node returns the consumer's WIRE (an associated `Wire: WireRow`); the generated
+    // decode turns it into the concrete row. Declared once when the component has a de-box-eligible node.
+    // The `+ Send` bound lets the wire cross the parallel-stage runner's scoped fan-out threads (the old
+    // concrete row was Send; the associated type needs the bound stated explicitly).
+    const hasDeBox = comp.body.some((n) => {
+        if ("cond" in n)
+            return false;
+        if ("map" in n || "fanout" in n)
+            return mapFanoutElemDeBoxEligible(n, typedNodes, plan);
+        return deBoxEligible(typedNodes.get(n.id));
+    });
+    if (hasDeBox)
+        lines.push(`    type Wire: WireRow + Send;`);
     for (const n of comp.body) {
         if ("cond" in n)
             continue; // #108: a cond node has no handler method (pure Expression).
@@ -736,21 +1108,29 @@ function emitHandlerTrait(comp, typedNodes, plan, ap) {
         const fnKw = fnKwFor(n.id);
         const bt = boundRustType(n, typedNodes, plan);
         if ("fanout" in n) {
-            // fanout (v3): one batched dispatch of the deduped id list — batch ports IN, aligned batch row OUT.
+            // fanout (v3): one batched dispatch of the deduped id list. A record element returns the aligned
+            // element WIRES the runner de-boxes (decode_wire_elem_*) then dedupe/drops. Each aligned position is
+            // Option<Self::Wire> — None = a DANGLING id (the runner maps it to the zero elem row).
             const portsT = `${portsStructName(comp.name, n.id)}Batch`;
-            const retT = rawRowStructName(comp.name, n.id);
-            lines.push(`    ${fnKw} ${method}(&self, ports: &${portsT}, bound: ${bt}) -> Option<${retT}>;`);
+            const elemDeBox = mapFanoutElemDeBoxEligible(n, typedNodes, plan);
+            const retT = elemDeBox ? "Vec<Option<Self::Wire>>" : rawRowStructName(comp.name, n.id);
+            lines.push(`    ${fnKw} ${method}(&self, ports: &${portsT}, bound: ${bt}) -> Result<${retT}, BehaviorError>;`);
             continue;
         }
         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}>;`);
+            // a record-element map returns the element WIRE(s): batched → Vec<Self::Wire>, nonbatched → Self::Wire.
+            const elemDeBox = mapFanoutElemDeBoxEligible(n, typedNodes, plan);
+            const retT = elemDeBox ? (batched ? "Vec<Self::Wire>" : "Self::Wire") : batched ? rawRowStructName(comp.name, n.id) : rawElemStructName(comp.name, n.id);
+            lines.push(`    ${fnKw} ${method}(&self, ports: &${portsT}, bound: ${bt}) -> Result<${retT}, BehaviorError>;`);
             continue;
         }
-        lines.push(`    ${fnKw} ${method}(&self, ports: &${portsStructName(comp.name, n.id)}, bound: ${bt}) -> Option<${rawRowStructName(comp.name, n.id)}>;`);
+        const ref = typedNodes.get(n.id);
+        const top = ref !== undefined ? recordTop(ref) : null;
+        const retT = top !== null ? rustWireTypeForTop(top) : rawRowStructName(comp.name, n.id);
+        lines.push(`    ${fnKw} ${method}(&self, ports: &${portsStructName(comp.name, n.id)}, bound: ${bt}) -> Result<${retT}, BehaviorError>;`);
     }
     lines.push(`}`);
     return lines.join("\n");
@@ -763,18 +1143,16 @@ function emitHandlerTrait(comp, typedNodes, plan, ap) {
 function mapElemMaterializerName(compName, nodeId) {
     return `materialize_map_elem_${sanitize(compName)}_${typedCell(nodeId)}`;
 }
-/** mapNodeArrRef — the map node's PRODUCED-ARRAY TypeRef from its `outType`, normalizing the two IR
- * conventions to the one array shape every downstream site assumes (`typedNodes.get(mapId)` is an arr):
- *   - the RECORDER SoT (authoring.ts recordMap): `node.outType` is the ELEMENT (pre-array-wrap) — wrap
- *     it to `{arr:element}` here (the map produces `[]element`), matching type-gate's outputType wrap
- *     (`"map" in n ? {arr:ot} : ot`). This is the declarative-authoring form (graphddb batchWrite/forEach).
- *   - legacy hand-built IR: `node.outType` is already the `{arr:element}` produced form — take it as-is.
- * A map ELEMENT is never itself an `{arr:…}` in the covered corpus, so the `arr`-keyed discriminator is
- * unambiguous. Both converge to the SAME produced-array ref, so existing goldens stay byte-identical. */
+/** mapNodeArrRef — the map node's PRODUCED-ARRAY TypeRef from its `outType`.
+ *
+ * A map node's `outType` is its ELEMENT type (scp-error.md "Map element type"), so the produced array
+ * is `{arr: element}`. This is the same reading the compiler applies when it resolves what a node
+ * result reference has (`type-gate`: `"map" in n ? {arr:ot} : ot`) — the emitter follows that SSoT
+ * rather than inspecting the annotation's shape, so an element that is ITSELF an `arr` stays
+ * expressible (element `arr(T)` produces `arr(arr(T))`). */
 function mapNodeArrRef(node, plan) {
     const outT = node.outType;
-    const isArr = outT !== null && typeof outT === "object" && "arr" in outT;
-    return deriveTypeRef((isArr ? outT : { arr: outT }), plan);
+    return deriveTypeRef({ arr: outT }, plan);
 }
 /** 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>. */
@@ -869,44 +1247,6 @@ function mapOverElemInfo(comp, node, typedNodes, plan) {
 function mapOverElemType(comp, node, typedNodes, plan) {
     return renderTypeRef(mapOverElemInfo(comp, node, typedNodes, plan).elemRef);
 }
-/**
- * priorNodeArrElemInfo (#129, rust twin) — resolve a leaf port that is a `ref` into a PRIOR BODY NODE
- * whose annotated `outType` is (or reaches, through a field path) a native array, to its element TypeRef
- * + the OWNED Rust Vec expression that yields it. GENERALIZES the `map…over` prior-node-arr dataflow
- * (mapOverElemInfo's first branch) to ANY leaf input port: a fold/dedup leaf whose `items` port is
- * `{ref:["<priorNode>"]}` (or `.items` of a prior connection node) now lowers to `Vec<ElemT>` cloned
- * out of the prior node's typed cell — ZERO boxed Value on the read hot path.
- *
- * The element type comes STRICTLY from the prior node's EXPLICIT `outType` annotation walked through
- * typedFieldAccess (BC does NOT infer — consumer-interface C3 / [[graphddb-typed-native-static-link]]):
- * if the head is not a prior body node, or its outType (through the field path) is not an `arr`, this
- * returns null and the caller keeps its existing fail-closed behaviour (never a silent box). A
- * single-segment INPUT-array port (elemType) is a DIFFERENT covered shape (portArrayElemRef) — handled
- * ahead of this. Requires the typedNodes map (prior-node outType TypeRefs) and a TypePlan.
- */
-function priorNodeArrElemInfo(node, typedNodes, plan) {
-    if (typedNodes === undefined || plan === undefined)
-        return null;
-    if (staticArrElems(node) !== null)
-        return null; // a static array literal — not a prior-node ref.
-    const e = classifyExpr(node);
-    if (e.kind !== "ref" || e.opt || e.path.length < 1)
-        return null;
-    if (!typedNodes.has(e.path[0]))
-        return null; // head is not a prior body node → not this shape.
-    const baseRef = typedNodes.get(e.path[0]);
-    let acc;
-    try {
-        acc = typedFieldAccess(`${typedCell(e.path[0])}.borrow()`, baseRef, e.path.slice(1), plan);
-    }
-    catch {
-        return null; // the field path does not resolve on the prior node's outType → fail-closed at caller.
-    }
-    if (acc.ref.kind !== "arr")
-        return null; // the prior-node result (through the path) is not an array.
-    // OWNED: clone the borrowed slice out of the RefCell so the ports struct owns its Vec<ElemT>.
-    return { elemRef: acc.ref.elem, overExpr: `${acc.expr}.clone()` };
-}
 // ── eligibility ─────────────────────────────────────────────────────────────────────
 function reconstructR(e) {
     switch (e.kind) {
@@ -947,31 +1287,46 @@ function numLiteralRustExpr(node) {
     // 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 / an
- * optional-input read) — resolvable to a native value with no Obj / no evaluate interpreter. This is the
- * SHAPE gate that decides native ELIGIBILITY; the lowering itself (portFieldRustType / emitPortInit) is
- * what proves each shape, and fails closed loudly on one it cannot lower. */
-function portIsStatic(node, inputPorts) {
-    const arr = staticArrElems(node);
-    if (arr !== null)
-        return arr.every((el) => portIsStatic(el, inputPorts));
-    if (numLiteralRustExpr(node) !== null)
-        return true; // bare number literal (e.g. Query `limit`)
-    // An optional-input read (`opt($.x)` / `coalesce(opt($.x), 20)` / `ne(opt($.x), null)`) is a
-    // statically-resolvable port — the opt lane lowers it (or fails closed with the specific reason).
-    if (inputPorts !== undefined && exprReadsOptionalInput(node, inputPorts))
+/** 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. */
+/** planForComp — a TypePlan for a single component (its named types are component-scoped). */
+function planForComp(comp) {
+    return buildTypePlan({ irVersion: 1, exprVersion: 2, components: [comp] });
+}
+/** buildTypedNodes — the prior-node typed-cell TypeRef map (control-gate nodes typeless; a map node
+ * carries its produced-array ref). An untyped node is omitted. */
+function buildTypedNodes(comp, plan) {
+    const typedNodes = new Map();
+    for (const n of comp.body) {
+        if (isControlGate(n))
+            continue;
+        try {
+            typedNodes.set(n.id, "map" in n ? mapNodeArrRef(n, plan) : deriveTypeRef(n.outType, plan));
+        }
+        catch {
+            /* untyped node — omit */
+        }
+    }
+    return typedNodes;
+}
+/** mapAsBinding — the `$as` element binding for a map node's element ports, or undefined (uncovered). */
+function mapAsBinding(comp, node, typedNodes, plan) {
+    try {
+        return { name: node.map.as, ref: mapOverElemInfo(comp, node, typedNodes, plan).elemRef, plan };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** portIsStatic — the ELIGIBILITY gate ASKS the one port lowering (compilePortNode / native-expr) whether
+ * it can lower this port. A port that does not lower (or lowers fallibly) fails closed. */
+function portIsStatic(node, comp, plan, typedNodes, asBinding) {
+    try {
+        compilePortNode(node, comp, plan, typedNodes, (h) => typedNodes.has(h), "port", asBinding !== undefined ? { asBinding, asBase: asBinding.name } : undefined);
         return true;
-    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), inputPorts));
-        default:
-            return false;
+    }
+    catch {
+        return false;
     }
 }
 /** The output must lower to a typed struct/value with no scope read: a ref to a BODY NODE, an
@@ -1037,8 +1392,11 @@ function coveredMapNode(n, bodyIds, comp) {
             return false;
     }
     const ports = m.ports;
+    const plan = planForComp(comp);
+    const typedNodes = buildTypedNodes(comp, plan);
+    const asBinding = mapAsBinding(comp, n, typedNodes, plan);
     for (const p of Object.keys(ports))
-        if (!portIsStatic(ports[p], comp.inputPorts))
+        if (!portIsStatic(ports[p], comp, plan, typedNodes, asBinding))
             return false;
     return true;
 }
@@ -1064,8 +1422,17 @@ function coveredFanoutNode(n, bodyIds, comp) {
             return false;
     }
     const ports = f.ports;
+    const plan = planForComp(comp);
+    const typedNodes = buildTypedNodes(comp, plan);
+    let asBinding;
+    try {
+        asBinding = { name: f.as, ref: fanoutOverElemInfo(comp, n, typedNodes, plan).elemRef, plan };
+    }
+    catch {
+        asBinding = undefined;
+    }
     for (const p of Object.keys(ports))
-        if (!portIsStatic(ports[p], comp.inputPorts))
+        if (!portIsStatic(ports[p], comp, plan, typedNodes, asBinding))
             return false;
     return true;
 }
@@ -1112,6 +1479,8 @@ function isSequentialComponentRefRead(comp) {
  * can never disagree. This is the message the fail-closed dispatch surfaces per non-native component.
  */
 function coverageRejectReason(comp) {
+    const crPlan = planForComp(comp);
+    const crTypedNodes = buildTypedNodes(comp, crPlan);
     const ep = execPlan(comp);
     if (ep === null)
         return "component is not a straight-line/staged sequential exec plan (no static exec plan)";
@@ -1176,7 +1545,7 @@ function coverageRejectReason(comp) {
         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], comp.inputPorts) === false)
+            if (portIsStatic(cr.ports[p], comp, crPlan, crTypedNodes) === false)
                 return `node '${n.id}' port '${p}' is not statically resolvable`;
     }
     if (!outputIsNativeLowerable(comp))
@@ -1204,31 +1573,17 @@ 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 ────────────────────────────
-/**
- * inputPortRustType — the native Rust type for an input port's declared type. Scalars lower to the
- * concrete scalar; `array`/`map` with a declared elemType to `Vec<ElemT>` / `BTreeMap<String, ElemT>`;
- * an OPTIONAL port (`{opt:T}` → `required:false`) to `Option<T>` — the native representation of "the
- * value is absent". A declared type with no native lowering stays the boxed `Value`.
- *
- * An OPTIONAL port whose inner type has no native lowering FAILS CLOSED: `Option<Value>` would be a
- * boxed escape, and emitting the bare inner type would silently turn "absent" into a zero value. A port
- * whose optionality cannot be represented is never silently coerced.
- */
+/** Rust type for an input port's declared type (scalar → concrete; array+elemType → Vec<ElemT>; else Value). */
 function inputPortRustType(schema, plan, where = "input port") {
     const ref = inputPortTypeRef(schema, plan);
     if (ref !== undefined)
         return renderTypeRef(ref);
     if (inputPortIsOptional(schema))
-        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust typed-native (runtime-free): ${where} is OPTIONAL (declared {opt:…}) but its inner type ${JSON.stringify(schema?.type)} has no native Rust lowering, so "absent" has no native representation (an Option<Value> would be a boxed escape, and the bare inner type would silently read absent as a zero value). Declare an elemType for an array/map, or use a natively-lowerable scalar.`);
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust typed-native (runtime-free): ${where} is OPTIONAL (declared {opt:…}) but its inner type ${JSON.stringify(schema?.type)} has no native Rust lowering, so "absent" has no native representation. Declare an elemType for an array/map, or use a natively-lowerable scalar.`);
     return "Value";
 }
-/** The scalar kind a REQUIRED input port declares, or undefined when it is not a required native scalar.
- * An OPTIONAL port is deliberately NOT a scalar kind here: its native type is `Option<T>`, and the
- * callers of this function build REQUIRED scalar slots (`in_.<field>` read straight into a non-opt port
- * field). Answering "i64" for an `{opt:"int"}` port is exactly how "absent" would silently become `0`. */
+/** The scalar kind an input port declares, or undefined if it is not a native scalar. */
 function inputScalarKind(schema) {
-    if (inputPortIsOptional(schema))
-        return undefined;
     switch (schema?.type) {
         case "string":
         case "literal": // a `"literal"` union is a constrained String (see inputPortRustType).
@@ -1252,6 +1607,8 @@ function emitInStruct(comp, plan) {
     if (ports.length === 0) {
         return `// ${name} — the CONCRETE input for '${comp.name}' (no input ports).\n#[derive(Default)]\npub struct ${name};`;
     }
+    // #139: inputPortRustType reads the inputPortTypeRef SSoT — an OPTIONAL port is `Option<T>` (absent →
+    // None); an optional whose inner type has no native lowering FAILS CLOSED (never a boxed escape).
     const fields = ports
         .map((p) => `    pub ${rustFieldName(p)}: ${inputPortRustType(comp.inputPorts[p], plan, `input port '${p}' of component '${comp.name}'`)}, // ${JSON.stringify(p)}`)
         .join("\n");
@@ -1262,64 +1619,10 @@ pub struct ${name} {
 ${fields}
 }`;
 }
-/** The port forms the STATIC (non-optional) lane lowers — named in its reject message so the message
- * describes what is actually covered rather than a stale corpus list. */
-const RUST_STATIC_PORT_FORMS = "This port does not read an optional input, so it lowers through the STATIC port forms: a string / bool / number literal, a static string-array (projection), a ref to a REQUIRED scalar input port, a ref to an input array/map port or a prior node's array (declared elemType), a ref to a `$as` element field, or a concat of native strings. A dynamic operator at port position is not covered on this lane. (A port that DOES read an optional input lowers through the full native expression compiler, which admits the whole closed operator set — so the covered operator set at port position currently depends on the lane, not on the operator.)";
-/**
- * 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;
-    }
-}
+/** A ref resolver for native lowering: given a ref head + remaining field path, return a native scalar
+ * Rust expression (typed input field / prior-node typed struct scalar / element binding field), or null
+ * when the ref does not resolve to a REQUIRED (non-opt) native scalar (then the caller falls back to the
+ * Value path). Returned exprs are OWNED (String cloned / scalar copied) — usable in a `format!` / literal. */
 // 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 /
@@ -1336,100 +1639,13 @@ 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, inputPorts, plan, typedNodes, asBinding, elemBaseExpr) {
-    const field = portFieldName(pn);
-    // The OPTIONAL-input lane (Option<T> pass-through / coalesce default) — same shared compile as
-    // portFieldRustType, so the field type and its initializer are derived from ONE lowering.
-    const optPort = optPortCompileR(expr, inputPorts ?? {}, `port '${pn}'`, plan);
-    if (optPort !== null)
-        return `${field}: ${optPort.expr}`;
-    // #108-map: a port that is a ref to a `$as` element MAP/NAMED field (or an input map port) → CLONE the
-    // typed composite value directly off the element/input (native BTreeMap / struct — ZERO boxed Value).
-    // Reuses portCompositeRef for the type; the value is the typed field access `.clone()`.
-    if (plan !== undefined) {
-        const compExpr = emitCompositePortValue(expr, inputPorts ?? {}, asBinding, plan, elemBaseExpr);
-        if (compExpr !== null)
-            return `${field}: ${compExpr}`;
-    }
-    // #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()`;
-        }
-    }
-    // #129: a leaf port that is a ref into a PRIOR NODE's typed arr outType (node→leaf array dataflow) →
-    // the native Vec<ElemT> cloned off the prior node's typed cell (`t_<node>.borrow().field….clone()`) —
-    // ZERO boxed Value on the read hot path (a fold/dedup leaf whose `items` = a prior node's array result).
-    const priorArr = priorNodeArrElemInfo(expr, typedNodes, plan);
-    if (priorArr !== null)
-        return `${field}: ${priorArr.overExpr}`;
-    // 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. ${RUST_STATIC_PORT_FORMS} Regenerate on the boxed straight-line path if this port is genuinely dynamic.`);
+function emitPortInit(pn, expr, comp, plan, typedNodes, isPrior, opts) {
+    const c = compilePortNode(expr, comp, plan, typedNodes, isPrior, `port '${pn}'`, opts);
+    if (c.stmts.length > 0)
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust typed-native (runtime-free): port '${pn}' ${JSON.stringify(expr)} lowers to a FALLIBLE expression (INT_OVERFLOW / NAN_OR_INF / MOD_ZERO / PRECISION_LOSS) — statements with an early error-return, which a ports-struct literal cannot host. Use a non-fallible port expression.`);
+    return `${portFieldName(pn)}: ${c.expr}`;
 }
 // ── 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";
 }
@@ -1621,12 +1837,9 @@ function emitNativeRawRunner(comp, plan, ap) {
                 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}'`, undefined, plan, typedNodes);
-            inits.push(emitPortInit(pn, expr, ty, resolveRef, comp.inputPorts, plan, typedNodes));
+            inits.push(emitPortInit(pn, node.ports[pn], comp, plan, typedNodes, (h) => priorNodeAt(h, k)));
         }
         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
@@ -1634,22 +1847,57 @@ function emitNativeRawRunner(comp, plan, ap) {
         // 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}};`);
+        // a de-box-eligible node returns the wire (Self::Wire / Vec / Option / BTreeMap); the generated
+        // decode_wire_result_* probes each record strictly and produces the structured error on a mismatch
+        // (byte-equal codes to run_behavior's outType check, so ≡ holds). A non-de-box node keeps its direct
+        // concrete-row move.
+        const top = recordTop(ref);
+        const namedTop = top !== null && top.kind === "named";
+        const deBox = top !== null;
         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}}`);
+            // continue: a failed node (leaf failure OR de-box mismatch) produces no Port — the downstream
+            // Skip propagation is what `continue` means. Only a clean decode commits the result.
+            if (namedTop) {
+                lines.push(`${indent}if let Ok(wire_${s}) = handlers.${nodeMethodName(node.id)}(&ports_${s}, ${boundArg})${awaitSfx} {`);
+                lines.push(`${indent}    if let Ok(row_${s}) = ${rustDecodeNamedName(top.innerName)}(&wire_${s}) {`);
+                lines.push(`${indent}        ${emitRowMove(`*${typedCell(node.id)}.borrow_mut()`, `row_${s}`, ref, plan)}`);
+                lines.push(`${indent}        produced_${s}.set(true);`);
+                lines.push(`${indent}    }`);
+                lines.push(`${indent}}`);
+            }
+            else if (deBox) {
+                lines.push(`${indent}if let Ok(wire_${s}) = handlers.${nodeMethodName(node.id)}(&ports_${s}, ${boundArg})${awaitSfx} {`);
+                lines.push(`${indent}    if let Ok(res_${s}) = ${rustDecodeResultName(comp.name, node.id)}(wire_${s}) {`);
+                lines.push(`${indent}        *${typedCell(node.id)}.borrow_mut() = res_${s};`);
+                lines.push(`${indent}        produced_${s}.set(true);`);
+                lines.push(`${indent}    }`);
+                lines.push(`${indent}}`);
+            }
+            else {
+                lines.push(`${indent}if let Ok(row_${s}) = handlers.${nodeMethodName(node.id)}(&ports_${s}, ${boundArg})${awaitSfx} {`);
+                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)}`);
+            const policyLit = meta.policy === "retry" ? "retry' policy (exhausted)" : "fail' policy";
+            const resultVar = deBox ? `wire_${s}` : `row_${s}`;
+            lines.push(`${indent}let ${resultVar} = match handlers.${nodeMethodName(node.id)}(&ports_${s}, ${boundArg})${awaitSfx} {`);
+            lines.push(`${indent}    Ok(r) => r,`);
+            lines.push(`${indent}    Err(e) => return Err(BehaviorError { code: "OP_FAILED".to_string(), message: format!("operation '{}' failed under '${policyLit}: {}", ${rustStrLit(node.id)}, e.message), detail: e.detail }),`);
+            lines.push(`${indent}};`);
+            if (namedTop) {
+                lines.push(`${indent}let row_${s} = ${rustDecodeNamedName(top.innerName)}(&wire_${s})?;`);
+                lines.push(`${indent}${emitRowMove(`*${typedCell(node.id)}.borrow_mut()`, `row_${s}`, ref, plan)}`);
+            }
+            else if (deBox) {
+                lines.push(`${indent}let res_${s} = ${rustDecodeResultName(comp.name, node.id)}(wire_${s})?;`);
+                lines.push(`${indent}*${typedCell(node.id)}.borrow_mut() = res_${s};`);
+            }
+            else {
+                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)
@@ -1754,12 +2002,9 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
                 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}'`, undefined, plan, typedNodes);
-            inits.push(emitPortInit(pn, expr, ty, resolveRef, comp.inputPorts, plan, typedNodes));
+            inits.push(emitPortInit(pn, node.ports[pn], comp, plan, typedNodes, (h) => priorNodeAt(h, atPos)));
         }
         if (gated) {
             lines.push(`${ind}ports_${s} = Some(${structName} { ${inits.join(", ")} });`);
@@ -1777,10 +2022,26 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
     const nMembers = refMembers.length;
     const boundN = Math.min(concurrency, nMembers);
     const jobsVar = `jobs_${sanitize(comp.name)}`;
+    const hWire = `<H as ${handlerTraitName(comp.name)}>::Wire`;
+    const hWireTop = (top) => {
+        switch (top.kind) {
+            case "named":
+                return hWire;
+            case "arr":
+                return `Vec<${hWire}>`;
+            case "opt":
+                return `Option<${hWire}>`;
+            case "map":
+                return `std::collections::BTreeMap<String, ${hWire}>`;
+        }
+    };
     for (const i of refMembers) {
         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);`);
+        // a de-box member's thread returns the WIRE (shaped by the record top); a non-de-box member returns
+        // its concrete row directly.
+        const memTop = recordTop(typedNodes.get(comp.body[i].id));
+        const slotT = memTop !== null ? hWireTop(memTop) : rawRowStructName(comp.name, comp.body[i].id);
+        lines.push(`        let slot_${s}: std::sync::Mutex<Option<Result<${slotT}, BehaviorError>>> = std::sync::Mutex::new(None);`);
     }
     lines.push(`        let mut ${jobsVar}: Vec<usize> = Vec::new();`);
     refMembers.forEach((i, slot) => {
@@ -1818,22 +2079,52 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
         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(`            };`);
+        lines.push(`            let out_${s} = slot_${s}.lock().unwrap().take().expect("runnable member wrote its slot");`);
+        const top = recordTop(ref);
+        const namedTop = top !== null && top.kind === "named";
+        const deBox = top !== null;
         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(`            }`);
+            if (namedTop) {
+                lines.push(`            if let Ok(wire_${s}) = out_${s} {`);
+                lines.push(`                if let Ok(row_${s}) = ${rustDecodeNamedName(top.innerName)}(&wire_${s}) {`);
+                lines.push(`                    ${emitRowMove(`*${typedCell(node.id)}.borrow_mut()`, `row_${s}`, ref, plan)}`);
+                lines.push(`                    produced_${s}.set(true);`);
+                lines.push(`                }`);
+                lines.push(`            }`);
+            }
+            else if (deBox) {
+                lines.push(`            if let Ok(wire_${s}) = out_${s} {`);
+                lines.push(`                if let Ok(res_${s}) = ${rustDecodeResultName(comp.name, node.id)}(wire_${s}) {`);
+                lines.push(`                    *${typedCell(node.id)}.borrow_mut() = res_${s};`);
+                lines.push(`                    produced_${s}.set(true);`);
+                lines.push(`                }`);
+                lines.push(`            }`);
+            }
+            else {
+                lines.push(`            if let Ok(row_${s}) = out_${s} {`);
+                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)}`);
+            const policyLit = meta.policy === "retry" ? "retry' policy (exhausted)" : "fail' policy";
+            const resultVar = deBox ? `wire_${s}` : `row_${s}`;
+            lines.push(`            let ${resultVar} = match out_${s} {`);
+            lines.push(`                Ok(r) => r,`);
+            lines.push(`                Err(e) => return Err(BehaviorError { code: "OP_FAILED".to_string(), message: format!("operation '{}' failed under '${policyLit}: {}", ${rustStrLit(node.id)}, e.message), detail: e.detail }),`);
+            lines.push(`            };`);
+            if (namedTop) {
+                lines.push(`            let row_${s} = ${rustDecodeNamedName(top.innerName)}(&wire_${s})?;`);
+                lines.push(`            ${emitRowMove(`*${typedCell(node.id)}.borrow_mut()`, `row_${s}`, ref, plan)}`);
+            }
+            else if (deBox) {
+                lines.push(`            let res_${s} = ${rustDecodeResultName(comp.name, node.id)}(wire_${s})?;`);
+                lines.push(`            *${typedCell(node.id)}.borrow_mut() = res_${s};`);
+            }
+            else {
+                lines.push(`            ${emitRowMove(`*${typedCell(node.id)}.borrow_mut()`, `row_${s}`, ref, plan)}`);
+            }
             lines.push(`            produced_${s}.set(true);`);
         }
         lines.push(`        }`);
@@ -1870,62 +2161,18 @@ isAsync = false) {
     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) };
-    };
+    // a record element is de-boxed strictly: the handler returns the element WIRE(s) and the arm decodes via
+    // decode_wire_elem_* (closing the scan-row hole). A de-box mismatch fails closed regardless of
+    // elementPolicy (matching the interpreter's whole-node outType throw).
+    const elemDeBox = mapFanoutElemDeBoxEligible(node, typedNodes, plan);
+    const decElemFn = elemDeBox ? rustDecodeElemName(comp.name, node.id) : "";
     // 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, plan);
-            // #108-map: pass the element binding + base expr so a `$as` MAP/NAMED field port clones the typed composite.
-            inits.push(emitPortInit(pn, m.ports[pn], ty, resolveRef, comp.inputPorts, plan, undefined, asBinding, `oel_${s}`));
+            inits.push(emitPortInit(pn, m.ports[pn], comp, plan, typedNodes, priorHere, { asBinding, asBase: `oel_${s}` }));
         }
         out.push(`${il}let ep_${s} = ${structName} { ${inits.join(", ")} };`);
         return out;
@@ -1935,13 +2182,7 @@ isAsync = false) {
     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 resolveHead = nativeResolveHead(comp, plan, typedNodes, priorHere, { asBinding: { name: asName, ref: overElemRef, plan }, asBase: `oel_${s}` });
         const g = new NativeExprCompiler(makeRustExprBackend(resolveHead, plan)).compileBool(m.when);
         const out = [];
         for (const st of g.stmts)
@@ -1981,26 +2222,30 @@ isAsync = false) {
         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}        Ok(r) => r,`);
+        lines.push(`${indent}        Err(e) => return Err(op_failed(${rustStrLit(node.id)}, "fail", e)),`);
         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} {`);
+        const batchLen = elemDeBox ? `row_${s}.len()` : `row_${s}.rows.len()`;
+        const batchIter = elemDeBox ? `row_${s}.into_iter()` : `row_${s}.rows.into_iter()`;
+        lines.push(`${indent}    if ${batchLen} != 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();`);
+            // zip the aligned batch rows onto each KEPT over element (into materializer). A record element's
+            // wire is de-boxed strictly first.
+            lines.push(`${indent}    let mut rows_iter_${s} = ${batchIter};`);
             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");`);
+            if (elemDeBox)
+                lines.push(`${indent}        let er_${s} = ${decElemFn}(&er_${s})?;`);
             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}    for er_${s} in ${batchIter} {`);
+            if (elemDeBox)
+                lines.push(`${indent}        let er_${s} = ${decElemFn}(&er_${s})?;`);
             lines.push(`${indent}        ${emitElemMove(`let el_${s}`, `er_${s}`, elemArrRef.elem, plan)}`);
             lines.push(`${indent}        built_${s}.push(el_${s});`);
             lines.push(`${indent}    }`);
@@ -2014,13 +2259,21 @@ isAsync = false) {
             lines.push(l);
         for (const l of buildPorts(indent + "    "))
             lines.push(l);
+        // Element Error Policy (scp-error.md): `skip` drops the failing element and proceeds (order is
+        // preserved; the leaf keeps the Error Value it produced). `error` (default) promotes the element
+        // Failure to the map's Component Failure, carrying the leaf's detail through.
         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}        Ok(r) => r,`);
+        if (m.elementPolicy === "skip") {
+            lines.push(`${indent}        Err(_) => continue,`);
+        }
+        else {
+            lines.push(`${indent}        Err(e) => return Err(op_failed(${rustStrLit(node.id)}, "fail", e)),`);
+        }
         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}    }`);
+        // a record element's wire is de-boxed strictly (fail-closed regardless of elementPolicy).
+        if (elemDeBox)
+            lines.push(`${indent}    let er_${s} = ${decElemFn}(&er_${s})?;`);
         if (hasInto) {
             lines.push(`${indent}    built_${s}.push(${elemMat}(oel_${s}, er_${s}));`);
         }
@@ -2064,54 +2317,11 @@ function emitFanoutArm(comp, node, atPos, typedNodes, plan, priorNodeAt, isAsync
     if (!dkField || dkField.type.kind !== "scalar" || dkField.type.scalar !== "string")
         throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust fanout (v3): node '${node.id}' dedupeKey '${f.dedupeKey}' must be a string field of the connection items element type '${elemRef.name}'.`);
     const dkRust = rustFieldName(f.dedupeKey);
-    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;
-        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) };
-    };
     const buildPorts = (il) => {
         const inits = [];
         const asBinding = { name: asName, ref: overElemRef, plan };
         for (const pn of portNames) {
-            const ty = portFieldRustType(f.ports[pn], comp.inputPorts, `fanout port '${pn}' of node '${node.id}'`, asBinding, plan);
-            inits.push(emitPortInit(pn, f.ports[pn], ty, resolveRef, comp.inputPorts, plan));
+            inits.push(emitPortInit(pn, f.ports[pn], comp, plan, typedNodes, priorHere, { asBinding, asBase: `oel_${s}` }));
         }
         return [`${il}let ep_${s} = ${structName} { ${inits.join(", ")} };`];
     };
@@ -2136,20 +2346,26 @@ function emitFanoutArm(comp, node, atPos, typedNodes, plan, priorNodeAt, isAsync
     lines.push(`${indent}    let want_${s} = pi_${s}.len();`);
     lines.push(`${indent}    let bp_${s} = ${batch} { items: pi_${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(f.component)})),`);
+    lines.push(`${indent}        Ok(r) => r,`);
+    lines.push(`${indent}        Err(e) => return Err(op_failed(${rustStrLit(node.id)}, "fail", e)),`);
     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} {`);
+    // the fanout element row is a named record → the handler returns the aligned element WIRES
+    // (Vec<Option<Self::Wire>>) and each present body is de-boxed strictly (a de-box mismatch fails closed).
+    // A DANGLING id is None → the zero element row (empty dedupeKey), which the dangling drop excludes.
+    const decElemFn = rustDecodeElemName(comp.name, node.id);
+    const rawElemT = rawElemStructName(comp.name, node.id);
+    lines.push(`${indent}    if row_${s}.len() != want_${s} {`);
     lines.push(`${indent}        return Err(BehaviorError::new("FANOUT_BATCH_RESULT_MISMATCH", format!("fanout '{}': batched handler must return a list aligned to the deduped id list (want {})", ${rustStrLit(node.id)}, want_${s})));`);
     lines.push(`${indent}    }`);
     // ── THE ONE dedupe/drop (mirrors fanoutDedupDrop verbatim): first-seen dedupe by dedupeKey field;
     //    drop dangling (empty dedupeKey ≡ interpreter's null/absent-key body); implicitSource strip is
     //    structural (the elem type already omits it). cursor is always None (connection wrap).
     lines.push(`${indent}    let mut seen_${s}: std::collections::HashSet<String> = std::collections::HashSet::new();`);
-    lines.push(`${indent}    for er_${s} in row_${s}.rows.into_iter() {`);
+    lines.push(`${indent}    for opt_er_${s} in row_${s}.into_iter() {`);
+    lines.push(`${indent}        let er_${s}: ${rawElemT} = match opt_er_${s} {`);
+    lines.push(`${indent}            Some(wire_${s}) => ${decElemFn}(&wire_${s})?,`);
+    lines.push(`${indent}            None => Default::default(),`);
+    lines.push(`${indent}        };`);
     lines.push(`${indent}        ${emitElemMove(`let el_${s}`, `er_${s}`, elemRef, plan)}`);
     lines.push(`${indent}        let key_${s} = el_${s}.${dkRust}.clone();`);
     if (f.drop === "dangling") {
@@ -2166,30 +2382,6 @@ function emitFanoutArm(comp, node, atPos, typedNodes, plan, priorNodeAt, isAsync
         lines.push(c);
     return lines.join("\n");
 }
-/**
- * rustInputHeadRef (#108) — resolve an INPUT port head for a native-expr ref (rust). The port's declared
- * type comes from the shared `inputPortTypeRef` SSoT, so an OPTIONAL port resolves as `{opt:…}` (native
- * `Option<T>`) and the compiler can see its optionality: a null-compare becomes a real presence test and
- * a coalesce a real `unwrap_or`, while a REQUIRED-scalar slot fed by an opt fails closed. Exprs are OWNED
- * (String / Option<String> cloned; Copy scalars as-is), except an array — the only array use inside a
- * cond/guard expr is `len`, which BORROWS (`&in_.xs`).
- */
-function rustInputHeadRef(head, comp, plan) {
-    const schema = comp.inputPorts?.[head];
-    const ref = inputPortTypeRef(schema, plan);
-    if (ref === undefined)
-        return null;
-    const field = `in_.${rustFieldName(head)}`;
-    return { expr: rustOwnedHeadExpr(field, ref), ref };
-}
-/** The OWNED native expression for a head of type `ref` read off a by-value struct field. A String (or an
- * Option/collection containing one) is cloned; a Copy scalar (and an Option/array of Copy scalars) is
- * read directly — cloning a Copy value trips clippy's `clone_on_copy`. An array stays borrowed (`len`). */
-function rustOwnedHeadExpr(field, ref) {
-    if (ref.kind === "arr")
-        return field; // borrowed by `len`
-    return typeRefIsCopy(ref) ? field : `${field}.clone()`;
-}
 /**
  * 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
@@ -2200,11 +2392,7 @@ function emitCondArm(comp, node, atPos, typedNodes, plan, priorNodeAt) {
     const c = node.cond;
     const s = sanitize(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 resolveHead = nativeResolveHead(comp, plan, typedNodes, priorHere);
     const compiler = new NativeExprCompiler(makeRustExprBackend(resolveHead, plan));
     const cond = compiler.compileBool(c.if);
     // #125: a when(...) control-gate cond は出力データ型を持たない制御スキップマーカー。typed cell へ何も
@@ -2335,6 +2523,13 @@ pub const COMPONENT_NAMES_NATIVE_RAW: [&str; ${names.length}] = [${names.join(",
 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)"))
+}
+
+// leaf_failure — a failure the LEAF reports (test glue): the runner assigns the node's failure code
+// from its Error Policy Kind, so what a leaf carries is its message and its structured Error Value.
+#[allow(dead_code)]
+fn leaf_failure(message: impl Into<String>) -> BehaviorError {
+    BehaviorError::new("LEAF_FAILURE", message)
 }`;
 // ── module assembly ──────────────────────────────────────────────────────────────────
 function emit(ctx) {
@@ -2384,6 +2579,9 @@ ${emitStructSurface([])}
     const handlerTraits = [];
     const inStructs = [];
     const elemMaterializers = [];
+    // the generated strict de-box functions (deduped by named type across all covered components).
+    const decodeFns = [];
+    const decodeEmitted = new Set();
     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.
@@ -2401,8 +2599,11 @@ ${emitStructSurface([])}
             else
                 structs.push(emitPortsStruct(c, n, undefined, plan, typedNodes)); // #129: typedNodes for prior-node arr leaf ports.
         }
+        // fail closed for a record inside a non-named top (never a silent trust) — before emitting anything.
+        assertDeBoxableResults(c, typedNodes, plan);
         rowStructs.push(emitRawRowStructs(c, typedNodes, plan));
         handlerTraits.push(emitHandlerTrait(c, typedNodes, plan, asyncPlans.get(c.name)));
+        emitRustNodeDecodeFns(c, typedNodes, plan, decodeEmitted, decodeFns);
         inStructs.push(emitInStruct(c, plan));
         const mm = emitMapElemMaterializers(c, typedNodes, plan);
         if (mm)
@@ -2445,6 +2646,12 @@ use std::cell::RefCell;`;
             : 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")}`,
+        decodeFns.length
+            ? `// strict de-box wire seam — the consumer implements WireRow/WireList over its wire payload (variant\n// classification); the generated decode_wire_* owns strictness (required/optional, present/absent, error\n// assembly, fail-closed). Concrete enums + monomorphized traits — no boxed value, no trait object, no\n// heap allocation crosses the seam.\n${emitRustProbeWireTypes()}`
+            : undefined,
+        decodeFns.length
+            ? `// Generated strict de-box functions (per named record type; structured Error Value on mismatch).\n${decodeFns.join("\n\n")}`
+            : undefined,
         elemMaterializers.length
             ? `// map augmented-element copiers (pure struct field assignment — no dynamic value read).\n${elemMaterializers.join("\n\n")}`
             : undefined,
@@ -2476,6 +2683,160 @@ export function rustTypedNativeObserve(ir, ioModel = "sync") {
     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");
+    // does any covered read de-box a named record — a componentRef record OR a map/fanout element row
+    // (→ the scripted handler returns a ScriptedWireRow / Vec<ScriptedWireRow>)?
+    const anyDeBox = native.some((c) => {
+        const tn = new Map();
+        for (const n of c.body)
+            if (!isControlGate(n))
+                tn.set(n.id, "map" in n ? mapNodeArrRef(n, plan) : deriveTypeRef(n.outType, plan));
+        return c.body.some((n) => {
+            if ("cond" in n)
+                return false;
+            if ("map" in n || "fanout" in n)
+                return mapFanoutElemDeBoxEligible(n, tn, plan);
+            return deBoxEligible(tn.get(n.id));
+        });
+    });
+    // scripted wire adapter (TEST glue): wraps a scripted Value as a WireRow/WireList and classifies each
+    // attribute's native type into a DynamoDB-flavored wire tag (S/N/BOOL/L/M/NULL). A real consumer
+    // implements WireRow over its own AttributeValue map; this drives the generated de-box from the same
+    // scripted vectors run_behavior uses — so actualWireType observed in a mismatch is the PRODUCER tag.
+    const wireAdapter = anyDeBox
+        ? `// ── scripted wire adapter (TEST glue) ──
+fn scripted_wire_tag(v: &Value) -> String {
+    match v {
+        Value::Null => "NULL",
+        Value::Bool(_) => "BOOL",
+        Value::Int(_) | Value::Float(_) => "N",
+        Value::Str(_) => "S",
+        Value::Arr(_) => "L",
+        Value::Obj(_) => "M",
+    }
+    .to_string()
+}
+
+fn scripted_wire_raw(v: &Value) -> String {
+    match v {
+        Value::Null => "null".to_string(),
+        Value::Bool(b) => b.to_string(),
+        Value::Int(n) => n.to_string(),
+        Value::Float(f) => f.to_string(),
+        Value::Str(s) => s.clone(),
+        Value::Arr(_) | Value::Obj(_) => "[composite]".to_string(),
+    }
+}
+
+fn probe_string_val(v: Option<&Value>) -> Probe<String> {
+    match v {
+        None => Probe::Absent,
+        Some(Value::Null) => Probe::Null { actual_wire_type: "NULL".to_string(), raw_value: "null".to_string() },
+        Some(Value::Str(s)) => Probe::Got(s.clone()),
+        Some(other) => Probe::Wrong { actual_wire_type: scripted_wire_tag(other), raw_value: scripted_wire_raw(other) },
+    }
+}
+
+fn probe_number_val(v: Option<&Value>) -> NumProbe {
+    match v {
+        None => NumProbe::Absent,
+        Some(Value::Null) => NumProbe::Null { actual_wire_type: "NULL".to_string(), raw_value: "null".to_string() },
+        Some(Value::Int(n)) => NumProbe::Got { raw: n.to_string(), actual_wire_type: "N".to_string() },
+        Some(Value::Float(f)) => NumProbe::Got { raw: f.to_string(), actual_wire_type: "N".to_string() },
+        Some(other) => NumProbe::Wrong { actual_wire_type: scripted_wire_tag(other), raw_value: scripted_wire_raw(other) },
+    }
+}
+
+fn probe_bool_val(v: Option<&Value>) -> Probe<bool> {
+    match v {
+        None => Probe::Absent,
+        Some(Value::Null) => Probe::Null { actual_wire_type: "NULL".to_string(), raw_value: "null".to_string() },
+        Some(Value::Bool(b)) => Probe::Got(*b),
+        Some(other) => Probe::Wrong { actual_wire_type: scripted_wire_tag(other), raw_value: scripted_wire_raw(other) },
+    }
+}
+
+fn probe_row_val(v: Option<&Value>) -> Probe<ScriptedWireRow> {
+    match v {
+        None => Probe::Absent,
+        Some(Value::Null) => Probe::Null { actual_wire_type: "NULL".to_string(), raw_value: "null".to_string() },
+        Some(Value::Obj(pairs)) => Probe::Got(ScriptedWireRow { obj: pairs.clone() }),
+        Some(other) => Probe::Wrong { actual_wire_type: scripted_wire_tag(other), raw_value: scripted_wire_raw(other) },
+    }
+}
+
+fn probe_list_val(v: Option<&Value>) -> Probe<ScriptedWireList> {
+    match v {
+        None => Probe::Absent,
+        Some(Value::Null) => Probe::Null { actual_wire_type: "NULL".to_string(), raw_value: "null".to_string() },
+        Some(Value::Arr(items)) => Probe::Got(ScriptedWireList { items: items.clone() }),
+        Some(other) => Probe::Wrong { actual_wire_type: scripted_wire_tag(other), raw_value: scripted_wire_raw(other) },
+    }
+}
+
+pub struct ScriptedWireRow {
+    obj: Vec<(String, Value)>,
+}
+
+impl ScriptedWireRow {
+    pub fn new(v: Value) -> Self {
+        match v {
+            Value::Obj(pairs) => ScriptedWireRow { obj: pairs },
+            _ => ScriptedWireRow { obj: Vec::new() },
+        }
+    }
+    fn get(&self, field: &str) -> Option<&Value> {
+        self.obj.iter().find(|(k, _)| k.as_str() == field).map(|(_, v)| v)
+    }
+}
+
+pub struct ScriptedWireList {
+    items: Vec<Value>,
+}
+
+impl WireRow for ScriptedWireRow {
+    type List = ScriptedWireList;
+    fn keys(&self) -> Vec<String> {
+        self.obj.iter().map(|(k, _)| k.clone()).collect()
+    }
+    fn probe_string(&self, field: &str) -> Probe<String> {
+        probe_string_val(self.get(field))
+    }
+    fn probe_number(&self, field: &str) -> NumProbe {
+        probe_number_val(self.get(field))
+    }
+    fn probe_bool(&self, field: &str) -> Probe<bool> {
+        probe_bool_val(self.get(field))
+    }
+    fn probe_row(&self, field: &str) -> Probe<Self> {
+        probe_row_val(self.get(field))
+    }
+    fn probe_list(&self, field: &str) -> Probe<Self::List> {
+        probe_list_val(self.get(field))
+    }
+}
+
+impl WireList for ScriptedWireList {
+    type Row = ScriptedWireRow;
+    fn len(&self) -> usize {
+        self.items.len()
+    }
+    fn elem_string(&self, i: usize) -> Probe<String> {
+        probe_string_val(self.items.get(i))
+    }
+    fn elem_number(&self, i: usize) -> NumProbe {
+        probe_number_val(self.items.get(i))
+    }
+    fn elem_bool(&self, i: usize) -> Probe<bool> {
+        probe_bool_val(self.items.get(i))
+    }
+    fn elem_row(&self, i: usize) -> Probe<Self::Row> {
+        probe_row_val(self.items.get(i))
+    }
+    fn elem_list(&self, i: usize) -> Probe<Self> {
+        probe_list_val(self.items.get(i))
+    }
+}`
+        : "";
     // ── 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 = [];
@@ -2499,22 +2860,39 @@ export function rustTypedNativeObserve(ir, ioModel = "sync") {
             // Option<K> (NOT a boxed Value) — computed per node so the impl signature matches the trait.
             const bt = boundRustType(n, typedNodes, plan);
             if ("fanout" in n) {
-                // v3: scripted fanout impl — drain one batched outcome, decode the aligned array into per-body
-                // elem rows (a null array element decodes to the zero elem row = dangling → dropped by the arm).
                 const f = n.fanout;
-                const elemRowRef = fanoutItemsElemRef(n, ref, plan);
+                const elemDeBox = mapFanoutElemDeBoxEligible(n, typedNodes, 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 = `${portsStructName(c.name, n.id)}Batch`;
-                methods.push(`    ${fnKw} ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Option<${batchT}> {
-        let (is_err, err, ok, _echo) = self.next(${rustStrLit(f.component)})?;
+                if (elemDeBox) {
+                    // a record-element fanout returns the aligned element WIRES; a null aligned body is a DANGLING
+                    // id → None (the covered runner maps it to the zero elem row).
+                    methods.push(`    ${fnKw} ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Result<Vec<Option<ScriptedWireRow>>, BehaviorError> {
+        let (is_err, err, ok, _echo) = self.next(${rustStrLit(f.component)}).ok_or_else(|| unknown_component(${rustStrLit(f.component)}))?;
         if is_err {
-            return Some(${batchT} { is_error: true, err, ..Default::default() });
+            return Err(leaf_failure(err));
+        }
+        let arr = match ok { Some(Value::Arr(a)) => a, _ => Vec::new() };
+        let wires = arr
+            .into_iter()
+            .map(|ev| match ev {
+                Value::Null => None,
+                _ => Some(ScriptedWireRow::new(ev)),
+            })
+            .collect();
+        Ok(wires)
+    }`);
+                    continue;
+                }
+                const elemRowRef = fanoutItemsElemRef(n, ref, plan);
+                const elemDecode = emitDecodeRow(c.name, n.id, elemT, elemRowRef, plan, emittedDecode, decodeFns, "Elem");
+                methods.push(`    ${fnKw} ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Result<${batchT}, BehaviorError> {
+        let (is_err, err, ok, _echo) = self.next(${rustStrLit(f.component)}).ok_or_else(|| unknown_component(${rustStrLit(f.component)}))?;
+        if is_err {
+            return Err(leaf_failure(err));
         }
         let arr = match ok { Some(Value::Arr(a)) => a, _ => Vec::new() };
-        // v3: a null aligned body is a DANGLING id — decode it to the zero elem row (whose dedupeKey
-        // field is empty), so the runner's dangling-drop excludes it (byte-equal to fanoutDedupDrop).
         let rows = arr
             .iter()
             .map(|ev| match ev {
@@ -2522,7 +2900,7 @@ export function rustTypedNativeObserve(ir, ioModel = "sync") {
                 _ => ${elemDecode}(ev),
             })
             .collect();
-        Some(${batchT} { rows, ..Default::default() })
+        Ok(${batchT} { rows })
     }`);
                 continue;
             }
@@ -2530,65 +2908,172 @@ export function rustTypedNativeObserve(ir, ioModel = "sync") {
                 const m = n.map;
                 const batched = m.batched === true;
                 const arrRef = ref;
-                const elemRowRef = mapElemRowRef(n, arrRef, plan);
+                const elemDeBox = mapFanoutElemDeBoxEligible(n, typedNodes, 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 (elemDeBox) {
+                    // a record-element map returns the element WIRE(s); the covered runner de-boxes each strictly.
+                    if (batched) {
+                        methods.push(`    ${fnKw} ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Result<Vec<ScriptedWireRow>, BehaviorError> {
+        let (is_err, err, ok, _echo) = self.next(${rustStrLit(m.component)}).ok_or_else(|| unknown_component(${rustStrLit(m.component)}))?;
+        if is_err {
+            return Err(leaf_failure(err));
+        }
+        let arr = match ok { Some(Value::Arr(a)) => a, _ => Vec::new() };
+        let wires = arr.into_iter().map(ScriptedWireRow::new).collect();
+        Ok(wires)
+    }`);
+                    }
+                    else {
+                        methods.push(`    ${fnKw} ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Result<ScriptedWireRow, BehaviorError> {
+        let (is_err, err, ok, _echo) = self.next(${rustStrLit(m.component)}).ok_or_else(|| unknown_component(${rustStrLit(m.component)}))?;
+        if is_err {
+            return Err(leaf_failure(err));
+        }
+        Ok(ScriptedWireRow::new(ok.unwrap_or(Value::Null)))
+    }`);
+                    }
+                    continue;
+                }
+                const elemRowRef = mapElemRowRef(n, arrRef, plan);
+                const elemDecode = emitDecodeRow(c.name, n.id, elemT, elemRowRef, plan, emittedDecode, decodeFns, "Elem");
                 if (batched) {
-                    methods.push(`    ${fnKw} ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Option<${batchT}> {
-        let (is_err, err, ok, _echo) = self.next(${rustStrLit(m.component)})?;
+                    methods.push(`    ${fnKw} ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Result<${batchT}, BehaviorError> {
+        let (is_err, err, ok, _echo) = self.next(${rustStrLit(m.component)}).ok_or_else(|| unknown_component(${rustStrLit(m.component)}))?;
         if is_err {
-            return Some(${batchT} { is_error: true, err, ..Default::default() });
+            return Err(leaf_failure(err));
         }
         let arr = match ok { Some(Value::Arr(a)) => a, _ => Vec::new() };
         let rows = arr.iter().map(${elemDecode}).collect();
-        Some(${batchT} { rows, ..Default::default() })
+        Ok(${batchT} { rows })
     }`);
                 }
                 else {
-                    methods.push(`    ${fnKw} ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Option<${elemT}> {
-        let (is_err, err, ok, _echo) = self.next(${rustStrLit(m.component)})?;
+                    methods.push(`    ${fnKw} ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Result<${elemT}, BehaviorError> {
+        let (is_err, err, ok, _echo) = self.next(${rustStrLit(m.component)}).ok_or_else(|| unknown_component(${rustStrLit(m.component)}))?;
         if is_err {
-            return Some(${elemT} { is_error: true, err, ..Default::default() });
+            return Err(leaf_failure(err));
         }
         let v = ok.unwrap_or(Value::Null);
-        Some(${elemDecode}(&v))
+        Ok(${elemDecode}(&v))
     }`);
                 }
-                void retT;
                 continue;
             }
             const node = n;
             const rowT = rawRowStructName(c.name, node.id);
+            // a de-box-eligible node's scripted handler returns a ScriptedWireRow (the scripted Value wrapped as
+            // a WireRow that classifies each attribute's native type into a DynamoDB-flavored wire tag); the
+            // covered module's generated decode_wire_* then probes it. A real consumer returns its wire payload
+            // for BC to de-box — the de-box no longer lives here.
+            if (deBoxEligible(ref)) {
+                // a record-containing top returns its wire (ScriptedWireRow / Vec / Option / BTreeMap) — the
+                // covered runner de-boxes each record. #129: an arr node with an `items` port echoes the NATIVE
+                // port array, serialized back to Vec<ScriptedWireRow> so the de-box round-trips.
+                const top = recordTop(ref);
+                const wireT = (() => {
+                    switch (top.kind) {
+                        case "named":
+                            return "ScriptedWireRow";
+                        case "arr":
+                            return "Vec<ScriptedWireRow>";
+                        case "opt":
+                            return "Option<ScriptedWireRow>";
+                        case "map":
+                            return "std::collections::BTreeMap<String, ScriptedWireRow>";
+                    }
+                })();
+                // echo-into-record (#141 fixtures): a named de-box node whose result WRAPS an input port — the
+                // scripted leaf echoes port P into the record's single field, so the input-port value flows into
+                // the de-boxed result and the runtime non-vacuity #139/#143/#144 assert survives the record wrap.
+                let namedEcho = "";
+                if (top.kind === "named") {
+                    const decl = findDecl(plan, top.innerName);
+                    const recordRust = renderTypeRef(ref);
+                    const field = decl !== undefined && decl.fields.length === 1 ? decl.fields[0] : undefined;
+                    const fieldRust = field !== undefined ? renderTypeRef(field.type) : null;
+                    for (const pn of Object.keys(node.ports)) {
+                        let portRust = null;
+                        try {
+                            portRust = portFieldRustType(node.ports[pn], c, plan, typedNodes, `echo port '${pn}'`);
+                        }
+                        catch {
+                            portRust = null;
+                        }
+                        if (portRust === recordRust) {
+                            // case 2: the port IS the whole record → echo it DIRECTLY (no field wrap), matching
+                            // run_behavior's plain echo:port of a whole-record port.
+                            const own = typeRefIsCopy(ref) ? `ports.${portFieldName(pn)}` : `ports.${portFieldName(pn)}.clone()`;
+                            namedEcho += `        if echo == ${rustStrLit(pn)} {\n            let tv = ${own};\n            return Ok(ScriptedWireRow::new(${serializeTyped("tv", ref, plan)}));\n        }\n`;
+                        }
+                        else if (fieldRust !== null && field !== undefined && portRust === fieldRust) {
+                            // case 1: a scalar port wraps into the record's single field ({v: ports.X}).
+                            const own = typeRefIsCopy(field.type) ? `ports.${portFieldName(pn)}` : `ports.${portFieldName(pn)}.clone()`;
+                            namedEcho += `        if echo == ${rustStrLit(pn)} {\n            let tv = ${own};\n            return Ok(ScriptedWireRow::new(Value::Obj(vec![(${rustStrLit(field.name)}.to_string(), ${serializeTyped("tv", field.type, plan)})])));\n        }\n`;
+                        }
+                    }
+                }
+                const canEcho = (top.kind === "arr" && Object.prototype.hasOwnProperty.call(node.ports, "items")) || namedEcho !== "";
+                const portsParam = canEcho ? "ports" : "_ports";
+                const okBind = canEcho ? "(is_err, err, ok, echo)" : "(is_err, err, ok, _echo)";
+                let body;
+                if (top.kind === "named") {
+                    body = `${namedEcho}        Ok(ScriptedWireRow::new(ok.unwrap_or(Value::Null)))`;
+                }
+                else if (top.kind === "arr") {
+                    const elemRef = ref.elem;
+                    const itemsF = portFieldName("items");
+                    const echoBranch = canEcho
+                        ? `        if echo == "items" {\n            let wires: Vec<ScriptedWireRow> = ports.${itemsF}.iter().map(|e| { let tv = e.clone(); ScriptedWireRow::new(${serializeTyped("tv", elemRef, plan)}) }).collect();\n            return Ok(wires);\n        }\n`
+                        : "";
+                    body = `${echoBranch}        let arr = match ok { Some(Value::Arr(a)) => a, _ => Vec::new() };\n        Ok(arr.into_iter().map(ScriptedWireRow::new).collect())`;
+                }
+                else if (top.kind === "opt") {
+                    body = `        match ok {\n            None | Some(Value::Null) => Ok(None),\n            Some(v) => Ok(Some(ScriptedWireRow::new(v))),\n        }`;
+                }
+                else {
+                    body = `        let obj = match ok { Some(Value::Obj(pairs)) => pairs, _ => Vec::new() };\n        Ok(obj.into_iter().map(|(k, v)| (k, ScriptedWireRow::new(v))).collect())`;
+                }
+                methods.push(`    ${fnKw} ${nodeMethodName(node.id)}(&self, ${portsParam}: &${portsStructName(c.name, node.id)}, _bound: ${bt}) -> Result<${wireT}, BehaviorError> {
+        let ${okBind} = self.next(${rustStrLit(node.component)}).ok_or_else(|| unknown_component(${rustStrLit(node.component)}))?;
+        if is_err {
+            return Err(leaf_failure(err));
+        }
+${body}
+    }`);
+                continue;
+            }
             const decode = emitDecodeRow(c.name, node.id, rowT, ref, plan, emittedDecode, decodeFns, "");
-            // #129 (TEST glue): support the reference scriptedHandlers' echo forms (PROTOCOL.md §3.5) — the
-            // adapter normalizes `{"echo":"port","port":"X"}` / `{"echo":"items"}` to the port NAME, and the
-            // scripted handler
-            // ECHOES a NATIVE port back as its result. This makes a port-plane pin non-vacuous: the node's
-            // observed result IS the native value that flowed into its ports struct, so a dropped / re-boxed /
-            // zero-defaulted port diverges from run_behavior instead of passing. A port is echoable when its
-            // native type IS the node's outType (that is exactly when the row's `val` can hold it); `ports` is
-            // bound only when at least one port qualifies.
-            const echoable = echoablePorts(c, node, ref, plan, typedNodes);
-            const portsParam = echoable.length > 0 ? "ports" : "_ports";
-            // a Copy port (i64/f64/bool/Option<scalar>) is read directly — cloning it trips clippy clone_on_copy.
-            const echoRead = (p) => `${portsParam}.${portFieldName(p)}${typeRefIsCopy(ref) ? "" : ".clone()"}`;
-            const echoBranch = echoable
-                .map((p) => `\n        if echo == ${rustStrLit(p)} {\n            return Some(${rowT} { val: ${echoRead(p)}, ..Default::default() });\n        }`)
-                .join("");
-            const okBind = echoable.length > 0 ? "(is_err, err, ok, echo)" : "(is_err, err, ok, _echo)";
-            methods.push(`    ${fnKw} ${nodeMethodName(node.id)}(&self, ${portsParam}: &${portsStructName(c.name, node.id)}, _bound: ${bt}) -> Option<${rowT}> {
-        let ${okBind} = self.next(${rustStrLit(node.component)})?;
+            // #129 (TEST glue): if this node has an `items` port and its outType is a bare arr, support the
+            // reference scriptedHandlers' `echo === "items"` — the scripted handler ECHOES the NATIVE `f_items`
+            // port back as its result. This makes the node→leaf array dataflow test non-vacuous: the leaf's
+            // observed result is exactly the native array that flowed into its ports struct, so a dropped or
+            // boxed native array would diverge from run_behavior. `ports` is bound only on the echo path.
+            const canEcho = ref.kind === "arr" && Object.prototype.hasOwnProperty.call(node.ports, "items");
+            const portsParam = canEcho ? "ports" : "_ports";
+            const echoBranch = canEcho
+                ? `\n        if echo == "items" {\n            return Ok(${rowT} { val: ${portsParam}.${portFieldName("items")}.clone() });\n        }`
+                : "";
+            const okBind = canEcho ? "(is_err, err, ok, echo)" : "(is_err, err, ok, _echo)";
+            methods.push(`    ${fnKw} ${nodeMethodName(node.id)}(&self, ${portsParam}: &${portsStructName(c.name, node.id)}, _bound: ${bt}) -> Result<${rowT}, BehaviorError> {
+        let ${okBind} = self.next(${rustStrLit(node.component)}).ok_or_else(|| unknown_component(${rustStrLit(node.component)}))?;
         if is_err {
-            return Some(${rowT} { is_error: true, err, ..Default::default() });
+            return Err(leaf_failure(err));
         }${echoBranch}
         let v = ok.unwrap_or(Value::Null);
-        Some(${decode}(&v))
+        Ok(${decode}(&v))
     }`);
         }
-        traitImpls.push(`impl ${handlerTraitName(c.name)} for ScriptedNativeRaw {\n${methods.join("\n")}\n}`);
+        const cHasDeBox = c.body.some((n) => {
+            if ("cond" in n)
+                return false;
+            if ("map" in n || "fanout" in n)
+                return mapFanoutElemDeBoxEligible(n, typedNodes, plan);
+            return deBoxEligible(typedNodes.get(n.id));
+        });
+        const wireAssoc = cHasDeBox ? `    type Wire = ScriptedWireRow;\n` : "";
+        traitImpls.push(`impl ${handlerTraitName(c.name)} for ScriptedNativeRaw {\n${wireAssoc}${methods.join("\n")}\n}`);
     }
     const arms = native
         .map((c) => {
@@ -2637,7 +3122,7 @@ impl ScriptedNativeRaw {
     }
 
     // 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,
+    // handlers); None when the component has no scripted queue. Returns (is_error, err,
     // ok_value, echo). The bc#87 parallel-stage runner calls node_* from multiple threads, so the drain
     // is Mutex-guarded. #129: \`echo\` carries the reference scriptedHandlers' \`echo\` directive (e.g.
     // "items") so a scripted node can ECHO a named input PORT back — used to make the node→leaf array
@@ -2647,13 +3132,11 @@ impl ScriptedNativeRaw {
         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) };
-        // PROTOCOL.md §3.5 echo forms, normalized to the port NAME: {"echo":"port","port":"X"} -> "X"
-        // ({"echo":"items"} is already that shape). The generated node method just compares this
-        // against its echoable port names.
-        let echo = match raw.get("echo").and_then(|e| e.as_str()) {
-            Some("port") => raw.get("port").and_then(|p| p.as_str()).unwrap_or("").to_string(),
-            Some(other) => other.to_string(),
-            None => String::new(),
+        // normalize echo:port to the port NAME X so a de-box handler's echo comparison fires;
+        // echo:items already names the port directly.
+        let echo = {
+            let e = raw.get("echo").and_then(|e| e.as_str()).unwrap_or("");
+            if e == "port" { raw.get("port").and_then(|p| p.as_str()).unwrap_or("").to_string() } else { e.to_string() }
         };
         if let Some(okv) = raw.get("ok") {
             let v = behavior_contracts::decode_value(okv).expect("decode ok");
@@ -2681,9 +3164,27 @@ 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).
+// the conformance harness reads (same code + message + structured detail) — the ONLY place the two meet
+// (test glue). The de-box's structured Error Value is carried over so the harness can assert it.
 fn to_rt_err(e: BehaviorError) -> behavior_contracts::BehaviorError {
-    behavior_contracts::BehaviorError::new(e.code, e.message)
+    let mut rt = behavior_contracts::BehaviorError::new(e.code, e.message);
+    if let Some(d) = e.detail {
+        let d = *d;
+        rt.detail = Some(Box::new(behavior_contracts::ErrorDetail {
+            kind: d.kind.map(|k| match k {
+                ErrorKind::TypeMismatch => behavior_contracts::ErrorKind::TypeMismatch,
+                ErrorKind::MissingField => behavior_contracts::ErrorKind::MissingField,
+                ErrorKind::Overflow => behavior_contracts::ErrorKind::Overflow,
+            }),
+            model: d.model,
+            field: d.field,
+            expected_type: d.expected_type,
+            actual_wire_type: d.actual_wire_type,
+            raw_value: d.raw_value,
+            context: d.context,
+        }));
+    }
+    rt
 }
 ${anyAsyncRunner
         ? `// bc#97 (TEST glue) — a minimal std-only block-on that drives an async runner Future to completion so
@@ -2723,6 +3224,9 @@ ${decodeFns.join("\n\n")}
 // input decoders (generic &[(String,Value)] -> concrete InNR_<comp>; TEST glue, one decode at the boundary).
 ${inDecoders}
 
+// scripted wire adapter (TEST glue) — wraps a scripted Value as a WireRow the generated de-box probes.
+${wireAdapter}
+
 ${adapter}
 
 // scripted handler trait impls (one per covered component — the concrete node_* seam, test glue).
@@ -2745,10 +3249,8 @@ ${arms}
 }
 /** 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; opt → Some/None; Value-typed → the raw Value clone). A key that is absent, or present as
- * `Value::Null`, leaves the field's Default — for an OPTIONAL port that is `None` (absent), which is the
- * same value `refCore` observes for the `null` binding run_behavior is given. Lives ONLY in the observe
- * companion. */
+ * 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 ?? {});
@@ -2770,15 +3272,7 @@ function emitInDecoder(comp, plan) {
         const et = schema.elemType;
         const head = i === 0 ? "        if" : "        } else if";
         lines.push(`${head} k == ${rustStrLit(p)} {`);
-        if (inputPortIsOptional(schema)) {
-            // An OPTIONAL port decodes into its native Option<T>. materializeExpr's opt de-box IS the wire
-            // rule: `Value::Null` → None (absent), any other value → Some(<inner>). A key that never appears
-            // keeps the struct Default (None) — the same absent value. Checked FIRST: optionality wraps every
-            // inner type (an optional array is Option<Vec<T>>, not Vec<T>).
-            const optRef = inputPortTypeRef(schema, plan);
-            lines.push(`            in_.${field} = ${materializeExpr("v", optRef, plan)};`);
-        }
-        else if ((schema?.type === "array" || schema?.type === "arr") && et !== 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);
@@ -2798,6 +3292,11 @@ function emitInDecoder(comp, plan) {
             const mapRef = { kind: "map", value: deriveTypeRef(et, plan) };
             lines.push(`            in_.${field} = ${materializeExpr("v", mapRef, plan)};`);
         }
+        else if (inputPortIsOptional(schema)) {
+            // #139: an OPTIONAL scalar port decodes into Option<T> via the inputPortTypeRef SSoT (a present key
+            // materializes Some(v); an absent key never enters this block, leaving the Default None).
+            lines.push(`            in_.${field} = ${materializeExpr("v", inputPortTypeRef(schema, plan), plan)};`);
+        }
         else if (scalar === undefined) {
             lines.push(`            in_.${field} = v.clone();`);
         }
@@ -2816,16 +3315,6 @@ function emitInDecoder(comp, plan) {
     lines.push(`}`);
     return lines.join("\n");
 }
-/** echoablePorts (TEST glue) — the node's ports whose NATIVE type is exactly the node's outType, in
- * declaration order. Those are the ports a scripted `echo: "<port>"` can return as the row's `val`. A
- * port with a different type is not echoable (the row could not hold it), and a NAMED outType has no
- * `val` at all (its row carries the struct's fields flattened — see emitDecodeRow). */
-function echoablePorts(comp, node, ref, plan, typedNodes) {
-    if (ref.kind === "named")
-        return [];
-    const want = renderTypeRef(ref);
-    return Object.keys(node.ports).filter((p) => portFieldRustType(node.ports[p], comp.inputPorts, `port '${p}'`, undefined, plan, typedNodes) === want);
-}
 /** 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. */
@@ -2840,12 +3329,12 @@ function emitDecodeRow(compName, nodeId, rowT, ref, plan, emitted, out, suffix)
         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() }`);
+        lines.push(`    ${rowT} { ${inits} }`);
     }
     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(`    ${rowT} { val }`);
     }
     lines.push(`}`);
     out.push(lines.join("\n"));