behavior-contracts 0.8.6 → 0.8.8

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

@@ -5,7 +5,20 @@ import { goTypedInternals } from "./emit-shared-go-typed.js";
 import { buildTypePlan, deriveTypeRef, findDecl, inputPortIsOptional, inputPortTypeRef } from "./typed.js";
 import { concurrencyPlan, execPlan, analyzeSequentialOps, classifyExpr, buildComponentPlan, } from "./straightline.js";
 import { NativeExprCompiler } from "./native-expr.js";
+import { buildDeBoxPlan, notationOfRef } from "./emit-shared-debox.js";
 const PKG = "dslcontracts";
+/** resolveGoWire — the CONCRETE consumer wire type names the de-box classifies a node result against
+ * (bc#141). Default (no option) → the in-package convention names, unqualified. A configured `import`
+ * qualifies the names with the imported package's selector so a consumer can keep its wire types in its
+ * own package. `value`/`row`/`list` name the WireValue / WireRow / WireList concrete types; the covered
+ * runner + the generated Probe result structs reference them by these names. */
+function resolveGoWire(ctx) {
+    const w = ctx.goWire;
+    if (w === undefined)
+        return { value: "WireValue", row: "WireRow", list: "WireList" };
+    const sel = w.import !== undefined ? `${w.import.split("/").pop().replace(/[^A-Za-z0-9_]/g, "_")}.` : "";
+    return { value: `${sel}${w.value}`, row: `${sel}${w.row}`, list: `${sel}${w.list}`, import: w.import };
+}
 /** goErr — build the LOCAL concrete error value for a behavior/plan failure on the covered read
  * plane (runtime-free). The covered module declares `type BehaviorError struct { Code, Message string }`
  * (see emitBehaviorErrorType); a `*BehaviorError` satisfies the runner's `error` return. This REPLACES
@@ -100,60 +113,184 @@ const { goFieldName, renderTypeRef, goScalar, serializeTyped, emitTypeDecls, emi
 function typedLocal(nodeId) {
     return `t_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
 }
-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;
-}
-/** goWireTypeForTop — the Go handler return type for a record-containing top's wire. */
-function goWireTypeForTop(top) {
-    switch (top.kind) {
-        case "named":
-            return "WireRow";
-        case "arr":
-            return "[]WireRow";
-        case "opt":
-            return "WireRow"; // a nil WireRow = None (opt admits absent)
+// ── strict de-box: the ONE inline renderer over the SSoT plan ─────────────────────────────
+//
+// A covered node result de-box is compiled INLINE at its consumption point from the language-neutral
+// SSoT walk (emit-shared-debox.ts `buildDeBoxPlan`). The handler returns the consumer's WIRE (a single
+// concrete WireValue — the producer's datum); the generated de-box classifies it against the STATICALLY
+// declared node type via the CONCRETE seam methods (WireValue.As* → the top; WireRow.Probe* → a record
+// field / map value; WireList.Elem* → a list element). 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. NO decodeWire_* helper, NO output-side
+// recursion, NO interface, NO generics, NO boxed Value: a nested record expands to a nested struct
+// build, a collection to a nested loop, and every method call resolves to a concrete consumer type.
+/** goTypeOfPlan — the CONCRETE Go type of a de-box plan node (base kind + `optDepth` `*` wraps). Equal to
+ * renderTypeRef of the ORIGINAL ref, but read off the language-neutral plan so the inline renderer can
+ * declare its temps / list-element / map-value locals without re-deriving the TypeRef. */
+function goTypeOfPlan(plan) {
+    let base;
+    switch (plan.k) {
+        case "scalar":
+            base = goScalar(plan.scalar);
+            break;
+        case "record":
+            base = plan.typeName;
+            break;
+        case "list":
+            base = `[]${goTypeOfPlan(plan.elem)}`;
+            break;
         case "map":
-            return "map[string]WireRow";
+            base = `map[string]${goTypeOfPlan(plan.value)}`;
+            break;
     }
+    return "*".repeat(plan.optDepth) + base;
 }
-/** 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, so 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(",")}}`;
+/**
+ * renderGoDeBox — the ONE inline, recursive strict de-box renderer (Go). Folds a language-neutral
+ * {@link DeBoxPlan} (the SSoT walk) into FLAT Go STATEMENTS that decode the wire obtained by probing
+ * `srcExpr` per the node's access (top → `As*()`, field → `Probe*(key)`, elem → `Elem*(i)`, mapval →
+ * `Probe*(k)`) and assign the decoded native value into the lvalue `target`. The recursion runs HERE at
+ * generation time (walking the plan), so the emitted Go is fully unrolled: NO `decodeWire_*` helper, NO
+ * output-side recursion — a nested record expands to a nested struct build, a nested collection to a
+ * nested loop. A required-position mismatch runs `fail(...)` (default: `return <zero>, de_*(...)`); an
+ * optional position (optDepth>0) leaves the target pointer nil on absent/null. `ctr` hands out unique
+ * temp suffixes 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,
+ * 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, and every seam call resolves to a CONCRETE consumer type (no dispatch).
+ */
+function renderGoDeBox(plan, target, srcExpr, ctr, indent, fail, idxExpr = "") {
+    const I = indent;
+    const I1 = indent + "\t";
+    const I2 = indent + "\t\t";
+    const id = ctr.n++;
+    const ml = JSON.stringify(plan.model);
+    const fl = JSON.stringify(plan.field);
+    const nl = JSON.stringify(plan.expectedType);
+    const opt = plan.optDepth > 0;
+    const pv = `p${id}`;
+    const kindSuffix = plan.k === "list" ? "List" : plan.k === "scalar" ? (plan.scalar === "string" ? "String" : plan.scalar === "bool" ? "Bool" : "Number") : "Row";
+    // the probe call for this node's access (top → As*, field/mapval → Probe*(key), elem → Elem*(i)).
+    const probeCall = (() => {
+        switch (plan.access.from) {
+            case "top":
+                return `${srcExpr}.As${kindSuffix}()`;
+            case "field":
+                return `${srcExpr}.Probe${kindSuffix}(${JSON.stringify(plan.access.key)})`;
+            case "elem":
+                return `${srcExpr}.Elem${kindSuffix}(${idxExpr})`;
+            case "mapval":
+                return `${srcExpr}.Probe${kindSuffix}(${idxExpr})`;
         }
+    })();
+    const mismatch = fail(`deTypeMismatch(${ml}, ${fl}, ${nl}, ${pv}.ActualWireType, ${pv}.Raw)`);
+    const missing = fail(`deMissingField(${ml}, ${fl}, ${nl})`);
+    // wrap a decoded BASE-typed temp in optDepth `&` layers into target (present ⇒ &^N; absent/null ⇒ nil).
+    const wrapAssign = (baseTemp) => {
+        if (plan.optDepth === 0)
+            return [`${I1}${target} = ${baseTemp}`];
+        const out = [];
+        let cur = baseTemp;
+        for (let i = 0; i < plan.optDepth; i++) {
+            if (i === plan.optDepth - 1)
+                out.push(`${I1}${target} = &${cur}`);
+            else {
+                const w = `w${id}_${i}`;
+                out.push(`${I1}${w} := &${cur}`);
+                cur = w;
+            }
+        }
+        return out;
+    };
+    const lines = [];
+    lines.push(`${I}${pv} := ${probeCall}`);
+    lines.push(`${I}if ${pv}.Kind == probeGot {`);
+    if (plan.k === "scalar") {
+        if (plan.scalar === "string" || plan.scalar === "bool") {
+            if (plan.optDepth === 0)
+                lines.push(`${I1}${target} = ${pv}.Got`);
+            else {
+                lines.push(`${I1}sv${id} := ${pv}.Got`);
+                for (const l of wrapAssign(`sv${id}`))
+                    lines.push(l);
+            }
+        }
+        else {
+            // int/float: parse + range-check here (BC owns overflow) — no panic, a structured overflow error.
+            const parse = plan.scalar === "int" ? `strconv.ParseInt(${pv}.Got, 10, 64)` : `strconv.ParseFloat(${pv}.Got, 64)`;
+            lines.push(`${I1}n${id}, nErr${id} := ${parse}`);
+            lines.push(`${I1}if nErr${id} != nil {`);
+            lines.push(`${I2}${fail(`deOverflow(${ml}, ${fl}, ${nl}, ${pv}.ActualWireType, ${pv}.Got)`)}`);
+            lines.push(`${I1}}`);
+            for (const l of wrapAssign(`n${id}`))
+                lines.push(l);
+        }
+    }
+    else if (plan.k === "record") {
+        lines.push(`${I1}var rec${id} ${plan.typeName}`);
+        for (const f of plan.fields)
+            lines.push(renderGoDeBox(f.plan, `rec${id}.${goFieldName(f.name)}`, `${pv}.Got`, ctr, I1, fail));
+        for (const l of wrapAssign(`rec${id}`))
+            lines.push(l);
     }
+    else if (plan.k === "list") {
+        const elemGo = goTypeOfPlan(plan.elem);
+        lines.push(`${I1}list${id} := make([]${elemGo}, 0, ${pv}.Got.Len())`);
+        lines.push(`${I1}for i${id} := 0; i${id} < ${pv}.Got.Len(); i${id}++ {`);
+        lines.push(`${I2}var el${id} ${elemGo}`);
+        lines.push(renderGoDeBox(plan.elem, `el${id}`, `${pv}.Got`, ctr, I2, fail, `i${id}`));
+        lines.push(`${I2}list${id} = append(list${id}, el${id})`);
+        lines.push(`${I1}}`);
+        for (const l of wrapAssign(`list${id}`))
+            lines.push(l);
+    }
+    else {
+        // map(V): the wire value is a producer map; enumerate its keys, decode each value as V.
+        const valGo = goTypeOfPlan(plan.value);
+        lines.push(`${I1}m${id} := make(map[string]${valGo})`);
+        lines.push(`${I1}for _, k${id} := range ${pv}.Got.Keys() {`);
+        lines.push(`${I2}var mv${id} ${valGo}`);
+        lines.push(renderGoDeBox(plan.value, `mv${id}`, `${pv}.Got`, ctr, I2, fail, `k${id}`));
+        lines.push(`${I2}m${id}[k${id}] = mv${id}`);
+        lines.push(`${I1}}`);
+        for (const l of wrapAssign(`m${id}`))
+            lines.push(l);
+    }
+    // WRONG → mismatch (required + optional). Required: NULL → mismatch, ABSENT → missing. Optional:
+    // NULL / ABSENT leave the target pointer nil (no statement — the zero value IS None).
+    lines.push(`${I}} else if ${pv}.Kind == probeWrong {`);
+    lines.push(`${I1}${mismatch}`);
+    if (!opt) {
+        lines.push(`${I}} else if ${pv}.Kind == probeNull {`);
+        lines.push(`${I1}${mismatch}`);
+        lines.push(`${I}} else {`);
+        lines.push(`${I1}${missing}`);
+    }
+    lines.push(`${I}}`);
+    return lines.join("\n");
 }
-/** emitProbeWireTypes — the once-per-module probe structs + WireRow/WireList seam interfaces. A
- * NumberProbe's Got is the raw numeric text (the de-box parses + range-checks it, so overflow is BC's
- * to detect); every probe carries ActualWireType even on a match so overflow can report the numeric
- * wire tag. Raw is the offending value stringified (NOT named RawValue — that token is reserved for the
- * ErrorDetail field decl). Concrete structs / named interfaces — no boxed Value on the seam. */
-function emitProbeWireTypes() {
+/** returnZeroFail — the default de-box mismatch control flow: return the runner's zero output + the
+ * structured Error Value (fail/retry componentRef results + map/fanout element de-box, which fails closed
+ * regardless of elementPolicy — matching the interpreter's whole-node outType throw). */
+const returnZeroFail = (zeroOut) => (errValueExpr) => `return ${zeroOut}, ${errValueExpr}`;
+/** renderResultDeBox — inline strict de-box of a whole result WIRE (`srcExpr`, a WireValue) into the
+ * lvalue `target`, 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. `ctr` hands out unique temp suffixes: the
+ * sequential runner threads ONE counter across all its at-fn-scope nodes so siblings never collide;
+ * loop/if-scoped arms (map / fanout / parallel commit) may pass a fresh one. */
+function renderResultDeBox(ref, target, srcExpr, nodeId, plan, indent, fail, ctr = { n: 0 }) {
+    return renderGoDeBox(buildDeBoxPlan(ref, { from: "top" }, { model: nodeId, field: nodeId, plan }), target, srcExpr, ctr, indent, fail);
+}
+/** emitProbeWireTypes — the once-per-module probe kind consts + probe RESULT structs. A NumberProbe's
+ * Got is the raw numeric text (the de-box parses + range-checks it, so overflow is BC's to detect); every
+ * probe carries ActualWireType even on a match so overflow can report the numeric wire tag. Raw is the
+ * offending value stringified (NOT named RawValue — that token is reserved for the ErrorDetail field
+ * decl). Concrete data structs — no boxed Value on the seam. bc does NOT declare the WireValue/WireRow/
+ * WireList seam types (that would own the wire format, and a Go interface is vtable dynamic dispatch); it
+ * REFERENCES the consumer's CONCRETE types by name (RowProbe.Got is a `${wire.row}`, ListProbe.Got a
+ * `${wire.list}`) and the runner calls their methods directly (zero dynamic dispatch, zero dictionary). */
+function emitProbeWireTypes(wire) {
     return `// Probe kinds — the outcome of classifying one wire attribute against a declared field type.
 const (
 	probeGot    uint8 = 0 // present; the wire variant matches the declared type
@@ -187,232 +324,23 @@ type BoolProbe struct {
 	Raw            string
 }
 
-// RowProbe / ListProbe — a composite probe result: a nested WireRow (a DynamoDB "M") or WireList (an "L").
+// RowProbe / ListProbe — a composite probe result: a nested wire map (a DynamoDB "M") or wire array (an
+// "L"). Got is the consumer's CONCRETE ${wire.row} / ${wire.list} (a value type — no boxed Value, no
+// interface); the inline de-box probes it directly.
 type RowProbe struct {
 	Kind           uint8
-	Got            WireRow
+	Got            ${wire.row}
 	ActualWireType string
 	Raw            string
 }
 
 type ListProbe struct {
 	Kind           uint8
-	Got            WireList
+	Got            ${wire.list}
 	ActualWireType string
 	Raw            string
-}
-
-// WireRow — the consumer's wire item, probed per declared field by the generated de-box. The consumer
-// implements it over its wire payload (a DynamoDB AttributeValue map) and classifies each attribute's
-// variant; the generated de-box owns strictness. No boxed Value, no dynamic accessor.
-type WireRow interface {
-	// Keys reports the attribute keys present (the entries of a wire map / DynamoDB "M"); the de-box
-	// iterates them to decode a declared map(V) field.
-	Keys() []string
-	ProbeString(field string) StringProbe
-	ProbeNumber(field string) NumberProbe
-	ProbeBool(field string) BoolProbe
-	ProbeRow(field string) RowProbe
-	ProbeList(field string) ListProbe
-}
-
-// WireList — a wire array (a DynamoDB "L"), probed per element by the generated de-box.
-type WireList interface {
-	Len() int
-	ElemString(i int) StringProbe
-	ElemNumber(i int) NumberProbe
-	ElemBool(i int) BoolProbe
-	ElemRow(i int) RowProbe
-	ElemList(i int) ListProbe
 }`;
 }
-/** goDecodeFnName — the decode function name for a named type (deduped across the module). */
-function goDecodeNamedName(name) {
-    return `decodeWire_${name.replace(/[^A-Za-z0-9_]/g, "_")}`;
-}
-/**
- * emitDecodeNamed — emit (once, deduped) `decodeWire_<Name>(w WireRow) (<GoType>, error)` for a named
- * type: probe each declared field from the type SSoT, produce the structured error on a mismatch
- * (deTypeMismatch / deMissingField / deOverflow), and recurse into nested named / arr fields. `model`
- * is the declaring type name (scp-error.md `model`). Nested named types are emitted transitively.
- */
-function emitDecodeNamed(name, plan, emitted, out) {
-    const fn = goDecodeNamedName(name);
-    if (emitted.has(fn))
-        return fn;
-    emitted.add(fn);
-    const goType = name; // a named TypeRef renders to its own Go type name.
-    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(`func ${fn}(w WireRow) (${goType}, error) {`);
-    lines.push(`\tvar out ${goType}`);
-    const ctr = { n: 0 };
-    for (const f of decl.fields) {
-        lines.push(emitDecodeValue(`out.${goFieldName(f.name)}`, f.type, "w", JSON.stringify(f.name), false, name, f.name, `${goType}{}`, plan, emitted, out, 1, ctr));
-    }
-    lines.push(`\treturn out, nil`);
-    lines.push(`}`);
-    out.push(lines.join("\n"));
-    return fn;
-}
-/**
- * emitDecodeValue — the SINGLE recursive decode over the full TypeRef grammar (scalar / opt(scalar) /
- * named / arr / map). It decodes one value of `ref`, obtained by probing `wireVar` at `keyExpr`, and
- * assigns it into the lvalue `target`. Every nested position (an arr element, a map value, an obj field)
- * recurses through THIS function, so arbitrary nesting (map-of-map, arr-of-map, …) works by construction
- * — there is no depth-specific decoder to leave a gap. A mismatch produces the structured Error Value
- * (deTypeMismatch / deMissingField / deOverflow) and returns `retZero`; no panic, no boxed value.
- *
- *   - `keyExpr`  the Go probe key: a quoted literal `"title"` (obj field), a map-key var, or a list index.
- *   - `isElem`   probe a WireList element (Elem*, no absent — an index always exists) vs a WireRow field
- *                / map key (Probe*, absent → missingField).
- *   - `fieldRaw` the raw error `field` label (scp-error.md). `ctr` gives every temp a unique suffix.
- */
-function emitDecodeValue(target, ref, wireVar, keyExpr, isElem, model, fieldRaw, retZero, plan, emitted, out, indent, ctr) {
-    const t = "\t".repeat(indent);
-    const ml = JSON.stringify(model);
-    const fl = JSON.stringify(fieldRaw);
-    const notation = notationOfRef(ref, plan);
-    const nl = JSON.stringify(notation);
-    const id = `_${ctr.n++}`;
-    const lines = [];
-    const rowProbe = `${wireVar}.${isElem ? "ElemRow" : "ProbeRow"}(${keyExpr})`;
-    const listProbe = `${wireVar}.${isElem ? "ElemList" : "ProbeList"}(${keyExpr})`;
-    // an absent attribute is a missing REQUIRED field (a WireList index always exists → no absent check).
-    const absent = (pv) => isElem ? "" : `${t}\tif ${pv}.Kind == probeAbsent {\n${t}\t\treturn ${retZero}, deMissingField(${ml}, ${fl}, ${nl})\n${t}\t}\n`;
-    const mismatch = (pv, ind) => `${ind}return ${retZero}, deTypeMismatch(${ml}, ${fl}, ${nl}, ${pv}.ActualWireType, ${pv}.Raw)`;
-    // opt(scalar): Absent / Null → leave the pointer nil (valid, no error); Wrong → mismatch; Got → &value.
-    if (ref.kind === "opt" && ref.inner.kind === "scalar" && ref.inner.scalar !== "null") {
-        const pv = `p${id}`;
-        lines.push(`${t}{`);
-        lines.push(`${t}\t${pv} := ${scalarProbeCall(wireVar, keyExpr, ref.inner.scalar, isElem).call}`);
-        lines.push(`${t}\tif ${pv}.Kind == probeGot {`);
-        lines.push(scalarAssignInto(target, pv, ref.inner.scalar, model, fieldRaw, notation, `${t}\t\t`, retZero, true));
-        lines.push(`${t}\t} else if ${pv}.Kind == probeWrong {`);
-        lines.push(mismatch(pv, `${t}\t\t`));
-        lines.push(`${t}\t}`);
-        lines.push(`${t}}`);
-        return lines.join("\n");
-    }
-    if (ref.kind === "scalar" && ref.scalar !== "null") {
-        const pv = `p${id}`;
-        lines.push(`${t}{`);
-        lines.push(`${t}\t${pv} := ${scalarProbeCall(wireVar, keyExpr, ref.scalar, isElem).call}`);
-        if (!isElem)
-            lines.push(absent(pv).replace(/\n$/, ""));
-        lines.push(`${t}\tif ${pv}.Kind != probeGot {`); // Wrong or Null on a required value → mismatch
-        lines.push(mismatch(pv, `${t}\t\t`));
-        lines.push(`${t}\t}`);
-        lines.push(scalarAssignInto(target, pv, ref.scalar, model, fieldRaw, notation, `${t}\t`, retZero, false));
-        lines.push(`${t}}`);
-        return lines.join("\n");
-    }
-    if (ref.kind === "named") {
-        const dec = emitDecodeNamed(ref.name, plan, emitted, out);
-        const rp = `r${id}`;
-        lines.push(`${t}{`);
-        lines.push(`${t}\t${rp} := ${rowProbe}`);
-        if (!isElem)
-            lines.push(absent(rp).replace(/\n$/, ""));
-        lines.push(`${t}\tif ${rp}.Kind != probeGot {`);
-        lines.push(mismatch(rp, `${t}\t\t`));
-        lines.push(`${t}\t}`);
-        lines.push(`${t}\tv${id}, e${id} := ${dec}(${rp}.Got)`);
-        lines.push(`${t}\tif e${id} != nil {`);
-        lines.push(`${t}\t\treturn ${retZero}, e${id}`);
-        lines.push(`${t}\t}`);
-        lines.push(`${t}\t${target} = v${id}`);
-        lines.push(`${t}}`);
-        return lines.join("\n");
-    }
-    if (ref.kind === "arr") {
-        const lp = `l${id}`;
-        const elemGo = renderTypeRef(ref.elem);
-        lines.push(`${t}{`);
-        lines.push(`${t}\t${lp} := ${listProbe}`);
-        if (!isElem)
-            lines.push(absent(lp).replace(/\n$/, ""));
-        lines.push(`${t}\tif ${lp}.Kind != probeGot {`);
-        lines.push(mismatch(lp, `${t}\t\t`));
-        lines.push(`${t}\t}`);
-        lines.push(`${t}\t${target} = make([]${elemGo}, 0, ${lp}.Got.Len())`);
-        lines.push(`${t}\tfor i${id} := 0; i${id} < ${lp}.Got.Len(); i${id}++ {`);
-        lines.push(`${t}\t\tvar el${id} ${elemGo}`);
-        lines.push(emitDecodeValue(`el${id}`, ref.elem, `${lp}.Got`, `i${id}`, true, model, fieldRaw, retZero, plan, emitted, out, indent + 2, ctr));
-        lines.push(`${t}\t\t${target} = append(${target}, el${id})`);
-        lines.push(`${t}\t}`);
-        lines.push(`${t}}`);
-        return lines.join("\n");
-    }
-    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 mp = `m${id}`;
-        const valGo = renderTypeRef(ref.value);
-        lines.push(`${t}{`);
-        lines.push(`${t}\t${mp} := ${rowProbe}`);
-        if (!isElem)
-            lines.push(absent(mp).replace(/\n$/, ""));
-        lines.push(`${t}\tif ${mp}.Kind != probeGot {`);
-        lines.push(mismatch(mp, `${t}\t\t`));
-        lines.push(`${t}\t}`);
-        lines.push(`${t}\t${target} = make(map[string]${valGo})`);
-        lines.push(`${t}\tfor _, k${id} := range ${mp}.Got.Keys() {`);
-        lines.push(`${t}\t\tvar mv${id} ${valGo}`);
-        lines.push(emitDecodeValue(`mv${id}`, ref.value, `${mp}.Got`, `k${id}`, false, model, fieldRaw, retZero, plan, emitted, out, indent + 2, ctr));
-        lines.push(`${t}\t\t${target}[k${id}] = mv${id}`);
-        lines.push(`${t}\t}`);
-        lines.push(`${t}}`);
-        return lines.join("\n");
-    }
-    // fail closed at generation for a shape the grammar does not cover (e.g. opt of a non-scalar).
-    throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go 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).`);
-}
-/** scalarProbeCall — the probe method call for a scalar of the given kind (string→ProbeString/ElemString,
- * int|float→ProbeNumber/ElemNumber, bool→ProbeBool/ElemBool). `keyOrIndex` is a quoted key (row) or an
- * index var (list). */
-function scalarProbeCall(wireVar, keyOrIndex, scalar, isElem) {
-    const m = scalar === "string" ? "String" : scalar === "bool" ? "Bool" : "Number";
-    const method = (isElem ? "Elem" : "Probe") + m;
-    return { call: `${wireVar}.${method}(${keyOrIndex})` };
-}
-/** scalarAssignInto — assign a probeGot scalar into an lvalue `target` (opt → pointer). Number is parsed
- * + range-checked here (BC owns overflow). No panic on parse failure — a structured overflow error. The
- * `n/nErr/f/fErr/v` temps are safe because every scalar decode is wrapped in its own `{ }` block. */
-function scalarAssignInto(fieldExpr, pv, scalar, model, key, notation, t, retZero, asPtr) {
-    const ml = JSON.stringify(model);
-    const kl = JSON.stringify(key);
-    const nl = JSON.stringify(notation);
-    if (scalar === "string") {
-        return asPtr ? `${t}v := ${pv}.Got\n${t}${fieldExpr} = &v` : `${t}${fieldExpr} = ${pv}.Got`;
-    }
-    if (scalar === "bool") {
-        return asPtr ? `${t}v := ${pv}.Got\n${t}${fieldExpr} = &v` : `${t}${fieldExpr} = ${pv}.Got`;
-    }
-    if (scalar === "int") {
-        const l = [];
-        l.push(`${t}n, nErr := strconv.ParseInt(${pv}.Got, 10, 64)`);
-        l.push(`${t}if nErr != nil {`);
-        l.push(`${t}\treturn ${retZero}, deOverflow(${ml}, ${kl}, ${nl}, ${pv}.ActualWireType, ${pv}.Got)`);
-        l.push(`${t}}`);
-        l.push(asPtr ? `${t}${fieldExpr} = &n` : `${t}${fieldExpr} = n`);
-        return l.join("\n");
-    }
-    // float — int widens to float; a non-numeric raw is a range/parse failure (overflow kind).
-    const l = [];
-    l.push(`${t}f, fErr := strconv.ParseFloat(${pv}.Got, 64)`);
-    l.push(`${t}if fErr != nil {`);
-    l.push(`${t}\treturn ${retZero}, deOverflow(${ml}, ${kl}, ${nl}, ${pv}.ActualWireType, ${pv}.Got)`);
-    l.push(`${t}}`);
-    l.push(asPtr ? `${t}${fieldExpr} = &f` : `${t}${fieldExpr} = f`);
-    return l.join("\n");
-}
-/** goDecodeElemName — the element de-box function name for a map/fanout node (per node). */
-function goDecodeElemName(compName, nodeId) {
-    return `decodeWireElem_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
-}
 /** mapFanoutElemRef — the element ROW TypeRef a map/fanout node decodes (the per-element record). */
 function mapFanoutElemRef(node, typedNodes, plan) {
     const ref = typedNodes.get(node.id);
@@ -420,190 +348,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 decodeWireElem_* (closing the scan-row silent-default hole). */
-function mapFanoutElemDeBoxEligible(node, typedNodes, plan) {
-    return mapFanoutElemRef(node, typedNodes, plan).kind === "named";
-}
-/**
- * emitDecodeElemRow — emit (once) `decodeWireElem_<comp>_<node>(w WireRow) (RawElem_<comp>_<node>, error)`
- * for a map/fanout node whose element ROW is a named record: probe each declared field via the SAME
- * recursion as record reads (emitDecodeValue) and build the concrete RawElem struct, failing closed with
- * the structured Error Value on a mismatch. This is the componentRef seam extended to scan/fan-out rows.
- */
-function emitDecodeElemRow(comp, node, elemRowRef, plan, emitted, out) {
-    const nodeId = node.id;
-    const fn = goDecodeElemName(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(`func ${fn}(w WireRow) (${retType}, error) {`);
-    lines.push(`\tvar out ${retType}`);
-    const ctr = { n: 0 };
-    for (const f of decl.fields) {
-        lines.push(emitDecodeValue(`out.${goFieldName(f.name)}`, f.type, "w", JSON.stringify(f.name), false, elemRowRef.name, f.name, `${retType}{}`, plan, emitted, out, 1, ctr));
-    }
-    lines.push(`\treturn out, nil`);
-    lines.push(`}`);
-    out.push(lines.join("\n"));
-    return fn;
-}
-/** emitNodeDecodeFns — emit the decode functions for every de-box-eligible node in a component: a
- * componentRef record read (decodeWire_<Name>) OR a map/fanout element row (decodeWireElem_<comp>_<node>).
- * Deduped; nested named fields recurse through the shared decodeWire_<Name>. */
-/** goDecodeResultName — the top-result decode function name for a de-box componentRef node. */
-function goDecodeResultName(compName, nodeId) {
-    return `decodeWireResult_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
-}
-/**
- * emitDecodeWireResult — emit (once) `decodeWireResult_<comp>_<node>(wire <WireType>) (<ResultType>,
- * error)` for a componentRef node whose result is a record-containing top: it decodes each record via
- * decodeWire_<InnerName> and assembles the top (a record / []record / *record / map[string]record),
- * failing closed with the structured Error Value on a mismatch. This is the SAME decode recursion at the
- * node-result position — one path covers named / arr(named) / opt(named) / map(named).
- */
-function emitDecodeWireResult(comp, node, ref, plan, emitted, out) {
-    const top = recordTop(ref);
-    const fn = goDecodeResultName(comp.name, node.id);
-    if (emitted.has(fn))
-        return fn;
-    emitted.add(fn);
-    const innerDecode = emitDecodeNamed(top.innerName, plan, emitted, out);
-    const resultType = renderTypeRef(ref);
-    const wireType = goWireTypeForTop(top);
-    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.`);
-    lines.push(`func ${fn}(wire ${wireType}) (${resultType}, error) {`);
-    switch (top.kind) {
-        case "named":
-            lines.push(`\treturn ${innerDecode}(wire)`);
-            break;
-        case "arr":
-            lines.push(`\tout := make(${resultType}, 0, len(wire))`);
-            lines.push(`\tfor _, w := range wire {`);
-            lines.push(`\t\te, err := ${innerDecode}(w)`);
-            lines.push(`\t\tif err != nil {`, `\t\t\treturn nil, err`, `\t\t}`);
-            lines.push(`\t\tout = append(out, e)`);
-            lines.push(`\t}`);
-            lines.push(`\treturn out, nil`);
-            break;
-        case "opt":
-            lines.push(`\tif wire == nil {`, `\t\treturn nil, nil`, `\t}`);
-            lines.push(`\tr, err := ${innerDecode}(wire)`);
-            lines.push(`\tif err != nil {`, `\t\treturn nil, err`, `\t}`);
-            lines.push(`\treturn &r, nil`);
-            break;
-        case "map":
-            lines.push(`\tout := make(${resultType})`);
-            lines.push(`\tfor k, w := range wire {`);
-            lines.push(`\t\tr, err := ${innerDecode}(w)`);
-            lines.push(`\t\tif err != nil {`, `\t\t\treturn nil, err`, `\t\t}`);
-            lines.push(`\t\tout[k] = r`);
-            lines.push(`\t}`);
-            lines.push(`\treturn out, nil`);
-            break;
-    }
-    lines.push(`}`);
-    out.push(lines.join("\n"));
-    return fn;
-}
-function emitNodeDecodeFns(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;
-            emitDecodeElemRow(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 decodeWire_<Name>; an arr/opt/map top assembles via
-        // decodeWireResult_* (which itself recurses into decodeWire_<Name> per record).
-        if (top.kind === "named")
-            emitDecodeNamed(top.innerName, plan, emitted, out);
-        else
-            emitDecodeWireResult(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);
-    }
-}
-/** 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. This is the
- * 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;
-}
-/**
- * assertDeBoxableResults — fail closed (never a silent trust) for a covered node whose result would
- * materialize on the trusting typed path and silently default a wrong wire value. Two shapes fail closed:
- * (1) a NON-named top (arr / opt / map) that transitively contains a record the de-box does not decode
- * (deeper nesting like arr(arr(named))) — it would trust the record's wire fields; (2) a HANDLER-BACKED
- * componentRef node whose result is a pure scalar / scalar-collection top (arr(scalar) / opt(scalar) /
- * map(scalar) / bare scalar) — it materializes `t = row.Val` on the trusting path, so a wrong wire value
- * silently defaults (diverging from run_behavior's outType check). Either is a loud generation-time error
- * (native-codegen-standard §2 — an unsupported shape fails closed, never escapes to a trusting path). A
- * record top (de-boxed) and a DATAFLOW scalar top (a prior-node-fed result, computed from already-native
- * data — #129 folds) both generate.
- */
-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", `go 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
-        // (decodeWireElem_*). A scalar / scalar-collection element materializes from the trusting per-element
-        // `.Val` — a wrong wire value silent-defaults. Fail closed.
-        if (isMapFanout) {
-            throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go 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 `t = row.Val`
-        // (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", `go 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 goPortFieldName(wire) {
     const safe = wire.replace(/[^A-Za-z0-9_]/g, "_");
     const head = safe.charAt(0);
@@ -1050,32 +794,11 @@ type ${structName} struct {
 ${fields}
 }`;
 }
-// ── CONCRETE per-node row structs + row→outType copiers (bc: full Go concreteness) ──────────
-//
-// The covered path no longer crosses a generic `RawValue`/`RawRow` on the RESULT plane. Each
-// covered node has a CONCRETE row struct `RawRow_<comp>_<node>` whose fields are the node's
-// projected outType fields (typed, flattened). A row models a SUCCESS; failure travels the (T,
-// per-component `Handler_<comp>` interface has one method per node returning that concrete struct;
-// the runner reads `row.<Field>` DIRECTLY (no `.(RawRow)`, no `.(scalar)`, no `RawValue`) and copies
-// each field into the node's outType struct local. The `.(T)` type-assert seam that the generic
-// RawValue de-box carried is GONE on the covered path (the handler produces the typed fields).
-//
-// A scalar/arr/opt node (outType not a named struct) has a single `Val <typed>` payload field. A
-// named-struct node has one Go field per outType field (same names/types as the outType decl), so
-// `RawRow_<comp>_<node>` is structurally the outType struct. The copier is then a
-// mechanical field-for-field assignment into the outType struct — NO dynamic value read anywhere.
-/** Row_<comp>_<node> — the concrete per-node handler-result row struct name. (Deliberately NOT
- * prefixed with the generic dynamic-accessor name — that accessor is what the concrete path removes.) */
-function rawRowStructName(compName, nodeId) {
-    return `Row_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
-}
-/** RowElem_<comp>_<node> — the concrete per-ELEMENT row struct name for a covered map node (the
- * element/into row the map handler yields per over element). */
-function rawElemStructName(compName, nodeId) {
-    return `RowElem_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
-}
-/** Handler_<comp> — the per-component concrete handler interface name (one Node_* method per node). */
-function handlerIfaceName(compName) {
+/** handlerTypeName — the per-component CONCRETE handler type name the runner takes by value (one Node_*
+ * method per node). It is NOT a bc-declared interface (a Go interface is vtable dynamic dispatch): the
+ * consumer supplies a concrete type of this name (default `Handler_<comp>`) and the runner calls
+ * `h.Node_*(...)` directly (zero dynamic dispatch, zero dictionary). */
+function handlerTypeName(compName) {
     return `Handler_${sanitize(compName)}`;
 }
 /** RunNativeRawStruct_<comp> — the EXPORTED name of the per-component struct-returning combined runner
@@ -1090,74 +813,6 @@ function runnerName(compName) {
 function nodeMethodName(compName, nodeId) {
     return `Node_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
 }
-/**
- * emitRawRowStructs — emit the concrete `RawRow_<comp>_<node>` struct per covered node (and, for a
- * covered map node, the per-element `RawElem_<comp>_<node>`). A named-struct outType flattens to one
- * Go field per outType field; a scalar/arr/opt node carries a single `Val` payload. Every row carries
- * A row models a SUCCESS; failure is the second (error) return, so no in-band error signal.
- */
-function emitRawRowStructs(comp, typedNodes, plan) {
-    const parts = [];
-    for (const n of comp.body) {
-        // #108: a cond node has NO handler-result row (pure Expression — no dispatch).
-        if ("cond" in n)
-            continue;
-        const ref = typedNodes.get(n.id);
-        if ("fanout" in n) {
-            // a covered fanout node: RawElem_ is the connection items element (the per-body row the batched
-            // handler yields, aligned to the deduped id list); the batch RawRow_ carries the aligned []RawElem_.
-            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` +
-                `type ${rawRowStructName(comp.name, n.id)} struct {\n\tRows []${rawElemStructName(comp.name, n.id)}\n}`);
-            continue;
-        }
-        if ("map" in n) {
-            // a covered map node: RawElem_<comp>_<node> is the HANDLER'S per-element return shape:
-            //   - into: the `into` field's type (the fetched item merged onto every over element);
-            //   - no-into (#93 shape 3): the element outType directly (connection-collect).
-            // The batched Node_* returns RawRow_<comp>_<node> (aligned []RawElem_ + error); a per-element
-            // dispatch Node_* returns RawElem_ directly (one physical call per element).
-            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` +
-                `type ${rawRowStructName(comp.name, n.id)} struct {\n\tRows []${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; a failure is the second (error) return, 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(`type ${name} struct {`);
-    if (ref.kind === "named") {
-        const decl = findDecl(plan, ref.name);
-        for (const f of decl.fields) {
-            lines.push(`\t${goFieldName(f.name)} ${renderTypeRef(f.type)} // ${JSON.stringify(f.name)}`);
-        }
-    }
-    else {
-        lines.push(`\tVal ${renderTypeRef(ref)}`);
-    }
-    lines.push(`}`);
-    return lines.join("\n");
-}
-/** emitRowCopy — the statements copying a concrete row's typed fields into the node's outType local
- * `target` (a value of Go type renderTypeRef(ref)). Named: field-for-field; scalar/arr/opt: `.Val`.
- * `rowExpr` is the concrete RawRow_/RawElem_ value; `indent` tabs. No dynamic read — pure assignment. */
-function emitRowCopy(target, rowExpr, ref, plan, indent) {
-    const t = "\t".repeat(indent);
-    if (ref.kind === "named") {
-        const decl = findDecl(plan, ref.name);
-        return decl.fields.map((f) => `${t}${target}.${goFieldName(f.name)} = ${rowExpr}.${goFieldName(f.name)}`).join("\n");
-    }
-    return `${t}${target} = ${rowExpr}.Val`;
-}
 /**
  * boundGoType (change #3 — typed `bound`) — the CONCRETE Go type of a covered node's `bound` handler
  * param (bc#90 / runtime-free). `bound` is the parent-produced key (the bindField value); it replaces
@@ -1187,58 +842,6 @@ function boundGoType(node, comp, typedNodes, plan) {
         return `*${renderTypeRef(bfRef.inner)}`;
     return `*${renderTypeRef(bfRef)}`;
 }
-/**
- * emitHandlerInterface — the per-component `Handler_<comp>` interface: one concrete-typed `Node_*`
- * method per covered node. Each componentRef node method takes the node's native ports struct + the
- * typed `bound` pointer (change #3 — the produced-aware parent key; NO boxed dslcontracts.Value) and
- * returns its concrete row struct + a resolved bool. A covered map node's method takes the batch
- * ports struct (batched) or the element ports struct (per-element) and returns the batch / element
- * row. This is the fully-concrete, runtime-free replacement for the generic ExecNativeRaw seam.
- */
-function emitHandlerInterface(comp, typedNodes, plan) {
-    const lines = [];
-    lines.push(`// ${handlerIfaceName(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(`type ${handlerIfaceName(comp.name)} interface {`);
-    for (const n of comp.body) {
-        if ("cond" in n)
-            continue; // #108: a cond node has no handler method (pure Expression).
-        const method = nodeMethodName(comp.name, n.id);
-        const bt = boundGoType(n, comp, typedNodes, plan);
-        if ("fanout" in n) {
-            // fanout (v3): one batched dispatch of the deduped id list. Ports = the batch struct; returns the
-            // aligned per-body element WIRES ([]WireRow) that the runner de-boxes (decodeWireElem_*) then
-            // applies dedupe/drop/wrap to. A non-record element keeps its concrete batch-row return.
-            const portsT = `${portsStructName(comp.name, n.id)}_batch`;
-            const elemDeBox = mapFanoutElemDeBoxEligible(n, typedNodes, plan);
-            const retT = elemDeBox ? "[]WireRow" : rawRowStructName(comp.name, n.id);
-            lines.push(`\t${method}(ports ${portsT}, bound ${bt}) (${retT}, error)`);
-            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) the runner de-boxes: batched → []WireRow (aligned
-            // to items), nonbatched → one WireRow per dispatch. A non-record element keeps its concrete row.
-            const elemDeBox = mapFanoutElemDeBoxEligible(n, typedNodes, plan);
-            const retT = elemDeBox ? (batched ? "[]WireRow" : "WireRow") : batched ? rawRowStructName(comp.name, n.id) : rawElemStructName(comp.name, n.id);
-            lines.push(`\t${method}(ports ${portsT}, bound ${bt}) (${retT}, error)`);
-            continue;
-        }
-        // a componentRef whose result is a record-containing top returns the wire (WireRow / []WireRow /
-        // nilable WireRow / map[string]WireRow); the generated de-box (decodeWireResult_*) probes each record
-        // strictly. A pure-scalar top (arr(scalar)/opt(scalar)/…) keeps its concrete row for direct copy.
-        const ref = typedNodes.get(n.id);
-        const top = ref !== undefined ? recordTop(ref) : null;
-        const retT = top !== null ? goWireTypeForTop(top) : rawRowStructName(comp.name, n.id);
-        lines.push(`\t${method}(ports ${portsStructName(comp.name, n.id)}, bound ${bt}) (${retT}, error)`);
-    }
-    lines.push(`}`);
-    return lines.join("\n");
-}
 /** mapElemMaterializerName — the augmented-element copier for a covered map...into node. */
 function mapElemMaterializerName(compName, nodeId) {
     return `materializeMapElemNR_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
@@ -1351,9 +954,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 + assign the `into` field from the concrete per-element handler row
- * (RawElem_<comp>_<node>). 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 = [];
@@ -1375,16 +977,15 @@ function emitMapElemMaterializers(comp, typedNodes, plan) {
         const intoRowRef = mapElemRowRef(n, arrRef, plan);
         const fn = mapElemMaterializerName(comp.name, n.id);
         const overElemGo = mapOverElemType(comp, n, typedNodes, plan);
-        const elemRowGo = rawElemStructName(comp.name, n.id);
         const lines = [];
         lines.push(`// ${fn} — assemble the augmented map element '${n.id}': copy the over element's typed`);
-        lines.push(`// fields + set the '${intoKey}' (into) field from the concrete per-element handler row.`);
-        lines.push(`func ${fn}(over ${overElemGo}, into ${elemRowGo}) ${elemRef.name} {`);
+        lines.push(`// fields + set the '${intoKey}' (into) field from the already-de-boxed into value.`);
+        lines.push(`func ${fn}(over ${overElemGo}, into ${renderTypeRef(intoRowRef)}) ${elemRef.name} {`);
         lines.push(`\tvar out ${elemRef.name}`);
         for (const f of overFields) {
             lines.push(`\tout.${goFieldName(f.name)} = over.${goFieldName(f.name)}`);
         }
-        lines.push(emitRowCopy(`out.${goFieldName(intoKey)}`, "into", intoRowRef, plan, 1));
+        lines.push(`\tout.${goFieldName(intoKey)} = into`);
         lines.push(`\treturn out`);
         lines.push(`}`);
         parts.push(lines.join("\n"));
@@ -1634,7 +1235,7 @@ function emitPortInit(pn, expr, comp, plan, typedNodes, isPrior, opts) {
  *
  * NO RunPlan / []OpSpec / planSpec walk: the staging, the bound, and which ops are parallel are baked.
  */
-function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes, plan, priorNodeAt, zeroOut, flags) {
+function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes, plan, priorNodeAt, zeroOut, flags, wire) {
     const lines = [];
     const ids = stage.map((i) => comp.body[i].id);
     lines.push(`\t// ── bc#87 real-concurrency stage {${ids.map((x) => JSON.stringify(x)).join(", ")}} — static parallel`);
@@ -1671,16 +1272,9 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
         const node = comp.body[i];
         const s = sanitize(node.id);
         const structName = portsStructName(comp.name, comp.body[i].id);
-        const memRef = typedNodes.get(comp.body[i].id);
-        // a de-box member's goroutine returns the top's wire (WireRow / []WireRow / nilable WireRow /
-        // map[string]WireRow, decoded in COMMIT); a non-de-box member returns its concrete row directly.
-        const memTop = recordTop(memRef);
-        if (memTop !== null) {
-            lines.push(`\t\tvar wire_${s} ${goWireTypeForTop(memTop)}`);
-        }
-        else {
-            lines.push(`\t\tvar row_${s} ${rawRowStructName(comp.name, comp.body[i].id)}`);
-        }
+        // every member's goroutine returns the result WIRE (a single WireValue); the ascending COMMIT phase
+        // de-boxes it INLINE (so the wire — not the decode — is what the goroutine writes to its slot).
+        lines.push(`\t\tvar wire_${s} ${wire.value}`);
         lines.push(`\t\tvar row_${s}Err error`);
         lines.push(`\t\trun_${s} := false`);
         lines.push(`\t\tvar ps_${s} ${structName}`);
@@ -1753,66 +1347,43 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
         lines.push(`\t\t\t\tdefer wg.Done()`);
         lines.push(`\t\t\t\tdefer func() { <-sem }()`);
         const boundArg = node.bindField !== undefined ? `bound_${s}` : "nil";
-        const resultVar = deBoxEligible(typedNodes.get(node.id)) ? `wire_${s}` : `row_${s}`;
-        lines.push(`\t\t\t\t${resultVar}, row_${s}Err = handlers.${nodeMethodName(comp.name, node.id)}(ps_${s}, ${boundArg})`);
+        lines.push(`\t\t\t\twire_${s}, row_${s}Err = handlers.${nodeMethodName(comp.name, node.id)}(ps_${s}, ${boundArg})`);
         lines.push(`\t\t\t}()`);
         lines.push(`\t\t}`);
     }
     lines.push(`\t\twg.Wait()`);
-    // 3) COMMIT (ascending index): interpret + materialize deterministically — lowest-index failure wins.
+    // 3) COMMIT (ascending index): interpret + INLINE de-box deterministically — lowest-index failure wins.
+    // Uniform seam: every member's slot holds a single result WIRE (WireValue); 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).
     for (const i of refMembers) {
         const node = comp.body[i];
         const meta = metas[i];
         const s = sanitize(node.id);
         const ref = typedNodes.get(node.id);
-        const oc = `row_${s}`;
-        const top = recordTop(ref);
-        const namedTop = top !== null && top.kind === "named";
-        const deBox = top !== null;
-        // a NAMED top decodes in place (decodeWire_<Name> → oc → field copy); an arr/opt/map top assembles
-        // via decodeWireResult_* (the same decode recursion, one per record) into the typed local directly.
         lines.push(`\t\tif run_${s} {`);
         if (meta.policy === "continue") {
-            lines.push(`\t\t\tif ${oc}Err == nil {`);
-            if (namedTop) {
-                lines.push(`\t\t\t\tif ${oc}, ${oc}DErr := ${goDecodeNamedName(top.innerName)}(wire_${s}); ${oc}DErr == nil {`);
-                lines.push(emitRowCopy(typedLocal(node.id), oc, ref, plan, 5));
-                lines.push(`\t\t\t\t\tproduced_${s} = true`);
-                lines.push(`\t\t\t\t}`);
-            }
-            else if (deBox) {
-                lines.push(`\t\t\t\tif res_${s}, res_${s}DErr := ${goDecodeResultName(comp.name, node.id)}(wire_${s}); res_${s}DErr == nil {`);
-                lines.push(`\t\t\t\t\t${typedLocal(node.id)} = res_${s}`);
-                lines.push(`\t\t\t\t\tproduced_${s} = true`);
-                lines.push(`\t\t\t\t}`);
-            }
-            else {
-                lines.push(emitRowCopy(typedLocal(node.id), oc, ref, plan, 4));
-                lines.push(`\t\t\t\tproduced_${s} = true`);
-            }
+            // continue: a failed member (leaf failure OR de-box mismatch) commits no Port (defensive — covered
+            // componentRef members are always 'fail' policy today). A local skip, NOT a runner-wide propagate.
+            const nodeGo = renderTypeRef(ref);
+            const nodeZeroFail = (e) => `return ${goZero(ref)}, ${e}`;
+            lines.push(`\t\t\tif row_${s}Err == nil {`);
+            lines.push(`\t\t\t\tdec_${s}, dec_${s}DErr := func() (${nodeGo}, error) {`);
+            lines.push(`\t\t\t\t\tvar out ${nodeGo}`);
+            lines.push(renderResultDeBox(ref, "out", `wire_${s}`, node.id, plan, "\t\t\t\t\t", nodeZeroFail));
+            lines.push(`\t\t\t\t\treturn out, nil`);
+            lines.push(`\t\t\t\t}()`);
+            lines.push(`\t\t\t\tif dec_${s}DErr == nil {`);
+            lines.push(`\t\t\t\t\t${typedLocal(node.id)} = dec_${s}`);
+            lines.push(`\t\t\t\t\tproduced_${s} = true`);
+            lines.push(`\t\t\t\t}`);
             lines.push(`\t\t\t}`);
         }
         else {
-            lines.push(`\t\t\tif ${oc}Err != nil {`);
-            lines.push(`\t\t\t\treturn ${zeroOut}, opFailed(${JSON.stringify(node.id)}, ${JSON.stringify(meta.policy === "retry" ? "retry" : "fail")}, ${oc}Err)`);
+            lines.push(`\t\t\tif row_${s}Err != nil {`);
+            lines.push(`\t\t\t\treturn ${zeroOut}, opFailed(${JSON.stringify(node.id)}, ${JSON.stringify(meta.policy === "retry" ? "retry" : "fail")}, row_${s}Err)`);
             lines.push(`\t\t\t}`);
-            if (namedTop) {
-                lines.push(`\t\t\t${oc}, ${oc}DErr := ${goDecodeNamedName(top.innerName)}(wire_${s})`);
-                lines.push(`\t\t\tif ${oc}DErr != nil {`);
-                lines.push(`\t\t\t\treturn ${zeroOut}, ${oc}DErr`);
-                lines.push(`\t\t\t}`);
-                lines.push(emitRowCopy(typedLocal(node.id), oc, ref, plan, 3));
-            }
-            else if (deBox) {
-                lines.push(`\t\t\tres_${s}, res_${s}DErr := ${goDecodeResultName(comp.name, node.id)}(wire_${s})`);
-                lines.push(`\t\t\tif res_${s}DErr != nil {`);
-                lines.push(`\t\t\t\treturn ${zeroOut}, res_${s}DErr`);
-                lines.push(`\t\t\t}`);
-                lines.push(`\t\t\t${typedLocal(node.id)} = res_${s}`);
-            }
-            else {
-                lines.push(emitRowCopy(typedLocal(node.id), oc, ref, plan, 3));
-            }
+            lines.push(renderResultDeBox(ref, typedLocal(node.id), `wire_${s}`, node.id, plan, "\t\t\t", returnZeroFail(zeroOut)));
             lines.push(`\t\t\tproduced_${s} = true`);
         }
         lines.push(`\t\t}`);
@@ -1833,7 +1404,7 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
  * consumer (graphddb) drives it and keeps the struct native. A Value observation is produced ONLY
  * by the separate serialize wrapper (run_native_raw_<comp>, below), the single outer Value boundary.
  */
-function emitNativeRawRunner(comp, plan, flags) {
+function emitNativeRawRunner(comp, plan, flags, wire) {
     const ep = execPlan(comp);
     const order = ep.order;
     const cplan = buildComponentPlan(comp, goStraightlineInternals.dialect, "scope");
@@ -1854,6 +1425,9 @@ function emitNativeRawRunner(comp, plan, flags) {
     const outRef = comp.outputType !== undefined ? deriveTypeRef(comp.outputType, plan) : undefined;
     const outStructType = outRef ? renderTypeRef(outRef) : `${PKG}.Value`;
     const zeroOut = outRef ? goZero(outRef) : "nil";
+    // ONE de-box temp counter across all at-fn-scope sequential nodes so sibling reads never collide on a
+    // temp name (a gated / loop-scoped arm has its own Go scope, so it may keep a fresh counter).
+    const seqCtr = { n: 0 };
     const lines = [];
     lines.push(`// ${runnerName(comp.name)} — the STRUCT-RETURNING combined read (bc#77/#87): the fully`);
     lines.push(`// de-plumbed path. Ports are a native struct (direct field assignment); the handler`);
@@ -1867,11 +1441,12 @@ function emitNativeRawRunner(comp, plan, flags) {
     lines.push(`// index order so the observed value / op multiset / failure precedence byte-match run_behavior`);
     lines.push(`// (the goroutine spawn is the ONLY runtime element — the WHAT is baked). The output is a typed`);
     lines.push(`// struct/value assembled by struct literal + field access — the consumer keeps it native.`);
-    // FULLY CONCRETE: GENERIC over the per-component CONCRETE handler interface ${handlerIfaceName(comp.name)},
-    // whose Node_* methods return the concrete per-node row struct (typed fields = the node's outType).
-    // The covered result plane carries no boxed ports / boxed value / dynamic accessor / semantic type-
-    // assert on a row value — the runner reads row.<Field> directly and copies each into the outType local.
-    lines.push(`func ${runnerName(comp.name)}[H ${handlerIfaceName(comp.name)}](handlers H, in ${inStructName(comp.name)}) (${outStructType}, error) {`);
+    // FULLY CONCRETE + NON-GENERIC: the runner takes the consumer's CONCRETE ${handlerTypeName(comp.name)}
+    // handler by value and calls h.Node_*(...) DIRECTLY (a Go generic method call goes through a dictionary,
+    // a Go interface through a vtable — BOTH are dynamic dispatch, so the covered plane uses neither). Each
+    // Node_* returns the node's result WIRE (a single ${wire.value}); the runner de-boxes it INLINE
+    // (fully-unrolled probe/match — no decode helper, no output recursion) into the node's outType struct.
+    lines.push(`func ${runnerName(comp.name)}(handlers ${handlerTypeName(comp.name)}, in ${inStructName(comp.name)}) (${outStructType}, error) {`);
     lines.push(`\t_ = in`);
     for (const k of order.keys()) {
         const node = comp.body[order[k]];
@@ -1895,7 +1470,7 @@ function emitNativeRawRunner(comp, plan, flags) {
         // ascending-sorted stages), so we emit the block at the first member and skip the rest.
         const stage = ep.parallelStageOf.get(i);
         if (stage !== undefined && stage[0] === i) {
-            lines.push(emitParallelStageArm(comp, stage, k, ep.concurrency, metas, typedNodes, plan, priorNodeAt, zeroOut, flags));
+            lines.push(emitParallelStageArm(comp, stage, k, ep.concurrency, metas, typedNodes, plan, priorNodeAt, zeroOut, flags, wire));
             k += stage.length - 1;
             continue;
         }
@@ -1971,76 +1546,36 @@ function emitNativeRawRunner(comp, plan, flags) {
             inits.push(emitPortInit(pn, node.ports[pn], comp, plan, typedNodes, (h) => priorNodeAt(h, k)));
         }
         lines.push(`${indent}ports_${s} := ${structName}{${inits.join(", ")}}`);
-        const oc = `row_${s}`;
-        const copy = (ind) => emitRowCopy(typedLocal(node.id), oc, ref, plan, ind.length);
-        // a NAMED top returns a WireRow, decoded in place (decodeWire_<Name> → oc → field copy). An arr/opt/map
-        // top returns []WireRow / nilable WireRow / map[string]WireRow, assembled via decodeWireResult_* (the same
-        // decode recursion, one per record). Either way a de-box mismatch fails closed with the structured Error
-        // Value (byte-equal codes to run_behavior's outType check, so ≡ holds). A non-de-box node keeps its
-        // direct concrete-row return + field copy.
-        const top = recordTop(ref);
-        const namedTop = top !== null && top.kind === "named";
-        const deBox = top !== null;
+        // uniform seam: the handler returns a single result WIRE (${wire.value}); 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 wire_${s}, wire_${s}Err := handlers.${nodeMethodName(comp.name, node.id)}(ports_${s}, ${boundArg}); wire_${s}Err == nil {`);
-                lines.push(`${indent}\tif ${oc}, ${oc}DErr := ${goDecodeNamedName(top.innerName)}(wire_${s}); ${oc}DErr == nil {`);
-                lines.push(copy(indent + "\t\t"));
-                lines.push(`${indent}\t\tproduced_${s} = true`);
-                lines.push(`${indent}\t}`);
-                lines.push(`${indent}}`);
-            }
-            else if (deBox) {
-                lines.push(`${indent}if wire_${s}, wire_${s}Err := handlers.${nodeMethodName(comp.name, node.id)}(ports_${s}, ${boundArg}); wire_${s}Err == nil {`);
-                lines.push(`${indent}\tif res_${s}, res_${s}DErr := ${goDecodeResultName(comp.name, node.id)}(wire_${s}); res_${s}DErr == nil {`);
-                lines.push(`${indent}\t\t${typedLocal(node.id)} = res_${s}`);
-                lines.push(`${indent}\t\tproduced_${s} = true`);
-                lines.push(`${indent}\t}`);
-                lines.push(`${indent}}`);
-            }
-            else {
-                lines.push(`${indent}if ${oc}, ${oc}Err := handlers.${nodeMethodName(comp.name, node.id)}(ports_${s}, ${boundArg}); ${oc}Err == nil {`);
-                lines.push(copy(indent + "\t"));
-                lines.push(`${indent}\tproduced_${s} = 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 runs in a local closure so a mismatch is 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 nodeGo = renderTypeRef(ref);
+            const nodeZeroFail = (e) => `return ${goZero(ref)}, ${e}`;
+            lines.push(`${indent}if wire_${s}, wire_${s}Err := handlers.${nodeMethodName(comp.name, node.id)}(ports_${s}, ${boundArg}); wire_${s}Err == nil {`);
+            lines.push(`${indent}\tdec_${s}, dec_${s}DErr := func() (${nodeGo}, error) {`);
+            lines.push(`${indent}\t\tvar out ${nodeGo}`);
+            lines.push(renderResultDeBox(ref, "out", `wire_${s}`, node.id, plan, `${indent}\t\t`, nodeZeroFail, seqCtr));
+            lines.push(`${indent}\t\treturn out, nil`);
+            lines.push(`${indent}\t}()`);
+            lines.push(`${indent}\tif dec_${s}DErr == nil {`);
+            lines.push(`${indent}\t\t${typedLocal(node.id)} = dec_${s}`);
+            lines.push(`${indent}\t\tproduced_${s} = true`);
+            lines.push(`${indent}\t}`);
+            lines.push(`${indent}}`);
         }
         else {
             const policyLit = JSON.stringify(meta.policy === "retry" ? "retry" : "fail");
-            if (namedTop) {
-                lines.push(`${indent}wire_${s}, wire_${s}Err := handlers.${nodeMethodName(comp.name, node.id)}(ports_${s}, ${boundArg})`);
-                lines.push(`${indent}if wire_${s}Err != nil {`);
-                lines.push(`${indent}\treturn ${zeroOut}, opFailed(${JSON.stringify(node.id)}, ${policyLit}, wire_${s}Err)`);
-                lines.push(`${indent}}`);
-                lines.push(`${indent}${oc}, ${oc}DErr := ${goDecodeNamedName(top.innerName)}(wire_${s})`);
-                lines.push(`${indent}if ${oc}DErr != nil {`);
-                lines.push(`${indent}\treturn ${zeroOut}, ${oc}DErr`);
-                lines.push(`${indent}}`);
-                lines.push(copy(indent));
-                lines.push(`${indent}produced_${s} = true`);
-            }
-            else if (deBox) {
-                lines.push(`${indent}wire_${s}, wire_${s}Err := handlers.${nodeMethodName(comp.name, node.id)}(ports_${s}, ${boundArg})`);
-                lines.push(`${indent}if wire_${s}Err != nil {`);
-                lines.push(`${indent}\treturn ${zeroOut}, opFailed(${JSON.stringify(node.id)}, ${policyLit}, wire_${s}Err)`);
-                lines.push(`${indent}}`);
-                lines.push(`${indent}res_${s}, res_${s}DErr := ${goDecodeResultName(comp.name, node.id)}(wire_${s})`);
-                lines.push(`${indent}if res_${s}DErr != nil {`);
-                lines.push(`${indent}\treturn ${zeroOut}, res_${s}DErr`);
-                lines.push(`${indent}}`);
-                lines.push(`${indent}${typedLocal(node.id)} = res_${s}`);
-                lines.push(`${indent}produced_${s} = true`);
-            }
-            else {
-                lines.push(`${indent}${oc}, ${oc}Err := handlers.${nodeMethodName(comp.name, node.id)}(ports_${s}, ${boundArg})`);
-                lines.push(`${indent}if ${oc}Err != nil {`);
-                lines.push(`${indent}\treturn ${zeroOut}, opFailed(${JSON.stringify(node.id)}, ${policyLit}, ${oc}Err)`);
-                lines.push(`${indent}}`);
-                lines.push(copy(indent));
-                lines.push(`${indent}produced_${s} = true`);
-            }
+            lines.push(`${indent}wire_${s}, wire_${s}Err := handlers.${nodeMethodName(comp.name, node.id)}(ports_${s}, ${boundArg})`);
+            lines.push(`${indent}if wire_${s}Err != nil {`);
+            lines.push(`${indent}\treturn ${zeroOut}, opFailed(${JSON.stringify(node.id)}, ${policyLit}, wire_${s}Err)`);
+            lines.push(`${indent}}`);
+            lines.push(renderResultDeBox(ref, typedLocal(node.id), `wire_${s}`, node.id, plan, indent, returnZeroFail(zeroOut), seqCtr));
+            lines.push(`${indent}produced_${s} = true`);
         }
         for (const c of closers)
             lines.push(c);
@@ -2138,13 +1673,13 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, f
     // over collection (typed field access to the parent node's arr — no serialize).
     lines.push(`${indent}over_${s} := ${overExpr}`);
     lines.push(`${indent}${typedLocal(node.id)} = make(${elemGo}, 0, len(over_${s}))`);
+    // 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); elementPolicy still governs the handler's own leaf failures only.
     const elemRowRef = mapElemRowRef(node, arrRef, plan);
-    // a record element is de-boxed strictly: the handler returns the element WIRE and the arm decodes it via
-    // decodeWireElem_* (closing the scan-row silent-default hole). A de-box mismatch fails closed regardless
-    // of elementPolicy (matching the interpreter's whole-node outType throw); elementPolicy still governs the
-    // handler's own leaf failures only.
-    const elemDeBox = elemRowRef.kind === "named";
-    const decElemFn = elemDeBox ? goDecodeElemName(comp.name, node.id) : "";
+    const elemRowGo = renderTypeRef(elemRowRef);
+    const renderElemDeBox = (target, src, il) => renderResultDeBox(elemRowRef, target, src, node.id, plan, il, returnZeroFail(zeroOut));
     // emit the per-element guard keep-gate (#108). `il` = indent, `elemVar` = the over element loop var.
     // On skip: batched → `continue` (element excluded from items + keptOver); non-batched → `continue`.
     const emitGuard = (il, elemVar) => {
@@ -2161,9 +1696,9 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, f
     };
     if (batched) {
         // BATCHED (#86 pt2 into / #93 shape 3 no-into / #108 guarded no-into): build kept-element ports,
-        // dispatch ONCE. The concrete Node_* returns RawRow{Rows []RawElem} aligned to items (or an error).
+        // dispatch ONCE. The concrete Node_* returns the aligned per-element WIRES ([]WireValue) or an error.
         // With a guard, `items` (and, for into, `keptOver`) hold only kept elements — matching run_behavior's
-        // keptIdx-aligned batch. `into` is never combined with a guard (rejected). no-into collects each row.
+        // keptIdx-aligned batch. `into` is never combined with a guard (rejected). Each wire is de-boxed inline.
         lines.push(`${indent}items_${s} := make([]${structName}, 0, len(over_${s}))`);
         if (hasInto)
             lines.push(`${indent}keptOver_${s} := make([]${overElemGo}, 0, len(over_${s}))`);
@@ -2181,37 +1716,22 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, f
         lines.push(`${indent}\tbp_${s} := ${batchStruct}{Items: items_${s}}`);
         lines.push(`${indent}\tmo_${s}, mo_${s}Err := handlers.${nodeMethodName(comp.name, node.id)}(bp_${s}, nil)`);
         lines.push(`${indent}\tif mo_${s}Err != nil {`, `${indent}\t\treturn ${zeroOut}, opFailed(${JSON.stringify(node.id)}, "fail", mo_${s}Err)`, `${indent}\t}`);
-        // the batch length aligns to items (the handler returns the element WIRES aligned; a record element
-        // is de-boxed below, a non-record element is the concrete batch row).
-        const batchLen = elemDeBox ? `len(mo_${s})` : `len(mo_${s}.Rows)`;
-        const batchAt = (mk) => (elemDeBox ? `mo_${s}[${mk}]` : `mo_${s}.Rows[${mk}]`);
-        lines.push(`${indent}\tif ${batchLen} != len(items_${s}) {`, `${indent}\t\treturn ${zeroOut}, ${goErr("MAP_BATCH_RESULT_MISMATCH", `fmt.Sprintf("map '${node.id}': batched handler must return a list aligned to items (want %d)", len(items_${s}))`)}`, `${indent}\t}`);
+        lines.push(`${indent}\tif len(mo_${s}) != len(items_${s}) {`, `${indent}\t\treturn ${zeroOut}, ${goErr("MAP_BATCH_RESULT_MISMATCH", `fmt.Sprintf("map '${node.id}': batched handler must return a list aligned to items (want %d)", len(items_${s}))`)}`, `${indent}\t}`);
         if (hasInto) {
-            // #86 pt2: zip-attach the into field onto each kept over element (augmented element copier).
+            // #86 pt2: de-box each aligned element wire (into the `into` field's type), then zip-attach onto the
+            // kept over element (augmented element copier).
             lines.push(`${indent}\tfor mk_${s} := range keptOver_${s} {`);
-            if (elemDeBox) {
-                lines.push(`${indent}\t\telm_${s}, elm_${s}Err := ${decElemFn}(${batchAt(`mk_${s}`)})`);
-                lines.push(`${indent}\t\tif elm_${s}Err != nil {`, `${indent}\t\t\treturn ${zeroOut}, elm_${s}Err`, `${indent}\t\t}`);
-                lines.push(`${indent}\t\tel_${s} := ${elemMat}(keptOver_${s}[mk_${s}], elm_${s})`);
-            }
-            else {
-                lines.push(`${indent}\t\tel_${s} := ${elemMat}(keptOver_${s}[mk_${s}], ${batchAt(`mk_${s}`)})`);
-            }
+            lines.push(`${indent}\t\tvar dec_${s} ${elemRowGo}`);
+            lines.push(renderElemDeBox(`dec_${s}`, `mo_${s}[mk_${s}]`, `${indent}\t\t`));
+            lines.push(`${indent}\t\tel_${s} := ${elemMat}(keptOver_${s}[mk_${s}], dec_${s})`);
             lines.push(`${indent}\t\t${typedLocal(node.id)} = append(${typedLocal(node.id)}, el_${s})`);
             lines.push(`${indent}\t}`);
         }
         else {
-            // #93 shape 3 / #108: collect each element DIRECTLY from the aligned per-element row (field copy).
-            lines.push(`${indent}\tfor mk_${s} := 0; mk_${s} < ${batchLen}; mk_${s}++ {`);
+            // #93 shape 3 / #108: de-box each aligned per-element wire DIRECTLY into the element (result = kept).
+            lines.push(`${indent}\tfor mk_${s} := 0; mk_${s} < len(mo_${s}); mk_${s}++ {`);
             lines.push(`${indent}\t\tvar el_${s} ${renderTypeRef(arrRef.elem)}`);
-            if (elemDeBox) {
-                lines.push(`${indent}\t\telm_${s}, elm_${s}Err := ${decElemFn}(${batchAt(`mk_${s}`)})`);
-                lines.push(`${indent}\t\tif elm_${s}Err != nil {`, `${indent}\t\t\treturn ${zeroOut}, elm_${s}Err`, `${indent}\t\t}`);
-                lines.push(emitRowCopy(`el_${s}`, `elm_${s}`, elemRowRef, plan, indent.length + 2));
-            }
-            else {
-                lines.push(emitRowCopy(`el_${s}`, batchAt(`mk_${s}`), elemRowRef, plan, indent.length + 2));
-            }
+            lines.push(renderElemDeBox(`el_${s}`, `mo_${s}[mk_${s}]`, `${indent}\t\t`));
             lines.push(`${indent}\t\t${typedLocal(node.id)} = append(${typedLocal(node.id)}, el_${s})`);
             lines.push(`${indent}\t}`);
         }
@@ -2220,7 +1740,7 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, f
     else {
         // #93 shape 2 / #108: NON-batched map — dispatch the child handler ONCE PER KEPT ELEMENT (N physical
         // requests, matching run_behavior's per-element loop). A guarded element that fails `when` is skipped
-        // (no dispatch, excluded from the result). The concrete Node_* returns ONE RawElem_.
+        // (no dispatch, excluded from the result). The concrete Node_* returns ONE element WIRE (WireValue).
         lines.push(`${indent}for mk_${s} := range over_${s} {`);
         lines.push(`${indent}\t${elemLocal(s)} := over_${s}[mk_${s}]`);
         for (const l of emitGuard(indent + "\t", elemLocal(s)))
@@ -2240,20 +1760,17 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, f
         else {
             lines.push(`${indent}\tif mo_${s}Err != nil {`, `${indent}\t\treturn ${zeroOut}, opFailed(${JSON.stringify(node.id)}, "fail", mo_${s}Err)`, `${indent}\t}`);
         }
-        // a record element's wire is de-boxed strictly. A de-box mismatch fails closed regardless of
+        // the element's wire is de-boxed strictly INLINE. A de-box mismatch fails closed regardless of
         // elementPolicy (≡ the interpreter's whole-node outType throw); elementPolicy governs the handler's
         // own leaf failures only (above).
-        const elemVar = elemDeBox ? `elm_${s}` : `mo_${s}`;
-        if (elemDeBox) {
-            lines.push(`${indent}\telm_${s}, elm_${s}Err := ${decElemFn}(mo_${s})`);
-            lines.push(`${indent}\tif elm_${s}Err != nil {`, `${indent}\t\treturn ${zeroOut}, elm_${s}Err`, `${indent}\t}`);
-        }
         if (hasInto) {
-            lines.push(`${indent}\tel_${s} := ${elemMat}(${elemLocal(s)}, ${elemVar})`);
+            lines.push(`${indent}\tvar dec_${s} ${elemRowGo}`);
+            lines.push(renderElemDeBox(`dec_${s}`, `mo_${s}`, `${indent}\t`));
+            lines.push(`${indent}\tel_${s} := ${elemMat}(${elemLocal(s)}, dec_${s})`);
         }
         else {
             lines.push(`${indent}\tvar el_${s} ${renderTypeRef(arrRef.elem)}`);
-            lines.push(emitRowCopy(`el_${s}`, elemVar, elemRowRef, plan, indent.length + 1));
+            lines.push(renderElemDeBox(`el_${s}`, `mo_${s}`, `${indent}\t`));
         }
         lines.push(`${indent}\t${typedLocal(node.id)} = append(${typedLocal(node.id)}, el_${s})`);
         lines.push(`${indent}}`);
@@ -2324,10 +1841,9 @@ function emitFanoutArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut
     // empty id-list => empty connection (handler not called), matching run_behavior.
     lines.push(`${indent}if len(pi_${s}) > 0 {`);
     lines.push(`${indent}\tbp_${s} := ${batchStruct}{Items: pi_${s}}`);
-    // the fanout element row is a named record → the handler returns the aligned element WIRES ([]WireRow),
-    // and each is de-boxed strictly via decodeWireElem_* (a de-box mismatch fails closed). A DANGLING id is
-    // a nil wire → the zero element (empty dedupeKey), which the dangling drop below excludes.
-    const decElemFn = goDecodeElemName(comp.name, node.id);
+    // the handler returns the aligned per-id element WIRES (one nilable WireValue per id); each present
+    // body is de-boxed strictly INLINE (a de-box mismatch fails closed). A DANGLING id is a nil wire → the
+    // zero element (empty dedupeKey), which the dangling drop below excludes.
     lines.push(`${indent}\tfo_${s}, fo_${s}Err := handlers.${nodeMethodName(comp.name, node.id)}(bp_${s}, nil)`);
     lines.push(`${indent}\tif fo_${s}Err != nil {`, `${indent}\t\treturn ${zeroOut}, opFailed(${JSON.stringify(node.id)}, "fail", fo_${s}Err)`, `${indent}\t}`);
     lines.push(`${indent}\tif len(fo_${s}) != len(pi_${s}) {`, `${indent}\t\treturn ${zeroOut}, ${goErr("FANOUT_BATCH_RESULT_MISMATCH", `fmt.Sprintf("fanout '${node.id}': batched handler must return a list aligned to the deduped id list (want %d)", len(pi_${s}))`)}`, `${indent}\t}`);
@@ -2339,9 +1855,7 @@ function emitFanoutArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut
     lines.push(`${indent}\tfor fi_${s} := range fo_${s} {`);
     lines.push(`${indent}\t\tvar el_${s} ${elemGo}`);
     lines.push(`${indent}\t\tif fo_${s}[fi_${s}] != nil {`);
-    lines.push(`${indent}\t\t\telm_${s}, elm_${s}Err := ${decElemFn}(fo_${s}[fi_${s}])`);
-    lines.push(`${indent}\t\t\tif elm_${s}Err != nil {`, `${indent}\t\t\t\treturn ${zeroOut}, elm_${s}Err`, `${indent}\t\t\t}`);
-    lines.push(emitRowCopy(`el_${s}`, `elm_${s}`, elemRef, plan, indent.length + 3));
+    lines.push(renderResultDeBox(elemRef, `el_${s}`, `(*fo_${s}[fi_${s}])`, node.id, plan, `${indent}\t\t\t`, returnZeroFail(zeroOut)));
     lines.push(`${indent}\t\t}`);
     lines.push(`${indent}\t\tkey_${s} := el_${s}.${dkGo}`);
     if (f.drop === "dangling") {
@@ -2787,7 +2301,7 @@ var ComponentNamesNativeRaw = []string{${native.map((c) => JSON.stringify(c.name
  * mismatch Sprintf, `strings` for a concat builder, `sync` for a parallel stage). ExpectedSpecVersions
  * stays as a local `var` for provenance, but the old `dslcontracts.SpecVersions` skew `init()` is GONE
  * (change #5 — there is no runtime to skew against once the module is runtime-free). */
-function emitMinimalHeader(ctx, needStrings, needSync, needFmt, needMath, needStrconv = false) {
+function emitMinimalHeader(ctx, needStrings, needSync, needFmt, needMath, needStrconv = false, wireImport) {
     const sv = ctx.specVersions;
     const imports = [];
     if (needFmt)
@@ -2800,6 +2314,10 @@ function emitMinimalHeader(ctx, needStrings, needSync, needFmt, needMath, needSt
         imports.push(`\t"strings"`);
     if (needSync)
         imports.push(`\t"sync"`);
+    // a configured consumer wire package (goWire.import) — the covered module references its CONCRETE
+    // WireValue/WireRow/WireList types (default: in-package, no import).
+    if (wireImport !== undefined)
+        imports.push(`\t${JSON.stringify(wireImport)}`);
     const importBlock = imports.length > 0 ? `\nimport (\n${imports.join("\n")}\n)\n` : "";
     return `// GENERATED by behavior-contracts (bc#90, go-typed-native — the RUNTIME-FREE covered read de-box) — DO NOT EDIT.
 // Input: portable component-graph IR only. Every component here is a COVERED READ (sequential typed
@@ -2825,17 +2343,16 @@ function emit(ctx) {
     // #108: reset the native-expr helper-usage accumulator (set by the cond/guard compiler when it emits
     // a fallible checked-arith helper call — determines whether the helper library + `math` import ship).
     goExprUsed.helpers = false;
+    const wire = resolveGoWire(ctx);
     // Emit the runners first so the nv* helper usage flags are known.
     const flags = { bind: false, field: false, cat: false, arr: false };
     const structs = [];
     const inStructs = [];
-    const rowStructs = [];
-    const handlerIfaces = [];
     const elemCopiers = [];
     const runnerCodes = [];
-    // 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 kind
+    // consts + probe RESULT structs) 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) {
         inStructs.push(emitInStruct(c, plan));
         const typedNodes = new Map();
@@ -2861,18 +2378,11 @@ function emit(ctx) {
                 structs.push(emitPortsStruct(c, n, undefined, plan, typedNodes));
             }
         }
-        // fail closed for a record inside a non-named top (never a silent trust) — before emitting anything.
-        assertDeBoxableResults(c, typedNodes, plan);
-        // CONCRETE per-node row structs + the per-component handler interface (the fully-concrete seam).
-        rowStructs.push(emitRawRowStructs(c, typedNodes, plan));
-        handlerIfaces.push(emitHandlerInterface(c, typedNodes, plan));
-        // the strict de-box functions for this component's de-box-eligible (named-record) reads.
-        emitNodeDecodeFns(c, typedNodes, plan, decodeEmitted, decodeFns);
-        // augmented-element copiers for covered map...into nodes (over fields + concrete into row).
+        // augmented-element copiers for covered map...into nodes (over fields + the de-boxed into value).
         const mm = emitMapElemMaterializers(c, typedNodes, plan);
         if (mm)
             elemCopiers.push(mm);
-        const r = emitNativeRawRunner(c, plan, flags);
+        const r = emitNativeRawRunner(c, plan, flags, wire);
         runnerCodes.push(r.code);
     }
     const structSurface = emitStructSurface(native);
@@ -2901,37 +2411,31 @@ function emit(ctx) {
     // #108: `math` is imported iff the native-expr compiler emitted a fallible helper (bcExpr_modF uses
     // math.Mod). The helper library itself is baked into the module only when used (goExprUsed.helpers).
     const needMath = goExprUsed.helpers;
-    // `strconv` is imported iff a generated de-box parses a numeric field (int/float range check).
-    const needStrconv = decodeFns.some((f) => f.includes("strconv."));
-    const header = emitMinimalHeader(ctx, false, needSync, needFmt, needMath, needStrconv);
+    // `strconv` is imported iff a generated inline de-box parses a numeric field (int/float range check).
+    const needStrconv = runnerCodes.some((c) => c.includes("strconv."));
+    const header = emitMinimalHeader(ctx, false, needSync, needFmt, needMath, needStrconv, wire.import);
     const banner = `// COMBINED READ layer (bc#90 — the RUNTIME-FREE read de-box; STRUCT-ONLY, FULLY-NATIVE surface). A
 // covered read is a strictly-sequential typed componentRef chain (point reads + relationKind:single
 // children), emitted ONLY here: each node builds a native ports struct by direct field assignment (every
 // port is a CONCRETE Go value — string / bool / []string projection / int64 limit — NO boxed Value, NO
-// PortReader accessor); the CONCRETE per-component handler interface (Handler_<comp>) takes a typed
-// produced-aware 'bound' pointer and returns a CONCRETE per-node row struct (Row_<comp>_<node>, typed
-// fields = the node's outType) whose fields the runner reads DIRECTLY and copies 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). Exec is INLINE sequential (no plan driver) so
-// a relation child reads the parent's REAL struct result via direct field access and the child-present
+// PortReader accessor); the runner takes the consumer's CONCRETE Handler_<comp> handler by
+// value and calls h.Node_*(...) DIRECTLY (no interface, no generics — zero dynamic dispatch). Each Node_*
+// takes a typed produced-aware 'bound' pointer and returns the node's result WIRE (a single ${wire.value});
+// 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). Exec is INLINE sequential (no plan driver)
+// so a relation child reads the parent's REAL struct result via direct field access and the child-present
 // decision is made from the real parent value — relationSingle / connection converge with run_behavior
-// (fixes #323/#74). The exposed API is the STRUCT-returning RunNativeRawStruct_<comp> (the consumer
-// keeps the model native — no serialization on the read hot path). This module is FULLY NATIVE: a naive
-// grep for boxing primitives OR for the bc-runtime package finds nothing, by design (bc#90/runtime-free).`;
+// (fixes #323/#74). The exposed API is the STRUCT-returning RunNativeRawStruct_<comp> (the consumer keeps
+// the model native — no serialization on the read hot path). This module is FULLY NATIVE: a naive grep for
+// boxing primitives OR for the bc-runtime package finds nothing, by design (bc#90/runtime-free).`;
     const sections = [
         banner,
         `// Local concrete failure type (runtime-free) — a covered runner returns *BehaviorError (satisfies\n// error) instead of a bc-runtime failure, so the fully-covered module imports ZERO bc runtime.\n${behaviorErrorType}`,
         decls ? `// Typed struct declarations (outType-derived; hash-dedup — shared type plan).\n${decls}` : undefined,
         `// Per-component CONCRETE input structs (fields = inputPorts; the consumer builds them natively —\n// no generic *Obj crosses the covered read boundary).\n${inStructs.join("\n\n")}`,
-        rowStructs.some((r) => r.trim().length > 0)
-            ? `// CONCRETE per-node handler-result row structs (typed fields = the node's outType; + error signal).\n${rowStructs.filter((r) => r.trim().length > 0).join("\n\n")}`
-            : undefined,
-        `// Per-component CONCRETE handler interfaces (one typed Node_* method per covered node).\n${handlerIfaces.join("\n\n")}`,
-        decodeFns.length
-            ? `// strict de-box wire seam — the consumer implements WireRow/WireList over its wire payload\n// (variant classification); the generated decodeWire_* owns strictness (required/optional, present/\n// absent, error assembly, fail-closed). Concrete probe structs — no boxed Value on the seam.\n${emitProbeWireTypes()}`
-            : undefined,
-        decodeFns.length
-            ? `// Generated strict de-box functions (per named record type; structured Error Value on mismatch).\n${decodeFns.join("\n\n")}`
+        anyWire
+            ? `// strict de-box wire seam — the consumer supplies CONCRETE ${wire.value} / ${wire.row} / ${wire.list}\n// types (variant classification) and the runner classifies each node result against the STATICALLY\n// declared type via their methods; the generated INLINE de-box owns strictness (required/optional,\n// present/absent, error assembly, fail-closed). bc emits only the probe RESULT structs — concrete data,\n// no boxed Value, no interface, no dictionary crosses the seam.\n${emitProbeWireTypes(wire)}`
             : undefined,
         elemCopiers.length
             ? `// Augmented map-element copiers (over element fields + the concrete into row — pure assignment).\n${elemCopiers.join("\n\n")}`
@@ -2972,32 +2476,21 @@ export function goTypedNativeObserve(ir, runtimeImport) {
         // decode the generic *Obj input into the CONCRETE In_<comp> struct (test glue — ONE decode at the
         // top, OUTSIDE the covered hot path; a REQUIRED declared input is present so an absent key is a
         // fail-closed decode error surfaced here, never on the native runner path).
-        return `\tif name == ${JSON.stringify(c.name)} {\n\t\tin, ierr := decode_${inStructName(c.name)}(input)\n\t\tif ierr != nil {\n\t\t\treturn nil, ierr\n\t\t}\n\t\ttv, err := ${runnerName(c.name)}(handlers, in)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\treturn ${ser}, nil\n\t}`;
+        return `\tif name == ${JSON.stringify(c.name)} {\n\t\tin, ierr := decode_${inStructName(c.name)}(input)\n\t\tif ierr != nil {\n\t\t\treturn nil, ierr\n\t\t}\n\t\ttv, err := ${runnerName(c.name)}(${handlerTypeName(c.name)}{handlers}, in)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\treturn ${ser}, nil\n\t}`;
     })
         .join("\n");
     // input decoders (TEST glue): generic *Obj -> concrete In_<comp>. Scalar fields read the typed value
     // (a `.(T)` here is on the SDK/wire Value in the OBSERVE companion, never in the covered module).
     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 WireRow / []WireRow)?
-    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 bc 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 exists only so the harness drives the
-    // generated de-box from the same scripted vectors run_behavior uses — so actualWireType observed in a
-    // mismatch is the PRODUCER tag (e.g. "N"), not the collapsed native type.
+    // 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 bc Value as the CONCRETE WireValue / WireRow /
+    // WireList (the in-package default seam types the covered module references) and classifies each datum's
+    // native type into a DynamoDB-flavored wire tag (S/N/BOOL/L/M/NULL). A real consumer supplies its OWN
+    // concrete WireValue over its AttributeValue payload; this exists only so the harness drives the
+    // generated inline de-box from the same scripted vectors run_behavior uses — so actualWireType observed
+    // in a mismatch is the PRODUCER tag (e.g. "N"), not the collapsed native type.
     const wireAdapter = anyDeBox
         ? `// ── scripted wire adapter (TEST glue) ──
 func scriptedWireTag(v ${PKG}.Value) string {
@@ -3076,7 +2569,7 @@ func probeRowVal(v ${PKG}.Value) RowProbe {
 		return RowProbe{Kind: probeNull, ActualWireType: "NULL", Raw: "null"}
 	}
 	if o, ok := v.(*${PKG}.Obj); ok {
-		return RowProbe{Kind: probeGot, Got: scriptedWireRow{obj: o}, ActualWireType: "M"}
+		return RowProbe{Kind: probeGot, Got: WireRow{obj: o}, ActualWireType: "M"}
 	}
 	return RowProbe{Kind: probeWrong, ActualWireType: scriptedWireTag(v), Raw: scriptedWireRaw(v)}
 }
@@ -3086,79 +2579,89 @@ func probeListVal(v ${PKG}.Value) ListProbe {
 		return ListProbe{Kind: probeNull, ActualWireType: "NULL", Raw: "null"}
 	}
 	if a, ok := v.([]${PKG}.Value); ok {
-		return ListProbe{Kind: probeGot, Got: scriptedWireList{items: a}, ActualWireType: "L"}
+		return ListProbe{Kind: probeGot, Got: WireList{items: a}, ActualWireType: "L"}
 	}
 	return ListProbe{Kind: probeWrong, ActualWireType: scriptedWireTag(v), Raw: scriptedWireRaw(v)}
 }
 
-type scriptedWireRow struct {
-	obj *${PKG}.Obj
+// WireValue — the CONCRETE scripted node-result wire (the in-package default seam type the covered runner
+// classifies via As*). A top value is always present, so As* never observes Absent; a scripted null is a
+// nil Value → Null. A real consumer supplies its own concrete WireValue over its AttributeValue payload.
+type WireValue struct {
+	v ${PKG}.Value
 }
 
-func newScriptedWireRow(v ${PKG}.Value) WireRow {
-	o, _ := v.(*${PKG}.Obj)
-	return scriptedWireRow{obj: o}
+func (w WireValue) AsString() StringProbe { return probeStringVal(w.v) }
+func (w WireValue) AsNumber() NumberProbe { return probeNumberVal(w.v) }
+func (w WireValue) AsBool() BoolProbe     { return probeBoolVal(w.v) }
+func (w WireValue) AsRow() RowProbe       { return probeRowVal(w.v) }
+func (w WireValue) AsList() ListProbe     { return probeListVal(w.v) }
+
+// WireRow / WireList — the CONCRETE scripted wire map / array (the in-package default seam types), probed
+// per declared field / element by the generated inline de-box (their methods return bc's probe structs).
+type WireRow struct {
+	obj *${PKG}.Obj
 }
 
-func (w scriptedWireRow) field(name string) (${PKG}.Value, bool) {
+func (w WireRow) field(name string) (${PKG}.Value, bool) {
 	if w.obj == nil {
 		return nil, false
 	}
 	return w.obj.Get(name)
 }
 
-func (w scriptedWireRow) Keys() []string {
+func (w WireRow) Keys() []string {
 	if w.obj == nil {
 		return nil
 	}
 	return w.obj.Keys
 }
 
-func (w scriptedWireRow) ProbeString(field string) StringProbe {
+func (w WireRow) ProbeString(field string) StringProbe {
 	if v, ok := w.field(field); ok {
 		return probeStringVal(v)
 	}
 	return StringProbe{Kind: probeAbsent}
 }
 
-func (w scriptedWireRow) ProbeNumber(field string) NumberProbe {
+func (w WireRow) ProbeNumber(field string) NumberProbe {
 	if v, ok := w.field(field); ok {
 		return probeNumberVal(v)
 	}
 	return NumberProbe{Kind: probeAbsent}
 }
 
-func (w scriptedWireRow) ProbeBool(field string) BoolProbe {
+func (w WireRow) ProbeBool(field string) BoolProbe {
 	if v, ok := w.field(field); ok {
 		return probeBoolVal(v)
 	}
 	return BoolProbe{Kind: probeAbsent}
 }
 
-func (w scriptedWireRow) ProbeRow(field string) RowProbe {
+func (w WireRow) ProbeRow(field string) RowProbe {
 	if v, ok := w.field(field); ok {
 		return probeRowVal(v)
 	}
 	return RowProbe{Kind: probeAbsent}
 }
 
-func (w scriptedWireRow) ProbeList(field string) ListProbe {
+func (w WireRow) ProbeList(field string) ListProbe {
 	if v, ok := w.field(field); ok {
 		return probeListVal(v)
 	}
 	return ListProbe{Kind: probeAbsent}
 }
 
-type scriptedWireList struct {
+type WireList struct {
 	items []${PKG}.Value
 }
 
-func (l scriptedWireList) Len() int                    { return len(l.items) }
-func (l scriptedWireList) ElemString(i int) StringProbe { return probeStringVal(l.items[i]) }
-func (l scriptedWireList) ElemNumber(i int) NumberProbe { return probeNumberVal(l.items[i]) }
-func (l scriptedWireList) ElemBool(i int) BoolProbe     { return probeBoolVal(l.items[i]) }
-func (l scriptedWireList) ElemRow(i int) RowProbe       { return probeRowVal(l.items[i]) }
-func (l scriptedWireList) ElemList(i int) ListProbe     { return probeListVal(l.items[i]) }
+func (l WireList) Len() int                     { return len(l.items) }
+func (l WireList) ElemString(i int) StringProbe { return probeStringVal(l.items[i]) }
+func (l WireList) ElemNumber(i int) NumberProbe { return probeNumberVal(l.items[i]) }
+func (l WireList) ElemBool(i int) BoolProbe     { return probeBoolVal(l.items[i]) }
+func (l WireList) ElemRow(i int) RowProbe       { return probeRowVal(l.items[i]) }
+func (l WireList) ElemList(i int) ListProbe     { return probeListVal(l.items[i]) }
 
 // FailureDetail exposes the structured Error Value fields WITHOUT naming the local ErrorDetail type, so
 // the harness can assert the de-box's kind / field / expectedType / actualWireType / rawValue (TEST
@@ -3171,21 +2674,17 @@ func (e *BehaviorError) FailureDetail() (kind, model, field, expectedType, actua
 	return d.Kind, d.Model, d.Field, d.ExpectedType, d.ActualWireType, d.RawValue, true
 }`
         : "";
-    // The observe companion drives EVERY covered component, so its handler type param H must satisfy
-    // EVERY per-component concrete Handler_<comp> interface — a combined constraint embeds them all.
-    const combinedConstraint = `allNativeRawHandlers`;
-    const constraintDecl = `// ${combinedConstraint} — the combined constraint embedding every covered component's concrete
-// handler interface, so one handler value drives all covered runners (test glue only).
-type ${combinedConstraint} interface {
-${native.map((c) => `\t${handlerIfaceName(c.name)}`).join("\n")}
-}`;
-    // ── concrete scripted adapter (TEST glue): implements every Node_* method by draining a per-
-    // COMPONENT scripted-outcome queue and DECODING the scripted ok Value into the CONCRETE row struct.
-    // This is where the generic scripted source (a Value queue) meets the concrete per-node seam: the
-    // decode is generated (it knows the concrete row type), so the runner stays fully concrete. ──
-    const decodeFns = [];
+    // Handler_<comp> wrapper types: the covered runner takes the CONCRETE per-component handler by value
+    // (non-generic). One scripted queue backs every component, so each Handler_<comp> embeds the shared
+    // *ScriptedNativeRaw — the Node_* methods (on *ScriptedNativeRaw) are promoted, so the runner's direct
+    // h.Node_*(...) call resolves to a concrete method (no interface, no dictionary). Test glue only.
+    const handlerWrappers = native
+        .map((c) => `// ${handlerTypeName(c.name)} — the CONCRETE handler the '${c.name}' runner takes by value (embeds the\n// shared scripted queue; the Node_* methods are promoted).\ntype ${handlerTypeName(c.name)} struct {\n\t*ScriptedNativeRaw\n}`)
+        .join("\n\n");
+    // ── concrete scripted adapter (TEST glue): implements every Node_* method by draining a per-COMPONENT
+    // scripted-outcome queue and returning the scripted ok Value wrapped as a WireValue (the generic
+    // scripted source — a Value queue — meets the uniform CONCRETE wire seam). ──
     const methodImpls = [];
-    const emittedDecode = new Set();
     for (const c of native) {
         const typedNodes = new Map();
         for (const n of c.body)
@@ -3196,16 +2695,12 @@ ${native.map((c) => `\t${handlerIfaceName(c.name)}`).join("\n")}
                 continue; // #108: cond has no handler method (pure Expression) — no scripted impl.
             const ref = typedNodes.get(n.id);
             if ("fanout" in n) {
+                // fanout: return the aligned per-id element WIRES ([]*WireValue); a null aligned body is a
+                // DANGLING id → nil (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`;
                 const foBoundT = boundGoType(n, c, typedNodes, plan);
-                if (elemDeBox) {
-                    // a record-element fanout returns the aligned element WIRES; the covered runner de-boxes each.
-                    // A null aligned body is a DANGLING id — a nil wire (the runner maps it to the zero elem row).
-                    methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, n.id)}(_ ${portsT}, _ ${foBoundT}) ([]WireRow, error) {
+                methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, n.id)}(_ ${portsT}, _ ${foBoundT}) ([]*WireValue, error) {
 	src, ok := s.next(${JSON.stringify(f.component)})
 	if !ok {
 		return nil, unknownComponent(${JSON.stringify(f.component)})
@@ -3214,54 +2709,27 @@ ${native.map((c) => `\t${handlerIfaceName(c.name)}`).join("\n")}
 		return nil, leafFailure(src.err)
 	}
 	arr, _ := src.ok.([]${PKG}.Value)
-	wires := make([]WireRow, 0, len(arr))
+	wires := make([]*WireValue, 0, len(arr))
 	for _, ev := range arr {
 		if ev == nil {
 			wires = append(wires, nil)
 			continue
 		}
-		wires = append(wires, newScriptedWireRow(ev))
+		wv := WireValue{v: ev}
+		wires = append(wires, &wv)
 	}
 	return wires, nil
-}`);
-                    continue;
-                }
-                const elemRowRef = fanoutItemsElemRef(n, ref, plan);
-                const elemDecode = emitDecodeRow(c.name, n.id, elemT, elemRowRef, plan, emittedDecode, decodeFns, "Elem");
-                methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, n.id)}(_ ${portsT}, _ ${foBoundT}) (${batchT}, error) {
-	src, ok := s.next(${JSON.stringify(f.component)})
-	if !ok {
-		return ${batchT}{}, unknownComponent(${JSON.stringify(f.component)})
-	}
-	if src.isErr {
-		return ${batchT}{}, leafFailure(src.err)
-	}
-	arr, _ := src.ok.([]${PKG}.Value)
-	rows := make([]${elemT}, 0, len(arr))
-	for _, ev := range arr {
-		if ev == nil {
-			rows = append(rows, ${elemT}{})
-			continue
-		}
-		rows = append(rows, ${elemDecode}(ev))
-	}
-	return ${batchT}{Rows: rows}, nil
 }`);
                 continue;
             }
             if ("map" in n) {
+                // map: batched → one WIRE per element ([]WireValue); non-batched → one element WIRE (WireValue).
                 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);
                 const mapBoundT = boundGoType(n, c, typedNodes, plan);
-                if (elemDeBox) {
-                    // a record-element map returns the element WIRE(s); the covered runner de-boxes each strictly.
-                    if (batched) {
-                        methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, n.id)}(_ ${portsT}, _ ${mapBoundT}) ([]WireRow, error) {
+                if (batched) {
+                    methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, n.id)}(_ ${portsT}, _ ${mapBoundT}) ([]WireValue, error) {
 	src, ok := s.next(${JSON.stringify(m.component)})
 	if !ok {
 		return nil, unknownComponent(${JSON.stringify(m.component)})
@@ -3270,155 +2738,74 @@ ${native.map((c) => `\t${handlerIfaceName(c.name)}`).join("\n")}
 		return nil, leafFailure(src.err)
 	}
 	arr, _ := src.ok.([]${PKG}.Value)
-	wires := make([]WireRow, 0, len(arr))
+	wires := make([]WireValue, 0, len(arr))
 	for _, ev := range arr {
-		wires = append(wires, newScriptedWireRow(ev))
+		wires = append(wires, WireValue{v: ev})
 	}
 	return wires, nil
-}`);
-                    }
-                    else {
-                        methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, n.id)}(_ ${portsT}, _ ${mapBoundT}) (WireRow, error) {
-	src, ok := s.next(${JSON.stringify(m.component)})
-	if !ok {
-		return nil, unknownComponent(${JSON.stringify(m.component)})
-	}
-	if src.isErr {
-		return nil, leafFailure(src.err)
-	}
-	return newScriptedWireRow(src.ok), nil
-}`);
-                    }
-                    continue;
-                }
-                const elemRowRef = mapElemRowRef(n, arrRef, plan);
-                const elemDecode = emitDecodeRow(c.name, n.id, elemT, elemRowRef, plan, emittedDecode, decodeFns, "Elem");
-                if (batched) {
-                    methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, n.id)}(_ ${portsT}, _ ${mapBoundT}) (${batchT}, error) {
-	src, ok := s.next(${JSON.stringify(m.component)})
-	if !ok {
-		return ${batchT}{}, unknownComponent(${JSON.stringify(m.component)})
-	}
-	if src.isErr {
-		return ${batchT}{}, leafFailure(src.err)
-	}
-	arr, _ := src.ok.([]${PKG}.Value)
-	rows := make([]${elemT}, 0, len(arr))
-	for _, ev := range arr {
-		rows = append(rows, ${elemDecode}(ev))
-	}
-	return ${batchT}{Rows: rows}, nil
 }`);
                 }
                 else {
-                    methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, n.id)}(_ ${portsT}, _ ${mapBoundT}) (${elemT}, error) {
+                    methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, n.id)}(_ ${portsT}, _ ${mapBoundT}) (WireValue, error) {
 	src, ok := s.next(${JSON.stringify(m.component)})
 	if !ok {
-		return ${elemT}{}, unknownComponent(${JSON.stringify(m.component)})
+		return WireValue{}, unknownComponent(${JSON.stringify(m.component)})
 	}
 	if src.isErr {
-		return ${elemT}{}, leafFailure(src.err)
+		return WireValue{}, leafFailure(src.err)
 	}
-	return ${elemDecode}(src.ok), nil
+	return WireValue{v: src.ok}, nil
 }`);
                 }
                 continue;
             }
+            // componentRef: return the whole result WIRE (one WireValue 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);
             const nodeBoundT = boundGoType(node, c, typedNodes, plan);
-            // 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 decodeWire_* then probes it. This mirrors a real consumer,
-            // whose handler 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 (WireRow / []WireRow / nilable WireRow /
-                // map[string]WireRow) — the covered runner de-boxes each record. #129: an arr node with an `items`
-                // port echoes the NATIVE port array; it is serialized back to []WireRow so the de-box round-trips.
-                const top = recordTop(ref);
-                const wireT = goWireTypeForTop(top);
-                // 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 recordGo = renderTypeRef(ref);
-                    // a SINGLE-field record admits a scalar-into-field wrap (echo:port + wrap:"v" → {v: ports.X}).
-                    const field = decl !== undefined && decl.fields.length === 1 ? decl.fields[0] : undefined;
-                    const fieldGo = field !== undefined ? renderTypeRef(field.type) : null;
-                    for (const pn of Object.keys(node.ports)) {
-                        let portGo = null;
-                        try {
-                            portGo = portFieldGoType(node.ports[pn], c, plan, typedNodes, `echo port '${pn}'`);
-                        }
-                        catch {
-                            portGo = null;
-                        }
-                        if (portGo === recordGo) {
-                            // case 2: the port IS the whole record (its type == the node's record type) → echo it
-                            // DIRECTLY (no field wrap), matching run_behavior's plain echo:port of a whole-record port.
-                            namedEcho += `\tif src.echo == ${JSON.stringify(pn)} {\n\t\treturn newScriptedWireRow(${serializeTyped(`ports.${goPortFieldName(pn)}`, ref, plan)}), nil\n\t}\n`;
-                        }
-                        else if (fieldGo !== null && field !== undefined && portGo === fieldGo) {
-                            // case 1: a scalar port wraps into the record's single field ({v: ports.X}).
-                            namedEcho += `\tif src.echo == ${JSON.stringify(pn)} {\n\t\treturn newScriptedWireRow(${serializeTyped(`${recordGo}{${goFieldName(field.name)}: ports.${goPortFieldName(pn)}}`, ref, plan)}), nil\n\t}\n`;
-                        }
+            // 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 fieldGo = field !== undefined ? renderTypeRef(field.type) : null;
+                const recordGo = renderTypeRef(ref);
+                for (const pn of Object.keys(node.ports)) {
+                    let portGo = null;
+                    try {
+                        portGo = portFieldGoType(node.ports[pn], c, plan, typedNodes, `echo port '${pn}'`);
+                    }
+                    catch {
+                        portGo = null;
+                    }
+                    if (portGo === recordGo) {
+                        // the port IS the whole record → echo it DIRECTLY (matching run_behavior's plain echo:port).
+                        echoBranches.push(`\tif src.echo == ${JSON.stringify(pn)} {\n\t\treturn WireValue{v: ${serializeTyped(`ports.${goPortFieldName(pn)}`, ref, plan)}}, nil\n\t}`);
+                    }
+                    else if (fieldGo !== null && field !== undefined && portGo === fieldGo) {
+                        // a scalar port wraps into the record's single field ({v: ports.X}).
+                        echoBranches.push(`\tif src.echo == ${JSON.stringify(pn)} {\n\t\treturn WireValue{v: ${serializeTyped(`${recordGo}{${goFieldName(field.name)}: ports.${goPortFieldName(pn)}}`, ref, plan)}}, nil\n\t}`);
                     }
                 }
-                const canEcho = (top.kind === "arr" && Object.prototype.hasOwnProperty.call(node.ports, "items")) || namedEcho !== "";
-                const portsParam = canEcho ? "ports" : "_";
-                let body;
-                if (top.kind === "named") {
-                    body = `${namedEcho}\treturn newScriptedWireRow(src.ok), nil`;
-                }
-                else if (top.kind === "arr") {
-                    const elemRef = ref.elem;
-                    const itemsF = goPortFieldName("items");
-                    const echoBranch = canEcho
-                        ? `\tif src.echo == "items" {\n\t\twires := make([]WireRow, 0, len(ports.${itemsF}))\n\t\tfor i := range ports.${itemsF} {\n\t\t\twires = append(wires, newScriptedWireRow(${serializeTyped(`ports.${itemsF}[i]`, elemRef, plan)}))\n\t\t}\n\t\treturn wires, nil\n\t}\n`
-                        : "";
-                    body = `${echoBranch}\tarr, _ := src.ok.([]${PKG}.Value)\n\twires := make([]WireRow, 0, len(arr))\n\tfor _, ev := range arr {\n\t\twires = append(wires, newScriptedWireRow(ev))\n\t}\n\treturn wires, nil`;
-                }
-                else if (top.kind === "opt") {
-                    body = `\tif src.ok == nil {\n\t\treturn nil, nil\n\t}\n\treturn newScriptedWireRow(src.ok), nil`;
-                }
-                else {
-                    body = `\tobj, _ := src.ok.(*${PKG}.Obj)\n\twires := make(map[string]WireRow)\n\tif obj != nil {\n\t\tfor _, k := range obj.Keys {\n\t\t\twires[k] = newScriptedWireRow(obj.Vals[k])\n\t\t}\n\t}\n\treturn wires, nil`;
-                }
-                methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, node.id)}(${portsParam} ${portsStructName(c.name, node.id)}, _ ${nodeBoundT}) (${wireT}, error) {
-	src, ok := s.next(${JSON.stringify(node.component)})
-	if !ok {
-		return nil, unknownComponent(${JSON.stringify(node.component)})
-	}
-	if src.isErr {
-		return nil, leafFailure(src.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 `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 named only when the echo path
-            // uses it (else the param stays `_` so a non-echo node compiles clean / unused-param-free).
-            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 to a Value array)
+                // so the node→leaf array dataflow test is non-vacuous.
+                echoBranches.push(`\tif src.echo == "items" {\n\t\treturn WireValue{v: ${serializeTyped(`ports.${goPortFieldName("items")}`, ref, plan)}}, nil\n\t}`);
+            }
+            const canEcho = echoBranches.length > 0;
             const portsParam = canEcho ? "ports" : "_";
-            const echoBranch = canEcho
-                ? `\tif src.echo == "items" {\n\t\treturn ${rowT}{Val: ports.${goPortFieldName("items")}}, nil\n\t}\n`
-                : "";
-            methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, node.id)}(${portsParam} ${portsStructName(c.name, node.id)}, _ ${nodeBoundT}) (${rowT}, error) {
+            const echoBlock = canEcho ? `${echoBranches.join("\n")}\n` : "";
+            methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, node.id)}(${portsParam} ${portsStructName(c.name, node.id)}, _ ${nodeBoundT}) (WireValue, error) {
 	src, ok := s.next(${JSON.stringify(node.component)})
 	if !ok {
-		return ${rowT}{}, unknownComponent(${JSON.stringify(node.component)})
+		return WireValue{}, unknownComponent(${JSON.stringify(node.component)})
 	}
 	if src.isErr {
-		return ${rowT}{}, leafFailure(src.err)
+		return WireValue{}, leafFailure(src.err)
 	}
-${echoBranch}	return ${decode}(src.ok), nil
+${echoBlock}	return WireValue{v: src.ok}, nil
 }`);
         }
     }
@@ -3433,10 +2820,10 @@ type scriptSrc struct {
 	ok    ${PKG}.Value
 }
 
-// ScriptedNativeRaw — the CONCRETE test handler: it satisfies every Handler_<comp> interface by
-// draining a per-COMPONENT scripted queue and decoding the ok Value into the concrete row struct.
-// The decode (decodeRow_*) is generated, so the covered runner drives fully-concrete Node_* methods.
-// EXPORTED so the runner glue (a separate package) can name it for the generic instantiation.
+// ScriptedNativeRaw — the CONCRETE test handler: its Node_* methods drain a per-COMPONENT scripted queue
+// and return the ok Value wrapped as a WireValue (the covered runner de-boxes it inline). Each runner
+// takes a Handler_<comp> value that embeds this, so the Node_* calls stay fully concrete (no interface).
+// EXPORTED so the runner glue (a separate package) can name it.
 type ScriptedNativeRaw struct {
 	mu     sync.Mutex
 	queues map[string][]scriptSrc
@@ -3510,10 +2897,10 @@ func (s *ScriptedNativeRaw) next(component string) (scriptSrc, bool) {
 }`;
     return `// GENERATED test-only observe companion (bc#77) — NOT part of the covered module. Serializes the
 // struct-native runner's result to a canonical Value for the equivalence pin, and carries the CONCRETE
-// scripted test handler (scriptedNativeRaw) that satisfies every Handler_<comp> interface by decoding a
-// scripted Value into the concrete per-node row. The consumer never uses this (it keeps the model
-// native + implements Handler_<comp> over its own wire payload); it exists only so the test harness can
-// byte-compare the STRUCT-only covered read against run_behavior. Same package as the covered module.
+// scripted test handler (ScriptedNativeRaw) + the CONCRETE WireValue/WireRow/WireList seam types +
+// per-component Handler_<comp> wrappers the runner takes. The consumer never uses this (it keeps the
+// model native + supplies its own concrete WireValue + Handler_<comp>); it exists only so the test
+// harness can byte-compare the STRUCT-only covered read against run_behavior. Same package as the module.
 package behaviors
 
 import (
@@ -3522,69 +2909,40 @@ ${anyDeBox ? '\t"strconv"\n\n' : ""}	"sync"
 	${PKG} "${runtimeImport ?? "github.com/foo-ogawa/behavior-contracts/go"}"
 )
 
-// scripted wire adapter (TEST glue) — wraps a scripted Value as a WireRow the generated de-box probes.
+// scripted wire adapter (TEST glue) — the CONCRETE WireValue/WireRow/WireList the covered module references.
 ${wireAdapter}
 
 // typed -> Value serializers (TEST glue only — the covered module has none).
 ${serializers}
 
-// Value -> typed struct marshallers (+ must* helpers) for the concrete-row decode (TEST glue only).
+// Value -> typed struct marshallers (+ must* helpers) for the input decoders (TEST glue only).
 ${marshallers}
 
 ${mustHelpers}
 
 ${arrOptHelpers}
 
-// per-node concrete-row decoders (scripted Value -> RawRow_/RawElem_ struct).
-${decodeFns.join("\n\n")}
-
 // input decoders (generic *Obj -> concrete In_<comp>; TEST glue, one decode at the observe boundary).
 ${inDecoders}
 
 ${adapter}
 
-${constraintDecl}
+// per-component CONCRETE handler wrappers (the runner takes one by value — embeds the shared queue).
+${handlerWrappers}
 
-// scriptedNativeRaw method impls (one per covered node — the concrete Node_* seam, test glue).
+// ScriptedNativeRaw method impls (one per covered node — the concrete Node_* seam returning WireValue).
 ${methodImpls.join("\n\n")}
 
-// ObserveNativeRaw drives the struct-native runner and serializes to a canonical Value (test only).
-// GENERIC over the CONCRETE combined handler type H — so each enclosed RunNativeRawStruct_* call is
-// instantiated at the concrete handler type (direct, devirtualized per-node method calls), not at an
-// interface. Instantiate with your concrete handler type to preserve the covered path's concreteness.
-func ObserveNativeRaw[H ${combinedConstraint}](name string, handlers H, input *${PKG}.Obj) (${PKG}.Value, error) {
+// ObserveNativeRaw drives the struct-native runner and serializes to a canonical Value (test only). It
+// takes the CONCRETE *ScriptedNativeRaw and wraps it per component in the runner's Handler_<comp> value —
+// each enclosed RunNativeRawStruct_* call is a NON-generic call over a concrete handler (direct,
+// devirtualized per-node method calls), never an interface or a generic dictionary.
+func ObserveNativeRaw(name string, handlers *ScriptedNativeRaw, input *${PKG}.Obj) (${PKG}.Value, error) {
 ${arms}
 	return nil, ${PKG}.NewBehaviorFailure("UNKNOWN_ENTRY", "component '"+name+"' is not a covered read (fail-closed)")
 }
 `;
 }
-/** emitDecodeRow — emit (once, deduped) a decoder `decodeRow_<comp>_<node><suffix>(v Value) <rowT>`
- * that materializes the scripted ok Value into the concrete row struct (typed fields = the outType /
- * elem-row type). Named: reuse the Value->struct marshaller + copy fields; scalar/arr/opt: materialize
- * into .Val. TEST glue only (the production consumer decodes its own wire payload). */
-function emitDecodeRow(compName, nodeId, rowT, ref, plan, emitted, out, suffix) {
-    const fn = `decodeRow_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}${suffix}`;
-    if (emitted.has(fn))
-        return fn;
-    emitted.add(fn);
-    const lines = [];
-    lines.push(`func ${fn}(v ${PKG}.Value) ${rowT} {`);
-    lines.push(`\tvar out ${rowT}`);
-    if (ref.kind === "named") {
-        const decl = findDecl(plan, ref.name);
-        lines.push(`\tt := ${goTypedInternals.materializeExpr("v", ref, plan)}`);
-        for (const f of decl.fields) {
-            lines.push(`\tout.${goFieldName(f.name)} = t.${goFieldName(f.name)}`);
-        }
-    }
-    else {
-        lines.push(`\tout.Val = ${goTypedInternals.materializeExpr("v", ref, plan)}`);
-    }
-    lines.push(`\treturn out`);
-    lines.push(`}`);
-    out.push(lines.join("\n"));
-    return fn;
-}
 /**
  * goTypedNativeEmitter — language id `go-typed-native` (bc#77). Emits the generic straight-line
  * body (for non-covered components / helpers) plus the COMBINED READ layer (native ports struct