behavior-contracts 0.8.6 → 0.8.8

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

@@ -6,6 +6,7 @@ import { buildTypePlan, deriveTypeRef, findDecl, inputPortIsOptional, inputPortT
 import { concurrencyPlan, execPlan, analyzeSequentialOps, classifyExpr } from "./straightline.js";
 import { NativeExprCompiler } from "./native-expr.js";
 import { buildAsyncPlans } from "./async-plan.js";
+import { buildDeBoxPlan, notationOfRef } from "./emit-shared-debox.js";
 const { sanitize, rustStrLit } = rustStraightlineInternals;
 const { typeRefIsCopy, rustFieldName, renderTypeRef, typedCell, typedFieldAccess, serializeTyped, emitTypeDecls, emitDefaults, emitSerializers, emitTypedValue, emitMarshallers, emitMarshalHelpers, materializeExpr, } = rustTypedInternals;
 /** rustErr — build the LOCAL concrete error value for a behavior/plan failure on the covered read
@@ -172,14 +173,6 @@ function pascal(s) {
 function portsStructName(compName, nodeId) {
     return `PortsNR${pascal(compName)}${pascal(nodeId)}`;
 }
-/** RawRowNR<Comp><Node> — the concrete per-node handler-result row struct name. */
-function rawRowStructName(compName, nodeId) {
-    return `RawRowNR${pascal(compName)}${pascal(nodeId)}`;
-}
-/** RawElemNR<Comp><Node> — the concrete per-ELEMENT row struct name for a covered map node. */
-function rawElemStructName(compName, nodeId) {
-    return `RawElemNR${pascal(compName)}${pascal(nodeId)}`;
-}
 /** HandlerNR<Comp> — the per-component concrete handler trait name (one node_* method per node). */
 function handlerTraitName(compName) {
     return `HandlerNR${pascal(compName)}`;
@@ -192,56 +185,17 @@ function nodeMethodName(nodeId) {
 function inStructName(compName) {
     return `InNR${pascal(compName)}`;
 }
-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;
-}
-/** 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). */
+// ── strict de-box: the probe/wire seam + generated decode orchestration ───────────────────────
+//
+// A covered record read returns the consumer's WIRE (a value implementing WireRow), and the generated
+// decode probes it per field from the declared type. The consumer supplies variant classification (a
+// probe reports the producer's own wire tag as a free string); the generated code owns strictness —
+// required/optional, present/absent, error assembly, fail-closed. The seam stays native: Probe/NumProbe
+// are concrete enums and WireRow/WireList are monomorphized via mutual associated types (Row/List), so no
+// boxed Value / dyn / Box crosses the boundary.
+/** emitRustProbeWireTypes — the once-per-module probe enums + WireValue/WireRow/WireList seam traits.
+ * Concrete enums; monomorphized traits (WireValue's Row associated type threads WireRow, whose List
+ * threads WireList — nesting stays 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
@@ -261,6 +215,20 @@ pub enum NumProbe {
     Absent,
 }
 
+// WireValue — a node result's own wire datum (the uniform handler return): the producer's value at a
+// result-consumption point. The generated de-box classifies it against the STATICALLY declared node type
+// via these inherent methods (as_row / as_list yield the WireRow / WireList the nested decode then probes).
+// A top value is always present, so there is no Absent — a producer-null is Null. Monomorphized (Row
+// associated type threads WireRow) — no dyn, no Box, no boxed value crosses the seam.
+pub trait WireValue: Sized {
+    type Row: WireRow;
+    fn as_string(&self) -> Probe<String>;
+    fn as_number(&self) -> NumProbe;
+    fn as_bool(&self) -> Probe<bool>;
+    fn as_row(&self) -> Probe<Self::Row>;
+    fn as_list(&self) -> Probe<<Self::Row as WireRow>::List>;
+}
+
 // 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
@@ -289,147 +257,124 @@ pub trait WireList: Sized {
     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.
+ * renderRustDeBox — the ONE inline, recursive strict de-box renderer. Folds a language-neutral
+ * {@link DeBoxPlan} (the SSoT walk) into a single Rust EXPRESSION that evaluates to the decoded native
+ * value of the plan's type, obtained by probing `srcExpr` per the node's access (top → `as_*`, field →
+ * `probe_*(key)`, elem → `elem_*(i)`, mapval → `probe_*(&k)`). The recursion runs HERE at generation
+ * time (walking the plan), so the emitted Rust is FLAT, CONCRETE, fully-unrolled code: NO `decode_wire_*`
+ * helper function, NO output-side recursion — a nested record expands to a nested struct literal, a
+ * nested collection to a nested loop. A required-position mismatch does `return Err(de_*(...))` (fail
+ * closed, propagating the structured Error Value from the enclosing runner); an optional position
+ * (optDepth>0) maps absent/null to the all-None value. `ctr` hands out unique temp names (`sub2`, `l3`,
+ * `m4`, `i3`, `k4`) so nested blocks never collide. `idxExpr` is the element index / map-key argument the
+ * enclosing list / map loop supplies (empty for top / field). Mirrors the interpreter's outType check +
+ * the (now-deleted) per-position decoders, but TOTAL over the grammar (opt(named)/arr(arr)/map(opt)…) and
+ * inlined — the type is baked all the way through by the TS compiler, not the target monomorphizer.
  */
-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));
+function renderRustDeBox(plan, srcExpr, ctr, indent, fail, idxExpr = "") {
+    const I = indent;
+    const I1 = indent + "    ";
     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 ml = rustStrLit(plan.model);
+    const fl = rustStrLit(plan.field);
+    const nl = rustStrLit(plan.expectedType);
+    const opt = plan.optDepth > 0;
+    const mismatch = fail(`de_type_mismatch(${ml}, ${fl}, ${nl}, actual_wire_type, raw_value)`);
+    const missing = fail(`de_missing_field(${ml}, ${fl}, ${nl})`);
+    // the probe expression for this node's access + a value-kind suffix (string/number/bool/row/list).
+    const probe = (suffix) => {
+        switch (plan.access.from) {
+            case "top":
+                return `${srcExpr}.as_${suffix}()`;
+            case "field":
+                return `${srcExpr}.probe_${suffix}(${rustStrLit(plan.access.key)})`;
+            case "elem":
+                return `${srcExpr}.elem_${suffix}(${idxExpr})`;
+            case "mapval":
+                return `${srcExpr}.probe_${suffix}(${idxExpr})`;
         }
-        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}) {
+    };
+    // wrap the decoded value in optDepth `Some(...)` layers (present ⇒ Some^N(v); absent/null ⇒ None).
+    const wrapSome = (expr) => {
+        let e = expr;
+        for (let i = 0; i < plan.optDepth; i++)
+            e = `Some(${e})`;
+        return e;
+    };
+    // the three non-Got Probe<T> arms (scalar string/bool, record, list, map): required ⇒ wrong/null
+    // mismatch + absent missing; optional ⇒ wrong mismatch, null/absent None.
+    const probeArms = opt
+        ? `${I1}Probe::Wrong { actual_wire_type, raw_value } => ${mismatch},\n${I1}Probe::Null { .. } | Probe::Absent => None,`
+        : `${I1}Probe::Wrong { actual_wire_type, raw_value }\n${I1}| Probe::Null { actual_wire_type, raw_value } => ${mismatch},\n${I1}Probe::Absent => ${missing},`;
+    if (plan.k === "scalar") {
+        if (plan.scalar === "int" || plan.scalar === "float") {
+            const rustT = plan.scalar === "int" ? "i64" : "f64";
+            const numArms = opt
+                ? `${I1}NumProbe::Wrong { actual_wire_type, raw_value } => ${mismatch},\n${I1}NumProbe::Null { .. } | NumProbe::Absent => None,`
+                : `${I1}NumProbe::Wrong { actual_wire_type, raw_value }\n${I1}| NumProbe::Null { actual_wire_type, raw_value } => ${mismatch},\n${I1}NumProbe::Absent => ${missing},`;
+            return `match ${probe("number")} {
 ${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}    Ok(n) => ${wrapSome("n")},
+${I1}    Err(_) => ${fail(`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},
+${numArms}
 ${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},
+        const meth = plan.scalar === "string" ? "string" : "bool";
+        return `match ${probe(meth)} {
+${I1}Probe::Got(v) => ${wrapSome("v")},
+${probeArms}
 ${I}}`;
     }
-    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},
+    if (plan.k === "record") {
+        const fieldInits = plan.fields
+            .map((f) => `${I1}    ${rustFieldName(f.name)}: ${renderRustDeBox(f.plan, `sub${id}`, ctr, `${I1}    `, fail)},`)
+            .join("\n");
+        return `match ${probe("row")} {
+${I1}Probe::Got(sub${id}) => ${wrapSome(`${plan.typeName} {
+${fieldInits}
+${I1}}`)},
+${probeArms}
 ${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());
+    if (plan.k === "list") {
+        const elemExpr = renderRustDeBox(plan.elem, `l${id}`, ctr, `${I1}        `, fail, `i${id}`);
+        return `match ${probe("list")} {
+${I1}Probe::Got(l${id}) => ${wrapSome(`{
+${I1}    let mut acc${id} = Vec::with_capacity(l${id}.len());
 ${I1}    for i${id} in 0..l${id}.len() {
-${I1}        acc.push(${elemExpr});
+${I1}        acc${id}.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},
+${I1}    acc${id}
+${I1}}`)},
+${probeArms}
 ${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();
+    // map(V): the wire value is a producer map (a DynamoDB "M"); enumerate its keys, decode each value as V.
+    const valExpr = renderRustDeBox(plan.value, `m${id}`, ctr, `${I1}        `, fail, `&k${id}`);
+    return `match ${probe("row")} {
+${I1}Probe::Got(m${id}) => ${wrapSome(`{
+${I1}    let mut acc${id} = 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}        acc${id}.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},
+${I1}    acc${id}
+${I1}}`)},
+${probeArms}
 ${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()}`;
+/** returnErrFail — the default de-box mismatch control flow: propagate the structured Error Value out of
+ * the enclosing runner (fail/retry componentRef results + map/fanout element de-box, which fails closed
+ * regardless of elementPolicy — matching the interpreter's whole-node outType throw). */
+const returnErrFail = (errValueExpr) => `return Err(${errValueExpr})`;
+/** renderResultDeBox — inline strict de-box of a whole result WIRE (`srcExpr`, a WireValue) into its
+ * native value, from the TOTAL SSoT plan for `ref` at the top position. `fail` selects the mismatch
+ * control flow. This is the ONE de-box call the runner arms share (componentRef result + map/fanout
+ * element) — no per-position predicate, no helper decode fn. */
+function renderResultDeBox(ref, srcExpr, nodeId, plan, indent, fail = returnErrFail) {
+    return renderRustDeBox(buildDeBoxPlan(ref, { from: "top" }, { model: nodeId, field: nodeId, plan }), srcExpr, { n: 0 }, indent, fail);
 }
 /** mapFanoutElemRef — the element ROW TypeRef a map/fanout node decodes (the per-element record). */
 function mapFanoutElemRef(node, typedNodes, plan) {
@@ -438,185 +383,6 @@ function mapFanoutElemRef(node, typedNodes, plan) {
         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";
-}
-/**
- * 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 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()}`;
-}
-/**
- * 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 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;
-    }
-    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);
-    }
-}
-/** 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.`);
-        }
-        // 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).`);
-        }
-        // 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.`);
-        }
-    }
-}
 function staticArrElems(node) {
     if (node === null || typeof node !== "object" || Array.isArray(node))
         return null;
@@ -971,72 +737,6 @@ fn bc_expr_str_gt(a: &str, b: &str) -> bool { bc_expr_cmp_cp(a, b) == std::cmp::
 #[allow(dead_code)]
 fn bc_expr_str_ge(a: &str, b: &str) -> bool { bc_expr_cmp_cp(a, b) != std::cmp::Ordering::Less }`;
 }
-// ── CONCRETE per-node row structs + row→outType copiers (mirror the Go concrete contract) ──────────
-//
-// Each covered node has a CONCRETE row struct `RawRowNR<Comp><Node>` whose fields are the node's projected
-// outType fields (typed, flattened). 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). 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) {
-        if ("cond" in n)
-            continue; // #108: a cond node has no handler-result row (pure Expression).
-        const ref = typedNodes.get(n.id);
-        if ("fanout" in n) {
-            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 rows: Vec<${rawElemStructName(comp.name, n.id)}>,\n}`);
-            continue;
-        }
-        if ("map" in n) {
-            const arrRef = ref;
-            const elemRowRef = mapElemRowRef(n, arrRef, plan);
-            parts.push(emitOneRowStruct(rawElemStructName(comp.name, n.id), elemRowRef, plan));
-            parts.push(`// ${rawRowStructName(comp.name, n.id)} — the BATCH row for map '${n.id}': the aligned per-element rows.\n` +
-                `#[derive(Default)]\npub struct ${rawRowStructName(comp.name, n.id)} {\n    pub 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.
- * 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).`);
-    lines.push(`#[derive(Default)]`);
-    lines.push(`pub struct ${name} {`);
-    if (ref.kind === "named") {
-        const decl = findDecl(plan, ref.name);
-        for (const f of decl.fields) {
-            lines.push(`    pub ${rustFieldName(f.name)}: ${renderTypeRef(f.type)}, // ${JSON.stringify(f.name)}`);
-        }
-    }
-    else {
-        lines.push(`    pub val: ${renderTypeRef(ref)},`);
-    }
-    lines.push(`}`);
-    return lines.join("\n");
-}
-/** emitRowCopy — the statement copying a concrete row's typed fields into the node's outType local
- * `target` (a value of Rust type renderTypeRef(ref)). Named: struct literal from the row's moved fields;
- * scalar/arr/opt: `.val`. `rowExpr` is the concrete row VALUE (moved). No dynamic read — pure move/copy. */
-function emitRowMove(target, rowExpr, ref, plan) {
-    if (ref.kind === "named") {
-        const decl = findDecl(plan, ref.name);
-        const inits = decl.fields.map((f) => `${rustFieldName(f.name)}: ${rowExpr}.${rustFieldName(f.name)}`).join(", ");
-        return `${target} = ${ref.name} { ${inits} };`;
-    }
-    return `${target} = ${rowExpr}.val;`;
-}
 /**
  * boundRustType (change #3 — typed `bound`) — the CONCRETE Rust type of a covered node's `bound` handler
  * param (bc#90 / runtime-free). `bound` is the parent-produced key (the bindField value); it replaces the
@@ -1084,23 +784,19 @@ function emitHandlerTrait(comp, typedNodes, plan, ap) {
     const fnKwFor = (nodeId) => (ap.nodeIsAsync(nodeId) ? "async fn" : "fn");
     const lines = [];
     lines.push(`// ${handlerTraitName(comp.name)} — the CONCRETE per-component handler seam: one typed method`);
-    lines.push(`// per covered node (native ports struct IN, concrete row struct OUT). No generic boxed-ports`);
-    lines.push(`// / boxed-value / dynamic accessor crosses the covered boundary — the consumer implements each`);
-    lines.push(`// node_* with a decode of its own wire payload into the concrete row (see INTEGRATION.md §6).`);
+    lines.push(`// per covered node (native ports struct IN, WIRE value OUT). No generic boxed-ports / boxed-value`);
+    lines.push(`// / dynamic accessor crosses the covered boundary — the consumer implements each node_* by`);
+    lines.push(`// returning its own wire payload as a WireValue; the generated inline de-box turns that into the`);
+    lines.push(`// node's concrete native result (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;`);
+    // every covered node returns the consumer's WIRE (a single associated `Wire: WireValue`) — the producer's
+    // datum at the node's result-consumption point; the generated inline de-box classifies it against the
+    // STATICALLY declared type. A batched map returns one wire per element (Vec); a fanout returns the aligned
+    // per-id wires (Vec<Option<Wire>> — None = a DANGLING id). The `+ Send` bound lets the wire cross the
+    // parallel-stage runner's scoped fan-out threads.
+    const hasHandler = comp.body.some((n) => !("cond" in n));
+    if (hasHandler)
+        lines.push(`    type Wire: WireValue + Send;`);
     for (const n of comp.body) {
         if ("cond" in n)
             continue; // #108: a cond node has no handler method (pure Expression).
@@ -1108,29 +804,23 @@ 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. 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).
+            // fanout (v3): one batched dispatch of the deduped id list, returning the aligned element WIRES the
+            // runner de-boxes 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 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>;`);
+            lines.push(`    ${fnKw} ${method}(&self, ports: &${portsT}, bound: ${bt}) -> Result<Vec<Option<Self::Wire>>, 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);
-            // 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);
+            // a map returns the element WIRE(s): batched → Vec<Self::Wire>, non-batched → Self::Wire.
+            const retT = batched ? "Vec<Self::Wire>" : "Self::Wire";
             lines.push(`    ${fnKw} ${method}(&self, ports: &${portsT}, bound: ${bt}) -> Result<${retT}, BehaviorError>;`);
             continue;
         }
-        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(`    ${fnKw} ${method}(&self, ports: &${portsStructName(comp.name, n.id)}, bound: ${bt}) -> Result<Self::Wire, BehaviorError>;`);
     }
     lines.push(`}`);
     return lines.join("\n");
@@ -1172,9 +862,8 @@ function mapElemRowRef(node, arrRef, plan) {
 }
 /**
  * emitMapElemMaterializers — for each covered map...into node, emit the AUGMENTED-element copier: copy
- * the over element's typed fields + move the `into` field from the concrete per-element handler row
- * (RawElemNR). Pure struct field assignment — NO dynamic value read (the handler already produced the
- * typed into row).
+ * the over element's typed fields + place the already-de-boxed `into` value into its field. Pure struct
+ * field assignment — NO dynamic value read (the inline de-box already produced the typed `into` value).
  */
 function emitMapElemMaterializers(comp, typedNodes, plan) {
     const parts = [];
@@ -1196,7 +885,6 @@ function emitMapElemMaterializers(comp, typedNodes, plan) {
         const overFields = decl.fields.filter((f) => f.name !== intoKey);
         const overElemTy = mapOverElemType(comp, n, typedNodes, plan);
         const fn = mapElemMaterializerName(comp.name, n.id);
-        const elemRowGo = rawElemStructName(comp.name, n.id);
         const intoRowRef = mapElemRowRef(n, arrRef, plan);
         const inits = [];
         // Copy scalars (i64/f64/bool) copy directly; String/named/arr/opt clone (clippy clone_on_copy clean).
@@ -1204,15 +892,12 @@ function emitMapElemMaterializers(comp, typedNodes, plan) {
             const isCopy = f.type.kind === "scalar" && (f.type.scalar === "int" || f.type.scalar === "float" || f.type.scalar === "bool");
             inits.push(`        ${rustFieldName(f.name)}: over.${rustFieldName(f.name)}${isCopy ? "" : ".clone()"},`);
         }
-        // move the into field off the concrete element row (named → struct literal; scalar/arr/opt → .val).
-        const intoValue = intoRowRef.kind === "named"
-            ? `${intoRowRef.name} { ${findDecl(plan, intoRowRef.name).fields.map((f) => `${rustFieldName(f.name)}: into.${rustFieldName(f.name)}`).join(", ")} }`
-            : `into.val`;
+        // the `into` param is the already-de-boxed into value (its native type) — drop it straight in.
         parts.push(`#[allow(dead_code)]
-fn ${fn}(over: &${overElemTy}, into: ${elemRowGo}) -> ${elemRef.name} {
+fn ${fn}(over: &${overElemTy}, into: ${renderTypeRef(intoRowRef)}) -> ${elemRef.name} {
     ${elemRef.name} {
 ${inits.join("\n")}
-        ${rustFieldName(intoKey)}: ${intoValue},
+        ${rustFieldName(intoKey)}: into,
     }
 }`);
         void intoField;
@@ -1739,11 +1424,11 @@ function emitNativeRawRunner(comp, plan, ap) {
     const lines = [];
     lines.push(`// run_native_raw_struct_${fn} — the STRUCT-RETURNING combined read (bc#77/#87/#94): the fully`);
     lines.push(`// de-plumbed CONCRETE path. Generic over the per-component CONCRETE ${handlerTraitName(comp.name)} trait,`);
-    lines.push(`// whose node_* methods take the node's native ports struct and return the concrete per-node row`);
-    lines.push(`// struct (typed fields = the outType). The runner builds each ports struct by direct native`);
-    lines.push(`// construction (a simple string port lowers to a native Rust expr), dispatches the concrete`);
-    lines.push(`// node_* method, and reads row.<field> DIRECTLY into the node's outType struct cell — no boxed`);
-    lines.push(`// handler result, no generic enum crossing, no dispatch on a dynamic value on the covered plane. Node`);
+    lines.push(`// whose node_* methods take the node's native ports struct and return the node's result WIRE`);
+    lines.push(`// (Self::Wire: WireValue). The runner builds each ports struct by direct native construction (a`);
+    lines.push(`// simple string port lowers to a native Rust expr), dispatches the concrete node_* method, and`);
+    lines.push(`// de-boxes the result wire INLINE (match wire.as_*() { … } fully unrolled — no decode helper) into`);
+    lines.push(`// the node's outType struct cell — no boxed handler result, no generic enum crossing, no dispatch on a dynamic value on the covered plane. Node`);
     lines.push(`// results are typed struct cells; a relation child reads the parent's REAL struct result via`);
     lines.push(`// direct field access (child-present decision from the real parent value — relationSingle /`);
     lines.push(`// connection converge). A real-concurrency stage (bc#87) is static parallel orchestration —`);
@@ -1847,57 +1532,33 @@ 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(", ")} };`);
-        // 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;
+        // uniform seam: every covered node returns a single result WIRE (Self::Wire); the inline de-box
+        // (renderResultDeBox) classifies it against the STATICALLY declared result type and produces the
+        // structured Error Value on a mismatch (byte-equal codes to run_behavior's outType check, so ≡ holds).
         if (meta.policy === "continue") {
-            // 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}}`);
-            }
+            // continue: a failed node (leaf failure OR de-box mismatch) produces no Port — the downstream Skip
+            // propagation is what `continue` means. The inline de-box's mismatch breaks the labeled block (a
+            // local skip, NOT a runner-wide propagate); only a clean decode commits. (Covered componentRef nodes
+            // are always 'fail' policy today — this arm is defensive.)
+            const label = `debox_${s}`;
+            const contFail = (e) => `break '${label} Err(${e})`;
+            lines.push(`${indent}if let Ok(wire_${s}) = handlers.${nodeMethodName(node.id)}(&ports_${s}, ${boundArg})${awaitSfx} {`);
+            lines.push(`${indent}    let decoded_${s}: Result<${renderTypeRef(ref)}, BehaviorError> = '${label}: {`);
+            lines.push(`${indent}        Ok(${renderResultDeBox(ref, `wire_${s}`, node.id, plan, `${indent}        `, contFail)})`);
+            lines.push(`${indent}    };`);
+            lines.push(`${indent}    if let Ok(val_${s}) = decoded_${s} {`);
+            lines.push(`${indent}        *${typedCell(node.id)}.borrow_mut() = val_${s};`);
+            lines.push(`${indent}        produced_${s}.set(true);`);
+            lines.push(`${indent}    }`);
+            lines.push(`${indent}}`);
         }
         else {
             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}let wire_${s} = 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}*${typedCell(node.id)}.borrow_mut() = ${renderResultDeBox(ref, `wire_${s}`, node.id, plan, indent)};`);
             lines.push(`${indent}produced_${s}.set(true);`);
         }
         for (const c of closers)
@@ -2023,25 +1684,11 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
     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);
-        // 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);`);
+        // every member's thread returns the result WIRE (a single Self::Wire); the ascending COMMIT phase
+        // de-boxes it (so the wire — not the decode — is what crosses the scoped threads).
+        lines.push(`        let slot_${s}: std::sync::Mutex<Option<Result<${hWire}, BehaviorError>>> = std::sync::Mutex::new(None);`);
     }
     lines.push(`        let mut ${jobsVar}: Vec<usize> = Vec::new();`);
     refMembers.forEach((i, slot) => {
@@ -2080,51 +1727,28 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
         const ref = typedNodes.get(node.id);
         lines.push(`        if ports_${s}.is_some() {`);
         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") {
-            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(`            }`);
-            }
+            // continue: a failed member (leaf failure OR de-box mismatch) commits no Port (defensive — covered
+            // componentRef members are always 'fail' policy today).
+            const label = `debox_${s}`;
+            const contFail = (e) => `break '${label} Err(${e})`;
+            lines.push(`            if let Ok(wire_${s}) = out_${s} {`);
+            lines.push(`                let decoded_${s}: Result<${renderTypeRef(ref)}, BehaviorError> = '${label}: {`);
+            lines.push(`                    Ok(${renderResultDeBox(ref, `wire_${s}`, node.id, plan, "                    ", contFail)})`);
+            lines.push(`                };`);
+            lines.push(`                if let Ok(val_${s}) = decoded_${s} {`);
+            lines.push(`                    *${typedCell(node.id)}.borrow_mut() = val_${s};`);
+            lines.push(`                    produced_${s}.set(true);`);
+            lines.push(`                }`);
+            lines.push(`            }`);
         }
         else {
             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(`            let wire_${s} = 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(`            *${typedCell(node.id)}.borrow_mut() = ${renderResultDeBox(ref, `wire_${s}`, node.id, plan, "            ")};`);
             lines.push(`            produced_${s}.set(true);`);
         }
         lines.push(`        }`);
@@ -2161,11 +1785,11 @@ isAsync = false) {
     const portNames = Object.keys(m.ports);
     const elemArrRef = typedNodes.get(node.id);
     const elemName = renderTypeRef(elemArrRef.elem);
-    // 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) : "";
+    // each element is de-boxed strictly INLINE: the handler returns the per-element WIRE and the arm decodes
+    // it against the element ref (the `into` field's type for map...into, else the element type). A de-box
+    // mismatch fails closed regardless of elementPolicy (matching the interpreter's whole-node outType throw).
+    const elemDeBoxRef = mapElemRowRef(node, elemArrRef, plan);
+    const renderElemDeBox = (il) => renderResultDeBox(elemDeBoxRef, `er_${s}`, node.id, plan, il);
     // build the per-element CONCRETE native ports struct. `il` = indent inside the element loop.
     const buildPorts = (il) => {
         const out = [];
@@ -2225,28 +1849,23 @@ isAsync = false) {
         lines.push(`${indent}        Ok(r) => r,`);
         lines.push(`${indent}        Err(e) => return Err(op_failed(${rustStrLit(node.id)}, "fail", e)),`);
         lines.push(`${indent}    };`);
-        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}    if row_${s}.len() != want_${s} {`);
         lines.push(`${indent}        return Err(BehaviorError::new("MAP_BATCH_RESULT_MISMATCH", format!("map '{}': batched handler must return a list aligned to items (want {})", ${rustStrLit(node.id)}, want_${s})));`);
         lines.push(`${indent}    }`);
         if (hasInto) {
-            // zip the aligned batch rows onto each KEPT over element (into materializer). A record element's
-            // wire is de-boxed strictly first.
-            lines.push(`${indent}    let mut rows_iter_${s} = ${batchIter};`);
+            // zip the aligned per-element WIRES onto each KEPT over element: de-box the element wire strictly
+            // (into the `into` field's type) then materialize the augmented element.
+            lines.push(`${indent}    let mut rows_iter_${s} = row_${s}.into_iter();`);
             lines.push(`${indent}    for over_el_${s} in kept_${s}.iter() {`);
             lines.push(`${indent}        let er_${s} = rows_iter_${s}.next().expect("aligned batch row");`);
-            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}        let dec_${s} = ${renderElemDeBox(`${indent}        `)};`);
+            lines.push(`${indent}        built_${s}.push(${elemMat}(over_el_${s}, dec_${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 ${batchIter} {`);
-            if (elemDeBox)
-                lines.push(`${indent}        let er_${s} = ${decElemFn}(&er_${s})?;`);
-            lines.push(`${indent}        ${emitElemMove(`let el_${s}`, `er_${s}`, elemArrRef.elem, plan)}`);
+            // no-into: de-box each aligned per-element wire DIRECTLY into the element (result = kept elements).
+            lines.push(`${indent}    for er_${s} in row_${s}.into_iter() {`);
+            lines.push(`${indent}        let el_${s} = ${renderElemDeBox(`${indent}        `)};`);
             lines.push(`${indent}        built_${s}.push(el_${s});`);
             lines.push(`${indent}    }`);
         }
@@ -2271,16 +1890,14 @@ isAsync = false) {
             lines.push(`${indent}        Err(e) => return Err(op_failed(${rustStrLit(node.id)}, "fail", e)),`);
         }
         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})?;`);
+        // the element's wire is de-boxed strictly INLINE (fail-closed regardless of elementPolicy).
+        lines.push(`${indent}    let dec_${s} = ${renderElemDeBox(`${indent}    `)};`);
         if (hasInto) {
-            lines.push(`${indent}    built_${s}.push(${elemMat}(oel_${s}, er_${s}));`);
+            lines.push(`${indent}    built_${s}.push(${elemMat}(oel_${s}, dec_${s}));`);
         }
         else {
             lines.push(`${indent}    let _ = &oel_${s};`);
-            lines.push(`${indent}    ${emitElemMove(`let el_${s}`, `er_${s}`, elemArrRef.elem, plan)}`);
-            lines.push(`${indent}    built_${s}.push(el_${s});`);
+            lines.push(`${indent}    built_${s}.push(dec_${s});`);
         }
         lines.push(`${indent}}`);
     }
@@ -2349,11 +1966,9 @@ function emitFanoutArm(comp, node, atPos, typedNodes, plan, priorNodeAt, isAsync
     lines.push(`${indent}        Ok(r) => r,`);
     lines.push(`${indent}        Err(e) => return Err(op_failed(${rustStrLit(node.id)}, "fail", e)),`);
     lines.push(`${indent}    };`);
-    // 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);
+    // the handler returns the aligned per-id element WIRES (Vec<Option<Self::Wire>>); each present body is
+    // de-boxed strictly INLINE (a de-box mismatch fails closed). A DANGLING id is None → the zero element
+    // (empty dedupeKey), which the dangling drop excludes.
     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}    }`);
@@ -2362,11 +1977,10 @@ function emitFanoutArm(comp, node, atPos, typedNodes, plan, priorNodeAt, isAsync
     //    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 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}        let el_${s}: ${elemName} = match opt_er_${s} {`);
+    lines.push(`${indent}            Some(wire_${s}) => ${renderResultDeBox(elemRef, `wire_${s}`, node.id, plan, `${indent}            `)},`);
     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") {
         lines.push(`${indent}        if key_${s}.is_empty() { continue; }`);
@@ -2444,16 +2058,6 @@ function emitCondArm(comp, node, atPos, typedNodes, plan, priorNodeAt) {
         lines.push(cl);
     return lines.join("\n");
 }
-/** emitElemMove — move a concrete element row (RawElemNR, error already handled) into a fresh `let` local
- * of the element outType. Named → struct literal from moved fields; scalar/arr/opt → .val. */
-function emitElemMove(letBind, rowExpr, ref, plan) {
-    if (ref.kind === "named") {
-        const decl = findDecl(plan, ref.name);
-        const inits = decl.fields.map((f) => `${rustFieldName(f.name)}: ${rowExpr}.${rustFieldName(f.name)}`).join(", ");
-        return `${letBind} = ${ref.name} { ${inits} };`;
-    }
-    return `${letBind} = ${rowExpr}.val;`;
-}
 /**
  * emitProducedAwareValue — the #86 part 1 produced-aware output lowering (rust twin of the go one).
  */
@@ -2575,13 +2179,12 @@ ${emitStructSurface([])}
     // #108: reset the native-expr helper-usage accumulator (set by the cond/guard compiler).
     rustExprUsed.helpers = false;
     const structs = [];
-    const rowStructs = [];
     const handlerTraits = [];
     const inStructs = [];
     const elemMaterializers = [];
-    // the generated strict de-box functions (deduped by named type across all covered components).
-    const decodeFns = [];
-    const decodeEmitted = new Set();
+    // every covered node returns a WireValue the inline de-box classifies — the wire seam (probe enums +
+    // WireValue/WireRow/WireList traits) is emitted once whenever any handler node exists.
+    const anyWire = native.some((c) => c.body.some((n) => !("cond" in n)));
     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.
@@ -2599,11 +2202,7 @@ ${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)
@@ -2618,9 +2217,9 @@ ${emitStructSurface([])}
 // relationKind:single children), emitted ONLY as a STRUCT-returning runner GENERIC over a per-component
 // CONCRETE handler trait (HandlerNR<comp>): native ports struct IN (direct construction — every port is a
 // CONCRETE Rust value: String / bool / Vec<&str> projection / i64 limit — NO boxed Value, NO by-name
-// accessor); the handler takes a typed produced-aware 'bound' Option and returns the node's CONCRETE row
-// struct (typed fields = the projected outType), and the runner reads row.<field> DIRECTLY into the node's
-// outType struct. The covered plane carries NO bc-runtime reference at all — failures use the LOCAL
+// accessor); the handler takes a typed produced-aware 'bound' Option and returns the node's result WIRE
+// (Self::Wire: WireValue), and the runner de-boxes it INLINE (fully-unrolled probe/match — no decode helper,
+// no output recursion) into the node's outType struct. The covered plane carries NO bc-runtime reference at all — failures use the LOCAL
 // BehaviorError (same codes, byte-equal to run_behavior). INLINE sequential (no plan driver) so a relation
 // child reads the parent's REAL struct result via direct field access and the child-present decision is
 // made from the real parent value — relationSingle / connection converge with run_behavior (fixes
@@ -2641,16 +2240,10 @@ use std::cell::RefCell;`;
         structs.some((r) => r.trim().length > 0)
             ? `// Native ports structs (one per componentRef node; typed per the static port type — CONCRETE).\n${structs.filter((r) => r.trim().length > 0).join("\n\n")}`
             : undefined,
-        rowStructs.some((r) => r.trim().length > 0)
-            ? `// CONCRETE per-node row structs (typed fields = the node's outType; + error signal).\n${rowStructs.filter((r) => r.trim().length > 0).join("\n\n")}`
-            : undefined,
         `// CONCRETE per-component input structs (fields = inputPorts).\n${inStructs.join("\n\n")}`,
-        `// CONCRETE per-component handler traits (one node_* method per node — native ports IN, row OUT).\n${handlerTraits.join("\n\n")}`,
-        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")}`
+        `// CONCRETE per-component handler traits (one node_* method per node — native ports IN, WIRE value OUT).\n${handlerTraits.join("\n\n")}`,
+        anyWire
+            ? `// strict de-box wire seam — the consumer implements WireValue (+ WireRow/WireList reached via\n// as_row/as_list) over its wire payload (variant classification); the generated INLINE de-box owns\n// strictness (required/optional, present/absent, error assembly, fail-closed). Concrete enums +\n// monomorphized traits — no boxed value, no trait object, no heap allocation crosses the seam.\n${emitRustProbeWireTypes()}`
             : undefined,
         elemMaterializers.length
             ? `// map augmented-element copiers (pure struct field assignment — no dynamic value read).\n${elemMaterializers.join("\n\n")}`
@@ -2683,25 +2276,14 @@ 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.
+    // every covered node returns a WireValue the inline de-box classifies — so the scripted wire adapter is
+    // needed whenever any component has a handler node.
+    const anyDeBox = native.some((c) => c.body.some((n) => !("cond" in n)));
+    // scripted wire adapter (TEST glue): wraps a scripted Value as a WireValue (+ WireRow/WireList reached
+    // via as_row/as_list) and classifies each datum's native type into a DynamoDB-flavored wire tag
+    // (S/N/BOOL/L/M/NULL). A real consumer implements WireValue over its own AttributeValue payload; this
+    // drives the generated inline de-box from the same scripted vectors run_behavior uses — so the
+    // actualWireType observed in a mismatch is the PRODUCER tag.
     const wireAdapter = anyDeBox
         ? `// ── scripted wire adapter (TEST glue) ──
 fn scripted_wire_tag(v: &Value) -> String {
@@ -2793,6 +2375,37 @@ pub struct ScriptedWireList {
     items: Vec<Value>,
 }
 
+// ScriptedWireValue — a scripted node result wrapped as the uniform WireValue: a top value is always
+// present (Some), so as_* never observes Absent; a scripted null is Value::Null → Probe::Null.
+pub struct ScriptedWireValue {
+    v: Value,
+}
+
+impl ScriptedWireValue {
+    pub fn new(v: Value) -> Self {
+        ScriptedWireValue { v }
+    }
+}
+
+impl WireValue for ScriptedWireValue {
+    type Row = ScriptedWireRow;
+    fn as_string(&self) -> Probe<String> {
+        probe_string_val(Some(&self.v))
+    }
+    fn as_number(&self) -> NumProbe {
+        probe_number_val(Some(&self.v))
+    }
+    fn as_bool(&self) -> Probe<bool> {
+        probe_bool_val(Some(&self.v))
+    }
+    fn as_row(&self) -> Probe<ScriptedWireRow> {
+        probe_row_val(Some(&self.v))
+    }
+    fn as_list(&self) -> Probe<ScriptedWireList> {
+        probe_list_val(Some(&self.v))
+    }
+}
+
 impl WireRow for ScriptedWireRow {
     type List = ScriptedWireList;
     fn keys(&self) -> Vec<String> {
@@ -2837,10 +2450,8 @@ impl WireList for ScriptedWireList {
     }
 }`
         : "";
-    // ── concrete scripted handler: implements every HandlerNR<comp> trait by decoding a scripted Value
-    // into the concrete per-node row (the generic scripted-source queue meets the concrete seam). ──
-    const decodeFns = [];
-    const emittedDecode = new Set();
+    // ── concrete scripted handler: implements every HandlerNR<comp> trait by returning the scripted ok
+    // Value as a WireValue (the generic scripted-source queue meets the uniform wire seam). ──
     const traitImpls = [];
     for (const c of native) {
         const ap = asyncPlans.get(c.name);
@@ -2860,15 +2471,11 @@ impl WireList for ScriptedWireList {
             // 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) {
+                // fanout: return the aligned per-id element WIRES (Vec<Option<ScriptedWireValue>>); a null aligned
+                // body is a DANGLING id → None (the covered runner maps it to the zero element).
                 const f = n.fanout;
-                const elemDeBox = mapFanoutElemDeBoxEligible(n, typedNodes, plan);
-                const elemT = rawElemStructName(c.name, n.id);
-                const batchT = rawRowStructName(c.name, n.id);
                 const portsT = `${portsStructName(c.name, n.id)}Batch`;
-                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> {
+                methods.push(`    ${fnKw} ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Result<Vec<Option<ScriptedWireValue>>, 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));
@@ -2878,201 +2485,91 @@ impl WireList for ScriptedWireList {
             .into_iter()
             .map(|ev| match ev {
                 Value::Null => None,
-                _ => Some(ScriptedWireRow::new(ev)),
+                _ => Some(ScriptedWireValue::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() };
-        let rows = arr
-            .iter()
-            .map(|ev| match ev {
-                Value::Null => ${elemT}::default(),
-                _ => ${elemDecode}(ev),
-            })
-            .collect();
-        Ok(${batchT} { rows })
     }`);
                 continue;
             }
             if ("map" in n) {
+                // map: batched → one WIRE per element (Vec<ScriptedWireValue>); non-batched → one element WIRE.
                 const m = n.map;
                 const batched = m.batched === true;
-                const arrRef = ref;
-                const elemDeBox = mapFanoutElemDeBoxEligible(n, typedNodes, plan);
-                const elemT = rawElemStructName(c.name, n.id);
-                const batchT = rawRowStructName(c.name, n.id);
                 const portsT = batched ? `${portsStructName(c.name, n.id)}Batch` : portsStructName(c.name, n.id);
-                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}) -> Result<${batchT}, BehaviorError> {
+                    methods.push(`    ${fnKw} ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Result<Vec<ScriptedWireValue>, 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 rows = arr.iter().map(${elemDecode}).collect();
-        Ok(${batchT} { rows })
+        let wires = arr.into_iter().map(ScriptedWireValue::new).collect();
+        Ok(wires)
     }`);
                 }
                 else {
-                    methods.push(`    ${fnKw} ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Result<${elemT}, BehaviorError> {
+                    methods.push(`    ${fnKw} ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Result<ScriptedWireValue, 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 v = ok.unwrap_or(Value::Null);
-        Ok(${elemDecode}(&v))
+        Ok(ScriptedWireValue::new(ok.unwrap_or(Value::Null)))
     }`);
                 }
                 continue;
             }
+            // componentRef: return the whole result WIRE (one ScriptedWireValue wrapping the scripted ok Value);
+            // the covered runner's INLINE de-box classifies it. A real consumer returns its own wire payload.
             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 (#129/#141 fixtures): the scripted leaf can ECHO an input PORT back as its result wire, so the
+            // input-port value flows into the de-boxed result and the runtime non-vacuity asserts survive.
+            const echoBranches = [];
+            if (ref.kind === "named") {
+                const decl = findDecl(plan, ref.name);
+                const field = decl !== undefined && decl.fields.length === 1 ? decl.fields[0] : undefined;
+                const fieldRust = field !== undefined ? renderTypeRef(field.type) : null;
+                const recordRust = renderTypeRef(ref);
+                for (const pn of Object.keys(node.ports)) {
+                    let portRust = null;
+                    try {
+                        portRust = portFieldRustType(node.ports[pn], c, plan, typedNodes, `echo port '${pn}'`);
                     }
-                })();
-                // 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`;
-                        }
+                    catch {
+                        portRust = null;
+                    }
+                    if (portRust === recordRust) {
+                        // the port IS the whole record → echo it DIRECTLY (matching run_behavior's plain echo:port).
+                        const own = typeRefIsCopy(ref) ? `ports.${portFieldName(pn)}` : `ports.${portFieldName(pn)}.clone()`;
+                        echoBranches.push(`        if echo == ${rustStrLit(pn)} {\n            let tv = ${own};\n            return Ok(ScriptedWireValue::new(${serializeTyped("tv", ref, plan)}));\n        }`);
+                    }
+                    else if (fieldRust !== null && field !== undefined && portRust === fieldRust) {
+                        // 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()`;
+                        echoBranches.push(`        if echo == ${rustStrLit(pn)} {\n            let tv = ${own};\n            return Ok(ScriptedWireValue::new(Value::Obj(vec![(${rustStrLit(field.name)}.to_string(), ${serializeTyped("tv", field.type, plan)})])));\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): 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");
+            else if (ref.kind === "arr" && Object.prototype.hasOwnProperty.call(node.ports, "items")) {
+                // #129: an arr node with an `items` port echoes the NATIVE port array (serialized element-by-element
+                // into a Value::Arr) so the node→leaf array dataflow test is non-vacuous.
+                const elemRef = ref.elem;
+                echoBranches.push(`        if echo == "items" {\n            let tv = Value::Arr(ports.${portFieldName("items")}.iter().map(|e| { let ev = e.clone(); ${serializeTyped("ev", elemRef, plan)} }).collect());\n            return Ok(ScriptedWireValue::new(tv));\n        }`);
+            }
+            const canEcho = echoBranches.length > 0;
             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> {
+            const echoBlock = canEcho ? `${echoBranches.join("\n")}\n` : "";
+            methods.push(`    ${fnKw} ${nodeMethodName(node.id)}(&self, ${portsParam}: &${portsStructName(c.name, node.id)}, _bound: ${bt}) -> Result<ScriptedWireValue, BehaviorError> {
         let ${okBind} = self.next(${rustStrLit(node.component)}).ok_or_else(|| unknown_component(${rustStrLit(node.component)}))?;
         if is_err {
             return Err(leaf_failure(err));
-        }${echoBranch}
-        let v = ok.unwrap_or(Value::Null);
-        Ok(${decode}(&v))
+        }
+${echoBlock}        Ok(ScriptedWireValue::new(ok.unwrap_or(Value::Null)))
     }`);
         }
-        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` : "";
+        const cHasHandler = c.body.some((n) => !("cond" in n));
+        const wireAssoc = cHasHandler ? `    type Wire = ScriptedWireValue;\n` : "";
         traitImpls.push(`impl ${handlerTraitName(c.name)} for ScriptedNativeRaw {\n${wireAssoc}${methods.join("\n")}\n}`);
     }
     const arms = native
@@ -3218,13 +2715,10 @@ ${marshallers}
 
 ${emitMarshalHelpers()}
 
-// per-node concrete-row decoders (scripted Value -> RawRowNR_/RawElemNR_ struct).
-${decodeFns.join("\n\n")}
-
 // input decoders (generic &[(String,Value)] -> concrete InNR_<comp>; TEST glue, one decode at the boundary).
 ${inDecoders}
 
-// scripted wire adapter (TEST glue) — wraps a scripted Value as a WireRow the generated de-box probes.
+// scripted wire adapter (TEST glue) — wraps a scripted Value as a WireValue the generated inline de-box probes.
 ${wireAdapter}
 
 ${adapter}
@@ -3315,31 +2809,6 @@ function emitInDecoder(comp, plan) {
     lines.push(`}`);
     return lines.join("\n");
 }
-/** emitDecodeRow — emit (once, deduped) a decoder `decode_row_<comp>_<node><suffix>(v: &Value) -> <rowT>`
- * that materializes the scripted ok Value into the concrete row struct. Named: reuse the Value->struct
- * marshaller + move fields; scalar/arr/opt: materialize into .val. TEST glue only. */
-function emitDecodeRow(compName, nodeId, rowT, ref, plan, emitted, out, suffix) {
-    const fn = `decode_row_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}${suffix.toLowerCase()}`;
-    if (emitted.has(fn))
-        return fn;
-    emitted.add(fn);
-    const lines = [];
-    lines.push(`fn ${fn}(v: &Value) -> ${rowT} {`);
-    if (ref.kind === "named") {
-        const decl = findDecl(plan, ref.name);
-        lines.push(`    let t = marshal_${ref.name}(v).expect("scripted row decode");`);
-        const inits = decl.fields.map((f) => `${rustFieldName(f.name)}: t.${rustFieldName(f.name)}`).join(", ");
-        lines.push(`    ${rowT} { ${inits} }`);
-    }
-    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 }`);
-    }
-    lines.push(`}`);
-    out.push(lines.join("\n"));
-    return fn;
-}
 export const rustTypedNativeEmitter = {
     language: "rust-typed-native",
     classification: "codegen", // native: 型付きフラットコード生成・IR/dict 非在（#128/A6）