behavior-contracts 0.8.5 → 0.8.6

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

@@ -15,14 +15,34 @@ function goErr(code, msgExpr) {
     return `&BehaviorError{Code: ${JSON.stringify(code)}, Message: ${msgExpr}}`;
 }
 /** emitBehaviorErrorType — the LOCAL concrete error type baked into the covered module so a runner can
- * fail closed with ZERO bc-runtime import. `*BehaviorError` satisfies `error`. */
+ * fail closed with ZERO bc-runtime import. `*BehaviorError` satisfies `error` and carries the leaf's
+ * structured Error Value (scp-error.md "The Error Value"). */
 function emitBehaviorErrorType() {
-    return `// BehaviorError — the LOCAL concrete failure type for the covered read plane (runtime-free): a
+    return `// ErrorDetail — the structured, recoverable payload a failure carries (scp-error.md "The Error
+// Value"). The LEAF produces it at the wire boundary (the only party holding both the declared type
+// and the raw wire datum); the runner transports it verbatim. Concrete fields — no boxed Value, no
+// serialized blob in a string: ExpectedType is Portable Type Notation, a rendering of a STATICALLY
+// DECLARED type, so nothing walks a type at runtime. Kind is the closed set (typeMismatch /
+// missingField / overflow), empty when the failure is not about a datum.
+type ErrorDetail struct {
+	Kind           string
+	Model          string
+	Field          string
+	ExpectedType   string
+	ActualWireType string
+	RawValue       string
+	Context        map[string]string
+}
+
+// BehaviorError — the LOCAL concrete failure type for the covered read plane (runtime-free): a
 // covered runner returns *BehaviorError (which satisfies error) instead of a bc-runtime failure, so
 // the fully-covered module imports ZERO bc runtime. Codes match run_behavior verbatim (byte-equal).
+// Detail carries the leaf's structured Error Value across the seam so a caller can log / skip /
+// repair / migrate rather than parse a message (nil when the failure is not about a datum).
 type BehaviorError struct {
 	Code    string
 	Message string
+	Detail  *ErrorDetail
 }
 
 func (e *BehaviorError) Error() string { return e.Code + ": " + e.Message }
@@ -30,7 +50,48 @@ func (e *BehaviorError) Error() string { return e.Code + ": " + e.Message }
 // FailureCode exposes the stable failure code (byte-equal to run_behavior) WITHOUT a bc-runtime type:
 // a caller that wants the code type-asserts the small local interface { FailureCode() string } rather
 // than a bc failure type — keeping this module runtime-free while a harness can still read the code.
-func (e *BehaviorError) FailureCode() string { return e.Code }`;
+func (e *BehaviorError) FailureCode() string { return e.Code }
+
+// unknownComponent — the fail-closed failure for a catalog name with no handler (byte-equal to
+// run_behavior). In the STATIC codegen model a missing impl is normally a compile error; this covers
+// the scripted test glue's dynamic queue miss.
+func unknownComponent(component string) *BehaviorError {
+	return &BehaviorError{Code: "UNKNOWN_COMPONENT", Message: "component '" + component + "' has no handler (fail-closed)"}
+}
+
+// leafFailure — a failure the LEAF reports (test glue): the runner assigns the node's failure code
+// from its Error Policy Kind, so what a leaf carries is its message and its structured Error Value.
+func leafFailure(message string) *BehaviorError {
+	return &BehaviorError{Code: "LEAF_FAILURE", Message: message}
+}
+
+// opFailed wraps a leaf failure as the node's Failure under its Error Policy Kind, carrying the
+// leaf's structured detail through unchanged (the runner transports the Error Value, it does not
+// synthesize or re-interpret it).
+func opFailed(node string, policy string, e error) *BehaviorError {
+	if be, ok := e.(*BehaviorError); ok {
+		return &BehaviorError{Code: "OP_FAILED", Message: "operation '" + node + "' failed under '" + policy + "' policy: " + be.Message, Detail: be.Detail}
+	}
+	return &BehaviorError{Code: "OP_FAILED", Message: "operation '" + node + "' failed under '" + policy + "' policy: " + e.Error()}
+}
+
+// deTypeMismatch / deMissingField / deOverflow — the de-box mismatch failures the generated decode
+// produces (scp-error.md "The Error Value"). Codes are byte-equal to the runtime outType check
+// (TYPE_MISMATCH / MISSING_PROP) so the covered read stays equivalent to run_behavior; detail.kind
+// distinguishes typeMismatch / missingField / overflow. ErrorDetail is built by a POSITIONAL literal so
+// the offending value is carried without naming the field (the covered module stays whole-file free of
+// the boxed result-type token; its only permitted occurrence is the ErrorDetail field declaration).
+func deTypeMismatch(model, field, expected, actualWire, raw string) *BehaviorError {
+	return &BehaviorError{Code: "TYPE_MISMATCH", Message: "node '" + model + "': " + field + ": expected " + expected + ", got " + actualWire, Detail: &ErrorDetail{"typeMismatch", model, field, expected, actualWire, raw, nil}}
+}
+
+func deMissingField(model, field, expected string) *BehaviorError {
+	return &BehaviorError{Code: "MISSING_PROP", Message: "node '" + model + "': " + field + ": required field is absent", Detail: &ErrorDetail{"missingField", model, field, expected, "", "", nil}}
+}
+
+func deOverflow(model, field, expected, actualWire, raw string) *BehaviorError {
+	return &BehaviorError{Code: "TYPE_MISMATCH", Message: "node '" + model + "': " + field + ": " + raw + " is outside the range of " + expected, Detail: &ErrorDetail{"overflow", model, field, expected, actualWire, raw, nil}}
+}`;
 }
 const { sanitize, emitExpr } = goStraightlineInternals;
 const { goFieldName, renderTypeRef, goScalar, serializeTyped, emitTypeDecls, emitSerializers, emitTypedValue, emitMustHelpers, } = goTypedInternals;
@@ -39,6 +100,510 @@ 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)
+        case "map":
+            return "map[string]WireRow";
+    }
+}
+/** 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(",")}}`;
+        }
+    }
+}
+/** 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() {
+    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
+	probeWrong  uint8 = 1 // present but a different wire variant (carries ActualWireType + Raw)
+	probeAbsent uint8 = 2 // no attribute for this field
+	probeNull   uint8 = 3 // present as the producer's null variant (opt → None; required → mismatch)
+)
+
+// StringProbe / NumberProbe / BoolProbe — a scalar probe result. Got holds the matched value (a
+// NumberProbe's Got is the raw numeric text; the de-box parses + range-checks it). ActualWireType is the
+// producer's own wire tag (a free string, e.g. a DynamoDB "S"/"N"/"BOOL"); Raw is the offending value
+// stringified. Concrete structs — no boxed Value crosses the seam.
+type StringProbe struct {
+	Kind           uint8
+	Got            string
+	ActualWireType string
+	Raw            string
+}
+
+type NumberProbe struct {
+	Kind           uint8
+	Got            string
+	ActualWireType string
+	Raw            string
+}
+
+type BoolProbe struct {
+	Kind           uint8
+	Got            bool
+	ActualWireType string
+	Raw            string
+}
+
+// RowProbe / ListProbe — a composite probe result: a nested WireRow (a DynamoDB "M") or WireList (an "L").
+type RowProbe struct {
+	Kind           uint8
+	Got            WireRow
+	ActualWireType string
+	Raw            string
+}
+
+type ListProbe struct {
+	Kind           uint8
+	Got            WireList
+	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);
+    if ("fanout" in node)
+        return fanoutItemsElemRef(node, ref, plan);
+    return mapElemRowRef(node, ref, plan);
+}
+/** mapFanoutElemDeBoxEligible — a map/fanout node whose element ROW is a named record de-boxes each
+ * element through the generated 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);
@@ -49,21 +614,14 @@ function portsStructName(compName, nodeId) {
     // type to implement the per-component Handler_<comp> interface's concrete Node_* method signatures.
     return `PortsNR_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
 }
-/**
- * portFieldGoType — the NATIVE Go type for a covered port field (bc#90 / runtime-free), read off the ONE
- * port lowering (compilePortNode / native-expr). The covered ports struct carries NO `dslcontracts.Value`
- * field: every port lowers to a concrete Go type, and a port that cannot lower FAILS CLOSED. The field
- * type is the compiled expression's TypeRef, so it can never disagree with the initializer (emitPortInit),
- * which is the SAME lowering read for its value. `where` names the emission site for the error.
- */
-function portFieldGoType(node, comp, plan, typedNodes, where = "port", opts) {
-    const c = compilePortNode(node, comp, plan, typedNodes, (h) => typedNodes.has(h), where, opts);
-    return c.renderedType ?? renderTypeRef(c.ref);
+/** scalar TypeRef → PortFieldType (native go scalar kind). */
+function goScalarPortField(scalar) {
+    return scalar === "string" ? "string" : scalar === "int" ? "int64" : scalar === "float" ? "float64" : "bool";
 }
 /**
  * goNativeResolveHead — the ONE ref-head resolver the runtime-free native-expr compiler reads, for cond
- * `if`/branches, a map/fanout `when` guard, AND a port (go twin — Go's value semantics need no ownership
- * ceremony). A head is a `$as` element binding, a prior body node's typed local, or an input port.
+ * `if`/branches, a map/fanout `when` guard, AND a port. A head is a `$as` element binding, a prior body
+ * node's typed local, or an input port.
  */
 function goNativeResolveHead(comp, plan, typedNodes, isPrior, opts) {
     return (head) => {
@@ -78,18 +636,14 @@ function goNativeResolveHead(comp, plan, typedNodes, isPrior, opts) {
 /**
  * compilePortNode — lower a port expression to its native ports-struct field via the runtime-free
  * native-expr compiler (native-expr.ts): the ONE port lowering. The port's field TYPE is the compiled
- * `ref`, its initializer the compiled `expr` — so the two are derived from a SINGLE lowering and can
- * never disagree. Any closed operator, a literal, a ref (input scalar/array/map, prior-node scalar/array,
- * `$as` element field), a concat, a static array, an optional-input read — all resolve here. A port that
- * cannot lower FAILS CLOSED loudly. A lowering that is FALLIBLE (hoists statements) is a covered SHAPE
- * returned here as-is; only the value site (emitPortInit) rejects it, since a ports-struct literal cannot
- * host statements — the coverage gate/type site must still see it as covered.
+ * `ref`, its initializer the compiled `expr` — derived from a SINGLE lowering, so they cannot disagree.
+ * Any closed operator, a literal, a ref (input scalar/array/map, prior-node scalar/array, `$as` element
+ * field), a concat, a static array, an optional-input read — all resolve here. A port that cannot lower
+ * FAILS CLOSED. A FALLIBLE lowering (hoists statements) is returned as-is; only emitPortInit rejects it.
  */
 function compilePortNode(node, comp, plan, typedNodes, isPrior, where, opts) {
     const resolveHead = goNativeResolveHead(comp, plan, typedNodes, isPrior, opts);
     try {
-        // zeroOut is unreachable: a fallible port is rejected at emitPortInit (a ports-struct literal hosts no
-        // statements), so the backend never renders an early-return with it.
         return new NativeExprCompiler(makeGoExprBackend("", resolveHead, plan)).compilePort(node);
     }
     catch (e) {
@@ -98,8 +652,73 @@ function compilePortNode(node, comp, plan, typedNodes, isPrior, where, opts) {
         throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go typed-native (runtime-free): ${where} ${JSON.stringify(node)} does not lower to a native Go value: ${e.message}`);
     }
 }
-/** the prior-node typed-local TypeRef map for a component (control-gate nodes are typeless; a map node
- * carries its produced-array ref). Shared by coverage, the struct surface, and the runner. */
+/**
+ * portFieldGoType — the NATIVE Go type for a covered port field (bc#90 / runtime-free). The covered
+ * ports struct carries NO `dslcontracts.Value` field: every port lowers to a concrete Go type.
+ *   - a static string-array (projection) → `[]string` (change #2);
+ *   - a bare int/float number literal (e.g. Query `limit: 20`) → `int64`/`float64`;
+ *   - a string/bool/scalar-input port → the scalar Go type (inferPortType).
+ * A port that would otherwise infer to the boxed `Value` (a dynamic operator, a non-static array, a
+ * Value-typed input) FAILS CLOSED — the covered read plane admits NO boxed escape (there is no
+ * `dslcontracts.Value` fallback on the native module). `where` names the emission site for the error.
+ */
+function portFieldGoType(node, comp, plan, typedNodes, where = "port", opts) {
+    const c = compilePortNode(node, comp, plan, typedNodes, (h) => typedNodes.has(h), where, opts);
+    return c.renderedType ?? renderTypeRef(c.ref);
+}
+function staticArrElems(node) {
+    if (node === null || typeof node !== "object" || Array.isArray(node))
+        return null;
+    const keys = Object.keys(node);
+    if (keys.length !== 1 || keys[0] !== "arr")
+        return null;
+    const arg = node.arr;
+    return Array.isArray(arg) ? arg : null;
+}
+/**
+ * isNativeRawComponent — a component covered by the combined read emitter. Strictly sequential
+ * (no real concurrency), body is ALL componentRef (no map/cond), default 'fail'/'continue'
+ * policy, relationKind is single/connection or absent, and EVERY node carries outType + the
+ * component carries outputType. relationKind:single / bindField ARE the point — inline exec makes
+ * the child-present decision from the real parent result. Ports AND the output are evaluated via
+ * the primitive SSoT over a Value-space portScope (so a dynamic operator in a port or an
+ * obj-assembly output is fine — the SSoT handles fail-closed semantics; only the RESULT plane +
+ * PORT container go native). A covered SHAPE that lacks outType is a fail-closed error raised at
+ * emit (see assertTypedCoverage) — never a silent re-box.
+ */
+/**
+ * numLiteralGoExpr — a BARE numeric port literal (JSON number, e.g. the `limit: 20` Query port).
+ * `classifyExpr` deliberately leaves a bare number `dynamic` (its checked int/float range rules are
+ * the evaluate SSoT, expr.go evalNumberLiteral), so a plain number never reaches the str/bool/null
+ * static branch. But a number literal IS statically resolvable to a native Go Value: the SAME
+ * range check the runtime applies is performed HERE at generation time (integral literal in the
+ * safe 2^53-1 window → int64; a fractional/exponent literal → the checked float64). Returns the Go
+ * expression for the literal's Value, or null when the node is not a bare number OR the integral
+ * literal is out of the safe window (that out-of-range case keeps the runtime INVALID_LITERAL
+ * semantics — the port is NOT covered natively, so the whole component falls through, never a
+ * silently-wrong inline). Mirrors coderuntime.evalNumberLiteral exactly.
+ */
+const NUM_SAFE_INT = 9007199254740991; // 2^53 - 1 (expr.go safeInt)
+function numLiteralGoExpr(node) {
+    if (typeof node !== "number" || !Number.isFinite(node))
+        return null;
+    if (Number.isInteger(node)) {
+        if (node < -NUM_SAFE_INT || node > NUM_SAFE_INT)
+            return null; // out of safe window → not covered (runtime INVALID_LITERAL)
+        return `${PKG}.Value(int64(${node}))`;
+    }
+    // fractional / exponent literal → checked float64 (finite, already guaranteed above).
+    return `${PKG}.Value(float64(${node}))`;
+}
+/** A port node is static (literal / ref / concat of those / static arr / bare number literal) —
+ * resolvable to a native Go Value with no NewObj / no evaluate interpreter. */
+/** planForComp — a TypePlan for a single component (its named types are component-scoped, so a
+ * one-component IR yields the same plan the full-IR build would for this component). */
+function planForComp(comp) {
+    return buildTypePlan({ irVersion: 1, exprVersion: 2, components: [comp] });
+}
+/** buildTypedNodes — the prior-node typed-local TypeRef map for a component (control-gate nodes are
+ * typeless; a map node carries its produced-array ref). An untyped node is omitted (not an error here). */
 function buildTypedNodes(comp, plan) {
     const typedNodes = new Map();
     for (const n of comp.body) {
@@ -114,25 +733,26 @@ function buildTypedNodes(comp, plan) {
     }
     return typedNodes;
 }
-function staticArrElems(node) {
-    if (node === null || typeof node !== "object" || Array.isArray(node))
-        return null;
-    const keys = Object.keys(node);
-    if (keys.length !== 1 || keys[0] !== "arr")
-        return null;
-    const arg = node.arr;
-    return Array.isArray(arg) ? arg : null;
+/** mapAsBinding — the `$as` element binding for a map/fanout node's element ports (the over-element
+ * TypeRef), or undefined when the over source does not resolve (an uncovered map). */
+function mapAsBinding(comp, node, typedNodes, plan) {
+    try {
+        return { name: node.map.as, ref: mapOverElemInfo(comp, node, typedNodes, plan).elemRef, plan };
+    }
+    catch {
+        return undefined;
+    }
 }
-/** Does a port lower to a native value? The ELIGIBILITY gate ASKS the one port lowering (compilePortNode
- * / native-expr) whether it can lower this port, rather than re-deriving the shape rules — so the gate
- * and the emitter can never disagree. A port that does not lower (or lowers fallibly) fails closed. */
+/** portIsStatic — the ELIGIBILITY gate ASKS the one port lowering (compilePortNode / native-expr)
+ * whether it can lower this port, rather than re-deriving the shape rules — so the gate and the emitter
+ * can never disagree. A port that does not lower (or lowers fallibly) fails closed. */
 function portIsStatic(node, comp, plan, typedNodes, asBinding) {
     try {
         compilePortNode(node, comp, plan, typedNodes, (h) => typedNodes.has(h), "port", asBinding !== undefined ? { asBinding, asBase: asBinding.name } : undefined);
         return true;
     }
     catch {
-        return false; // an eligibility probe: any lowering failure ⇒ not native-covered here.
+        return false;
     }
 }
 /** The output must lower to a typed struct/value with no Value-scope read: a ref whose head is a
@@ -180,8 +800,8 @@ function isFullyTyped(comp) {
     }
     return true;
 }
-function isNativeRaw(comp, plan) {
-    return isSequentialComponentRefRead(comp, plan) && isFullyTyped(comp);
+function isNativeRaw(comp) {
+    return isSequentialComponentRefRead(comp) && isFullyTyped(comp);
 }
 /**
  * coveredMapNode — the #86 part 2 covered map shape (nestedBatchGet). A BATCHED `map` node whose:
@@ -196,7 +816,7 @@ function isNativeRaw(comp, plan) {
  * element struct by copying the over element's typed fields + materializing the into field from the
  * aligned batch raw — NO boxed Value on any plane.
  */
-function coveredMapNode(n, bodyIds, comp, plan, typedNodes) {
+function coveredMapNode(n, bodyIds, comp) {
     if (n === null || typeof n !== "object" || !("map" in n))
         return false;
     const m = n.map;
@@ -213,7 +833,7 @@ function coveredMapNode(n, bodyIds, comp, plan, typedNodes) {
     // A map node must carry an outType (its ELEMENT type per the recorder SoT — authoring.ts recordMap
     // holds `node.outType = mapElem`, the PRE-array-wrap element; the emitter synthesizes the produced
     // `[]element`). A map WITHOUT outType is uncovered. Legacy hand-built IR that already carries the
-    // `{arr:element}` produced form is ALSO accepted — mapNodeArrRef normalizes both to the array ref.
+    // The map node's outType is the ELEMENT type; mapNodeArrRef wraps it to the produced array ref.
     const outT = n.outType;
     if (outT === undefined || typeof outT !== "object")
         return false;
@@ -233,22 +853,14 @@ function coveredMapNode(n, bodyIds, comp, plan, typedNodes) {
             return false;
     }
     const ports = m.ports;
+    const plan = planForComp(comp);
+    const typedNodes = buildTypedNodes(comp, plan);
     const asBinding = mapAsBinding(comp, n, typedNodes, plan);
     for (const p of Object.keys(ports))
         if (!portIsStatic(ports[p], comp, plan, typedNodes, asBinding))
             return false;
     return true;
 }
-/** the `$as` element binding for a covered map/fanout node's element ports (name + over-element TypeRef),
- * or undefined when the over element type does not resolve (the node is then uncovered upstream). */
-function mapAsBinding(comp, node, typedNodes, plan) {
-    try {
-        return { name: node.map.as, ref: mapOverElemInfo(comp, node, typedNodes, plan).elemRef, plan };
-    }
-    catch {
-        return undefined;
-    }
-}
 /**
  * coveredFanoutNode (v3) — a FANOUT node (first-class `@refs` id-list fan-out) is covered when:
  *   - over is a static ref to a PRIOR BODY NODE's typed arr field OR an INPUT array port with elemType,
@@ -257,7 +869,7 @@ function mapAsBinding(comp, node, typedNodes, plan) {
  * The fanout de-boxes to: one deduped batched dispatch → first-seen dedupe (by the elem's dedupeKey
  * field) + dangling drop + implicitSource strip + connection wrap {items, cursor:nil} — NO boxed Value.
  */
-function coveredFanoutNode(n, bodyIds, comp, plan, typedNodes) {
+function coveredFanoutNode(n, bodyIds, comp) {
     if (n === null || typeof n !== "object" || !("fanout" in n))
         return false;
     const f = n.fanout;
@@ -277,6 +889,8 @@ function coveredFanoutNode(n, bodyIds, comp, plan, typedNodes) {
             return false;
     }
     const ports = f.ports;
+    const plan = planForComp(comp);
+    const typedNodes = buildTypedNodes(comp, plan);
     let asBinding;
     try {
         asBinding = { name: f.as, ref: fanoutOverElemInfo(comp, n, typedNodes, plan).elemRef, plan };
@@ -294,8 +908,8 @@ function coveredFanoutNode(n, bodyIds, comp, plan, typedNodes) {
  * reads. A real-concurrency plan whose parallel members include a map / bindField-relation child is
  * NOT covered here (falls through) — the static-parallel orchestration covers the componentRef fan-out
  * (the GroupAccessRead shape); a parallel map/relation-child stage is a further shape (out of scope). */
-function isSequentialComponentRefRead(comp, plan) {
-    return coverageRejectReason(comp, plan) === null;
+function isSequentialComponentRefRead(comp) {
+    return coverageRejectReason(comp) === null;
 }
 /**
  * coverageRejectReason — the DIAGNOSTIC twin of isSequentialComponentRefRead (bc#86/#89). Returns
@@ -305,11 +919,12 @@ function isSequentialComponentRefRead(comp, plan) {
  * never disagree. This is the message the fail-closed dispatch surfaces per non-native component — the
  * user's signal to add native coverage, fix a genuinely-dynamic spec, or use the --ir dynamic surface.
  */
-function coverageRejectReason(comp, plan) {
+function coverageRejectReason(comp) {
+    const crPlan = planForComp(comp);
+    const crTypedNodes = buildTypedNodes(comp, crPlan);
     const ep = execPlan(comp);
     if (ep === null)
         return "component is not a straight-line/staged sequential exec plan (no static exec plan)";
-    const typedNodes = buildTypedNodes(comp, plan);
     // A parallel-stage member must be a componentRef node (no map) so the static parallel orchestration
     // is a clean fan-out — the bounded-concurrency error-precedence protocol is proven for that shape.
     // A map child inside a parallel stage still falls through (its per-element loop is a further shape).
@@ -354,7 +969,7 @@ function coverageRejectReason(comp, plan) {
         if ("fanout" in n) {
             // v3: a first-class fanout node (deduped connection list-in fan-out) IS covered when its over is a
             // covered ref (prior-node arr / input array with elemType) and its element ports are static.
-            if (!coveredFanoutNode(n, bodyIds, comp, plan, typedNodes))
+            if (!coveredFanoutNode(n, bodyIds, comp))
                 return `node '${n.id}' is a non-covered fanout shape (over an input array without elemType, or a dynamic element port)`;
             continue;
         }
@@ -362,7 +977,7 @@ function coverageRejectReason(comp, plan) {
             // #86 pt2 batched map...into / #93 shape 2/3 / #108 guarded map (no into) / map-over-input (with
             // elemType) ARE covered. A non-covered map shape (guard+into heterogeneous / over-input without
             // elemType) falls through to the loud fail-closed reject.
-            if (!coveredMapNode(n, bodyIds, comp, plan, typedNodes))
+            if (!coveredMapNode(n, bodyIds, comp))
                 return `node '${n.id}' is a non-covered map shape (guard+into heterogeneous, or over an input array without elemType)`;
             continue;
         }
@@ -393,7 +1008,7 @@ function coverageRejectReason(comp, plan) {
         if (cr.relationKind !== undefined && cr.relationKind !== "single" && cr.relationKind !== "connection")
             return `relationKind '${cr.relationKind}' not native-covered (node '${n.id}')`;
         for (const p of Object.keys(cr.ports))
-            if (portIsStatic(cr.ports[p], comp, plan, typedNodes) === false)
+            if (portIsStatic(cr.ports[p], comp, crPlan, crTypedNodes) === false)
                 return `node '${n.id}' port '${p}' is not statically resolvable`;
     }
     if (!outputIsNativeLowerable(comp))
@@ -401,20 +1016,25 @@ function coverageRejectReason(comp, plan) {
     return null;
 }
 /** Fail closed if a covered read SHAPE lacks the typed annotations (no silent boxed re-box). */
-function assertTypedCoverage(comp, plan) {
-    if (!isSequentialComponentRefRead(comp, plan))
+function assertTypedCoverage(comp) {
+    if (!isSequentialComponentRefRead(comp))
         return;
     if (isFullyTyped(comp))
         return;
     throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go combined read (bc#77): component '${comp.name}' is a sequential componentRef read but lacks outType/outputType on every node — the combined emitter de-boxes the RESULT into the node's outType struct, so a covered read MUST be fully typed (bc#45). Add outType annotations, or regenerate on go-straightline-native (boxed result).`);
 }
 // ── native ports struct + PortReader ──────────────────────────────────────────────────
-function emitPortsStruct(comp, node, plan, typedNodes, asBinding) {
+function emitPortsStruct(comp, node, asBinding, plan, typedNodes) {
     const structName = portsStructName(comp.name, node.id);
     const portNames = Object.keys(node.ports);
     if (portNames.length === 0) {
         return `// ${structName} — native ports for node '${node.id}' (${node.component}); no ports.\ntype ${structName} struct{}`;
     }
+    // a node WITH ports always resolves through the one port lowering, which needs the type plan + the
+    // prior-node map (both are supplied by every caller — narrow the optional params for the fields below).
+    if (plan === undefined || typedNodes === undefined) {
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go typed-native: ports struct for node '${node.id}' needs a type plan + prior-node map`);
+    }
     const fieldTypes = portNames.map((p) => portFieldGoType(node.ports[p], comp, plan, typedNodes, `port '${p}' of node '${node.id}'`, asBinding !== undefined ? { asBinding, asBase: asBinding.name } : undefined));
     const fieldNames = portNames.map(goPortFieldName);
     const fields = portNames
@@ -434,7 +1054,7 @@ ${fields}
 //
 // 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) plus a per-node error signal (IsError/Err). The
+// 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
@@ -442,7 +1062,7 @@ ${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 + {IsError, Err}. The copier is then a
+// `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.) */
@@ -474,7 +1094,7 @@ function nodeMethodName(compName, nodeId) {
  * 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
- * the per-node error signal (IsError/Err) so the runner interprets policy without a boxed outcome.
+ * A row models a SUCCESS; failure is the second (error) return, so no in-band error signal.
  */
 function emitRawRowStructs(comp, typedNodes, plan) {
     const parts = [];
@@ -489,7 +1109,7 @@ function emitRawRowStructs(comp, typedNodes, plan) {
             const elemRowRef = fanoutItemsElemRef(n, ref, plan);
             parts.push(emitOneRowStruct(rawElemStructName(comp.name, n.id), elemRowRef, plan));
             parts.push(`// ${rawRowStructName(comp.name, n.id)} — the BATCH row for fanout '${n.id}': the aligned per-body rows.\n` +
-                `type ${rawRowStructName(comp.name, n.id)} struct {\n\tIsError bool\n\tErr     string\n\tRows    []${rawElemStructName(comp.name, n.id)}\n}`);
+                `type ${rawRowStructName(comp.name, n.id)} struct {\n\tRows []${rawElemStructName(comp.name, n.id)}\n}`);
             continue;
         }
         if ("map" in n) {
@@ -502,7 +1122,7 @@ function emitRawRowStructs(comp, typedNodes, plan) {
             const elemRowRef = mapElemRowRef(n, arrRef, plan);
             parts.push(emitOneRowStruct(rawElemStructName(comp.name, n.id), elemRowRef, plan));
             parts.push(`// ${rawRowStructName(comp.name, n.id)} — the BATCH row for map '${n.id}': the aligned per-element rows.\n` +
-                `type ${rawRowStructName(comp.name, n.id)} struct {\n\tIsError bool\n\tErr     string\n\tRows    []${rawElemStructName(comp.name, n.id)}\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));
@@ -510,13 +1130,11 @@ function emitRawRowStructs(comp, typedNodes, plan) {
     return parts.join("\n\n");
 }
 /** Emit one concrete row struct: flatten a named outType to typed fields, else a single Val payload;
- * always carry IsError/Err. */
+ * 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; + error signal).`);
+    lines.push(`// ${name} — CONCRETE handler-result row (typed fields = the node's outType).`);
     lines.push(`type ${name} struct {`);
-    lines.push(`\tIsError bool`);
-    lines.push(`\tErr     string`);
     if (ref.kind === "named") {
         const decl = findDecl(plan, ref.name);
         for (const f of decl.fields) {
@@ -591,21 +1209,32 @@ function emitHandlerInterface(comp, typedNodes, plan) {
         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 batch row (per-body rows) + resolved. The runner applies dedupe/drop/wrap after.
+            // 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 retT = rawRowStructName(comp.name, n.id);
-            lines.push(`\t${method}(ports ${portsT}, bound ${bt}) (${retT}, bool)`);
+            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);
-            const retT = batched ? rawRowStructName(comp.name, n.id) : rawElemStructName(comp.name, n.id);
-            lines.push(`\t${method}(ports ${portsT}, bound ${bt}) (${retT}, bool)`);
+            // 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;
         }
-        lines.push(`\t${method}(ports ${portsStructName(comp.name, n.id)}, bound ${bt}) (${rawRowStructName(comp.name, n.id)}, bool)`);
+        // 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");
@@ -629,7 +1258,7 @@ function emitMapPortsStructs(comp, node, typedNodes, plan) {
     // struct element). A pure-static/concat port ignores the binding.
     const { elemRef } = mapOverElemInfo(comp, node, typedNodes, plan);
     const asBinding = { name: m.as, ref: elemRef, plan };
-    const elemStruct = emitPortsStruct(comp, { id: node.id, component: m.component, ports: m.ports }, plan, typedNodes, asBinding);
+    const elemStruct = emitPortsStruct(comp, { id: node.id, component: m.component, ports: m.ports }, asBinding, plan, typedNodes);
     const batchStruct = `${structName}_batch`;
     return `${elemStruct}
 
@@ -647,7 +1276,7 @@ function emitFanoutPortsStructs(comp, node, typedNodes, plan) {
     const structName = portsStructName(comp.name, node.id);
     const { elemRef } = fanoutOverElemInfo(comp, node, typedNodes, plan);
     const asBinding = { name: f.as, ref: elemRef, plan };
-    const elemStruct = emitPortsStruct(comp, { id: node.id, component: f.component, ports: f.ports }, plan, typedNodes, asBinding);
+    const elemStruct = emitPortsStruct(comp, { id: node.id, component: f.component, ports: f.ports }, asBinding, plan, typedNodes);
     const batchStruct = `${structName}_batch`;
     return `${elemStruct}
 
@@ -693,18 +1322,16 @@ function fanoutOverElemInfo(comp, node, typedNodes, plan) {
     }
     throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go fanout (v3): fanout '${node.id}' 'over' must be a ref to a prior node's typed arr field OR an input array port with a declared elemType (got ${JSON.stringify(f.over)}).`);
 }
-/** mapNodeArrRef — the map node's PRODUCED-ARRAY TypeRef from its `outType`, normalizing the two IR
- * conventions to the one array shape every downstream site assumes (`typedNodes.get(mapId)` is an arr):
- *   - the RECORDER SoT (authoring.ts recordMap): `node.outType` is the ELEMENT (pre-array-wrap) — wrap
- *     to `{arr:element}` (the map produces `[]element`), matching type-gate's outputType wrap
- *     (`"map" in n ? {arr:ot} : ot`). This is the declarative-authoring form (graphddb batchWrite/forEach).
- *   - legacy hand-built IR: `node.outType` already the `{arr:element}` produced form — take it as-is.
- * A map ELEMENT is never itself an `{arr:…}` in the covered corpus, so the discriminator is unambiguous.
- * Both converge to the SAME produced-array ref, so existing goldens stay byte-identical. */
+/** mapNodeArrRef — the map node's PRODUCED-ARRAY TypeRef from its `outType`.
+ *
+ * A map node's `outType` is its ELEMENT type (scp-error.md "Map element type"), so the produced array
+ * is `{arr: element}`. This is the same reading the compiler applies when it resolves what a node
+ * result reference has (`type-gate`: `"map" in n ? {arr:ot} : ot`) — the emitter follows that SSoT
+ * rather than inspecting the annotation's shape, so an element that is ITSELF an `arr` stays
+ * expressible (element `arr(T)` produces `arr(arr(T))`). */
 function mapNodeArrRef(node, plan) {
     const outT = node.outType;
-    const isArr = outT !== null && typeof outT === "object" && "arr" in outT;
-    return deriveTypeRef((isArr ? outT : { arr: outT }), plan);
+    return deriveTypeRef({ arr: outT }, plan);
 }
 /** mapElemRowRef — the handler's per-element RETURN shape for a covered map node: the `into` field's
  * type (into) or the element outType directly (no-into). This is the type of RawElem_<comp>_<node>. */
@@ -847,31 +1474,17 @@ function reconstructG(e) {
 function inStructName(compName) {
     return `In_${sanitize(compName)}`;
 }
-/**
- * inputPortGoType — the native Go type for an input port's declared type. Scalars lower to the concrete
- * scalar; `array`/`map` with a declared elemType to `[]ElemT` / `map[string]ElemT`; an OPTIONAL port
- * (`{opt:T}` → `required:false`) to `*T` — the native representation of "the value is absent" (nil).
- * A declared type with no native lowering stays the boxed Value.
- *
- * An OPTIONAL port whose inner type has no native lowering FAILS CLOSED: a boxed `Value` cannot carry
- * the presence distinction on the covered plane, and emitting the bare inner type would silently turn
- * "absent" into a zero value. A port whose optionality cannot be represented is never silently coerced.
- */
+/** Go type for an input port's declared type (scalar → concrete; array+elemType → []ElemT; else Value). */
 function inputPortGoType(schema, plan, where = "input port") {
     const ref = inputPortTypeRef(schema, plan);
     if (ref !== undefined)
         return renderTypeRef(ref);
     if (inputPortIsOptional(schema))
-        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go typed-native (runtime-free): ${where} is OPTIONAL (declared {opt:…}) but its inner type ${JSON.stringify(schema?.type)} has no native Go lowering, so "absent" has no native representation (a boxed Value would be an escape, and the bare inner type would silently read absent as a zero value). Declare an elemType for an array/map, or use a natively-lowerable scalar.`);
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go typed-native (runtime-free): ${where} is OPTIONAL (declared {opt:…}) but its inner type ${JSON.stringify(schema?.type)} has no native Go lowering, so "absent" has no native representation. Declare an elemType for an array/map, or use a natively-lowerable scalar.`);
     return `${PKG}.Value`;
 }
-/** The scalar kind a REQUIRED input port declares, or undefined when it is not a required native scalar.
- * An OPTIONAL port is deliberately NOT a scalar kind here: its native type is `*T`, and the callers of
- * this function build REQUIRED scalar slots (`in.<Field>` read straight into a non-opt port field).
- * Answering "int64" for an `{opt:"int"}` port is exactly how "absent" would silently become `0`. */
+/** The scalar kind an input port declares, or undefined if it is not a native scalar. */
 function inputScalarKind(schema) {
-    if (inputPortIsOptional(schema))
-        return undefined;
     switch (schema?.type) {
         case "string":
         case "literal": // a `"literal"` union is a constrained string (see inputPortGoType).
@@ -896,6 +1509,8 @@ function emitInStruct(comp, plan) {
         return `// ${name} — the CONCRETE input for '${comp.name}' (no input ports).\ntype ${name} struct{}`;
     }
     const names = ports.map((p) => goFieldName(p));
+    // #139: inputPortGoType reads the inputPortTypeRef SSoT — an OPTIONAL port is `*T` (absent → nil); an
+    // optional whose inner type has no native lowering FAILS CLOSED (never a boxed Value escape).
     const types = ports.map((p) => inputPortGoType(comp.inputPorts[p], plan, `input port '${p}' of component '${comp.name}'`));
     const nameW = Math.max(0, ...names.map((n) => n.length));
     const typeW = Math.max(0, ...types.map((t) => t.length));
@@ -937,15 +1552,6 @@ function emitInDecoder(comp, plan) {
         const scalar = inputScalarKind(schema);
         const et = schema.elemType;
         lines.push(`\tif v, ok := input.Get(${JSON.stringify(p)}); ok {`);
-        if (inputPortIsOptional(schema)) {
-            // An OPTIONAL port decodes into its native *T. materializeExpr's opt de-box IS the wire rule:
-            // a nil Value (null) → nil (absent), any other value → a pointer to the materialized inner. A key
-            // that never appears leaves the struct's zero value (nil) — the same absent value. Checked FIRST:
-            // optionality wraps every inner type (an optional array is *[]T, not []T).
-            lines.push(`\t\tin.${field} = ${goTypedInternals.materializeExpr("v", inputPortTypeRef(schema, plan), plan)}`);
-            lines.push(`\t}`);
-            continue;
-        }
         if ((schema?.type === "array" || schema?.type === "arr") && et !== undefined) {
             // #108: decode the boxed Value array into the native []ElemT (test glue — materialize each element
             // via the typed materializer; a non-array or non-conforming element is a fail-closed decode error).
@@ -976,11 +1582,9 @@ function emitInDecoder(comp, plan) {
             lines.push(`\t\tin.${field} = v`);
         }
         else {
-            lines.push(`\t\tt, tok := v.(${scalar})`);
-            lines.push(`\t\tif !tok {`);
-            lines.push(`\t\t\treturn in, ${PKG}.NewExprFailure("TYPE_MISMATCH", "input ${p}: expected ${scalar}, got "+${PKG}.TypeName(v))`);
-            lines.push(`\t\t}`);
-            lines.push(`\t\tin.${field} = t`);
+            // #139: materialize via the inputPortTypeRef SSoT so an OPTIONAL scalar reads as *T (present → &v);
+            // an absent optional never enters this block (Get !ok), leaving the field nil (not a required zero).
+            lines.push(`\t\tin.${field} = ${goTypedInternals.materializeExpr("v", inputPortTypeRef(schema, plan), plan)}`);
         }
         lines.push(`\t}`);
     }
@@ -988,17 +1592,25 @@ function emitInDecoder(comp, plan) {
     lines.push(`}`);
     return lines.join("\n");
 }
+/** A ref resolver for native lowering: given a ref head + remaining field path, return a native scalar
+ * Go expression (typed input field / prior-node typed struct scalar / element binding field), or null
+ * when the ref does not resolve to a REQUIRED (non-opt) native scalar (then the caller falls back to
+ * the nvVE Value path — which keeps the runtime null/opt/TYPE_MISMATCH semantics). */
 /**
- * emitPortInit — the port field initializer, read off the ONE port lowering (compilePortNode / native-
- * expr). The field's declared TYPE (portFieldGoType) is the SAME lowering's TypeRef, so type and value
- * can never disagree. `isPrior` tests whether a ref head names a settled prior node at this position;
- * `opts.asBinding`/`opts.asBase` carry a map/fanout element binding. A FALLIBLE lowering (hoisted
- * statements) is rejected HERE — a ports-struct literal cannot host statements.
+ * emitPortInit — emit the port field build for one port as a FULLY NATIVE Go expression (bc#90 /
+ * runtime-free). Every covered port lowers to a concrete Go value assigned straight into the ports
+ * struct field — NO `dslcontracts.Value`, NO nvVE helper, NO `.(T)` type-assert:
+ *   - a static string array (projection) → `[]string{"a", "b", ...}` (change #2);
+ *   - a bare int/float number literal (e.g. Query `limit: 20`) → `int64(20)` / `float64(...)`;
+ *   - a string/bool/scalar-input port → the native scalar expression (emitNativeScalar).
+ * A port that CANNOT lower natively FAILS CLOSED (there is no boxed Value fallback on the covered
+ * plane — a boxed escape would re-introduce the bc-runtime coupling this module removes). Returns the
+ * struct field initializer (`Field: <expr>`). `resolveRef` resolves a ref head for the scalar path.
  */
 function emitPortInit(pn, expr, comp, plan, typedNodes, isPrior, opts) {
     const c = compilePortNode(expr, comp, plan, typedNodes, isPrior, `port '${pn}'`, opts);
     if (c.stmts.length > 0)
-        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go typed-native (runtime-free): port '${pn}' ${JSON.stringify(expr)} lowers to a FALLIBLE expression (one that can raise INT_OVERFLOW / NAN_OR_INF / MOD_ZERO / PRECISION_LOSS). Such an expression lowers to STATEMENTS carrying an early error-return, and a port is built inline in the ports-struct literal — a position that cannot host them. (A cond/guard position CAN host them, so the same expression is covered there — the boundary is the POSITION, not the operator.) Use a non-fallible port expression.`);
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go typed-native (runtime-free): port '${pn}' ${JSON.stringify(expr)} lowers to a FALLIBLE expression (one that can raise INT_OVERFLOW / NAN_OR_INF / MOD_ZERO / PRECISION_LOSS). Such an expression lowers to STATEMENTS carrying an early error-return, and a port is built inline in the ports-struct literal — a position that cannot host them. Use a non-fallible port expression.`);
     return `${goPortFieldName(pn)}: ${c.expr}`;
 }
 /**
@@ -1059,9 +1671,17 @@ 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 rowT = rawRowStructName(comp.name, comp.body[i].id);
-        lines.push(`\t\tvar row_${s} ${rowT}`);
-        lines.push(`\t\tvar row_${s}Resolved bool`);
+        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)}`);
+        }
+        lines.push(`\t\tvar row_${s}Err error`);
         lines.push(`\t\trun_${s} := false`);
         lines.push(`\t\tvar ps_${s} ${structName}`);
         lines.push(`\t\t_ = ps_${s}`);
@@ -1133,7 +1753,8 @@ 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";
-        lines.push(`\t\t\t\trow_${s}, row_${s}Resolved = handlers.${nodeMethodName(comp.name, node.id)}(ps_${s}, ${boundArg})`);
+        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}()`);
         lines.push(`\t\t}`);
     }
@@ -1145,20 +1766,53 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
         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} {`);
-        lines.push(`\t\t\tif !${oc}Resolved {`, `\t\t\t\treturn ${zeroOut}, ${goErr("UNKNOWN_COMPONENT", `"component '${node.component}' has no handler (fail-closed)"`)}`, `\t\t\t}`);
         if (meta.policy === "continue") {
-            lines.push(`\t\t\tif !${oc}.IsError {`);
-            lines.push(emitRowCopy(typedLocal(node.id), oc, ref, plan, 4));
-            lines.push(`\t\t\t\tproduced_${s} = true`);
+            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`);
+            }
             lines.push(`\t\t\t}`);
         }
         else {
-            const policy = meta.policy === "retry" ? "retry' policy (exhausted)" : "fail' policy";
-            lines.push(`\t\t\tif ${oc}.IsError {`);
-            lines.push(`\t\t\t\treturn ${zeroOut}, ${goErr("OP_FAILED", `"operation '${node.id}' failed under '${policy}: "+${oc}.Err`)}`);
+            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\t}`);
-            lines.push(emitRowCopy(typedLocal(node.id), oc, ref, plan, 3));
+            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(`\t\t\tproduced_${s} = true`);
         }
         lines.push(`\t\t}`);
@@ -1318,22 +1972,75 @@ function emitNativeRawRunner(comp, plan, flags) {
         }
         lines.push(`${indent}ports_${s} := ${structName}{${inits.join(", ")}}`);
         const oc = `row_${s}`;
-        lines.push(`${indent}${oc}, ${oc}Resolved := handlers.${nodeMethodName(comp.name, node.id)}(ports_${s}, ${boundArg})`);
-        lines.push(`${indent}if !${oc}Resolved {`, `${indent}\treturn ${zeroOut}, ${goErr("UNKNOWN_COMPONENT", `"component '${node.component}' has no handler (fail-closed)"`)}`, `${indent}}`);
         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;
         if (meta.policy === "continue") {
-            lines.push(`${indent}if !${oc}.IsError {`);
-            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. 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}}`);
+            }
         }
         else {
-            const policy = meta.policy === "retry" ? "retry' policy (exhausted)" : "fail' policy";
-            lines.push(`${indent}if ${oc}.IsError {`);
-            lines.push(`${indent}\treturn ${zeroOut}, ${goErr("OP_FAILED", `"operation '${node.id}' failed under '${policy}: "+${oc}.Err`)}`);
-            lines.push(`${indent}}`);
-            lines.push(copy(indent));
-            lines.push(`${indent}produced_${s} = true`);
+            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`);
+            }
         }
         for (const c of closers)
             lines.push(c);
@@ -1408,7 +2115,8 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, f
         if (!hasGuard)
             return null;
         const resolveHead = goNativeResolveHead(comp, plan, typedNodes, priorHere, { asBinding: { name: asName, ref: overElemRef, plan }, asBase: elemVar });
-        return new NativeExprCompiler(makeGoExprBackend(zeroOut, resolveHead, plan)).compileBool(m.when);
+        const be = makeGoExprBackend(zeroOut, resolveHead, plan);
+        return new NativeExprCompiler(be).compileBool(m.when);
     };
     // emit the per-element native ports struct build (shared; `il` is the indent inside the element
     // loop, `elemVar` the over element loop variable). Returns the lines building `ep_<s>`.
@@ -1431,6 +2139,12 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, f
     lines.push(`${indent}over_${s} := ${overExpr}`);
     lines.push(`${indent}${typedLocal(node.id)} = make(${elemGo}, 0, len(over_${s}))`);
     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) : "";
     // 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) => {
@@ -1447,7 +2161,7 @@ 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{IsError,Err,Rows []RawElem} aligned to items.
+        // dispatch ONCE. The concrete Node_* returns RawRow{Rows []RawElem} aligned to items (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.
         lines.push(`${indent}items_${s} := make([]${structName}, 0, len(over_${s}))`);
@@ -1465,22 +2179,39 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, f
         // empty items => empty result (handler not called), matching run_behavior.
         lines.push(`${indent}if len(items_${s}) > 0 {`);
         lines.push(`${indent}\tbp_${s} := ${batchStruct}{Items: items_${s}}`);
-        lines.push(`${indent}\tmo_${s}, mo_${s}Resolved := handlers.${nodeMethodName(comp.name, node.id)}(bp_${s}, nil)`);
-        lines.push(`${indent}\tif !mo_${s}Resolved {`, `${indent}\t\treturn ${zeroOut}, ${goErr("UNKNOWN_COMPONENT", `"component '${m.component}' has no handler (fail-closed)"`)}`, `${indent}\t}`);
-        lines.push(`${indent}\tif mo_${s}.IsError {`, `${indent}\t\treturn ${zeroOut}, ${goErr("OP_FAILED", `"operation '${node.id}' failed under 'fail' policy: "+mo_${s}.Err`)}`, `${indent}\t}`);
-        lines.push(`${indent}\tif len(mo_${s}.Rows) != 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}\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}`);
         if (hasInto) {
             // #86 pt2: zip-attach the into field onto each kept over element (augmented element copier).
             lines.push(`${indent}\tfor mk_${s} := range keptOver_${s} {`);
-            lines.push(`${indent}\t\tel_${s} := ${elemMat}(keptOver_${s}[mk_${s}], mo_${s}.Rows[mk_${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\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} := range mo_${s}.Rows {`);
+            lines.push(`${indent}\tfor mk_${s} := 0; mk_${s} < ${batchLen}; mk_${s}++ {`);
             lines.push(`${indent}\t\tvar el_${s} ${renderTypeRef(arrRef.elem)}`);
-            lines.push(emitRowCopy(`el_${s}`, `mo_${s}.Rows[mk_${s}]`, elemRowRef, plan, indent.length + 2));
+            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(`${indent}\t\t${typedLocal(node.id)} = append(${typedLocal(node.id)}, el_${s})`);
             lines.push(`${indent}\t}`);
         }
@@ -1499,15 +2230,30 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, f
         // per-element dispatch (ONE physical request per element). run_behavior passes the over element
         // as the bound value; the element data is fully conveyed by the native ports struct here, so bound
         // stays nil. Byte-equivalence holds because the bound value only feeds handler-internal logic.
-        lines.push(`${indent}\tmo_${s}, mo_${s}Resolved := handlers.${nodeMethodName(comp.name, node.id)}(ep_${s}, nil)`);
-        lines.push(`${indent}\tif !mo_${s}Resolved {`, `${indent}\t\treturn ${zeroOut}, ${goErr("UNKNOWN_COMPONENT", `"component '${m.component}' has no handler (fail-closed)"`)}`, `${indent}\t}`);
-        lines.push(`${indent}\tif mo_${s}.IsError {`, `${indent}\t\treturn ${zeroOut}, ${goErr("OP_FAILED", `"operation '${node.id}' failed under 'fail' policy: "+mo_${s}.Err`)}`, `${indent}\t}`);
+        // Element Error Policy (scp-error.md): `skip` drops the failing element and proceeds (order is
+        // preserved; the leaf keeps the Error Value it produced). `error` (default) promotes the element
+        // Failure to the map's Component Failure, carrying the leaf's detail through.
+        lines.push(`${indent}\tmo_${s}, mo_${s}Err := handlers.${nodeMethodName(comp.name, node.id)}(ep_${s}, nil)`);
+        if (m.elementPolicy === "skip") {
+            lines.push(`${indent}\tif mo_${s}Err != nil {`, `${indent}\t\tcontinue`, `${indent}\t}`);
+        }
+        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
+        // 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)}, mo_${s})`);
+            lines.push(`${indent}\tel_${s} := ${elemMat}(${elemLocal(s)}, ${elemVar})`);
         }
         else {
             lines.push(`${indent}\tvar el_${s} ${renderTypeRef(arrRef.elem)}`);
-            lines.push(emitRowCopy(`el_${s}`, `mo_${s}`, elemRowRef, plan, indent.length + 1));
+            lines.push(emitRowCopy(`el_${s}`, elemVar, elemRowRef, plan, indent.length + 1));
         }
         lines.push(`${indent}\t${typedLocal(node.id)} = append(${typedLocal(node.id)}, el_${s})`);
         lines.push(`${indent}}`);
@@ -1578,19 +2324,25 @@ 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}}`);
-    lines.push(`${indent}\tfo_${s}, fo_${s}Resolved := handlers.${nodeMethodName(comp.name, node.id)}(bp_${s}, nil)`);
-    lines.push(`${indent}\tif !fo_${s}Resolved {`, `${indent}\t\treturn ${zeroOut}, ${goErr("UNKNOWN_COMPONENT", `"component '${f.component}' has no handler (fail-closed)"`)}`, `${indent}\t}`);
-    lines.push(`${indent}\tif fo_${s}.IsError {`, `${indent}\t\treturn ${zeroOut}, ${goErr("OP_FAILED", `"operation '${node.id}' failed under 'fail' policy: "+fo_${s}.Err`)}`, `${indent}\t}`);
-    lines.push(`${indent}\tif len(fo_${s}.Rows) != 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}`);
+    // 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);
+    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}`);
     // ── THE ONE dedupe/drop (mirrors fanoutDedupDrop verbatim): first-seen dedupe by dedupeKey field;
     //    drop dangling (zero dedupeKey ≡ interpreter's null/absent-key body); implicitSource strip is
     //    structural (the elem type already omits it). cursor is always nil (connection wrap).
-    lines.push(`${indent}\tseen_${s} := make(map[string]struct{}, len(fo_${s}.Rows))`);
-    lines.push(`${indent}\titems_${s} = make([]${elemGo}, 0, len(fo_${s}.Rows))`);
-    lines.push(`${indent}\tfor fi_${s} := range fo_${s}.Rows {`);
-    lines.push(`${indent}\t\tbody_${s} := fo_${s}.Rows[fi_${s}]`);
+    lines.push(`${indent}\tseen_${s} := make(map[string]struct{}, len(fo_${s}))`);
+    lines.push(`${indent}\titems_${s} = make([]${elemGo}, 0, len(fo_${s}))`);
+    lines.push(`${indent}\tfor fi_${s} := range fo_${s} {`);
     lines.push(`${indent}\t\tvar el_${s} ${elemGo}`);
-    lines.push(emitRowCopy(`el_${s}`, `body_${s}`, elemRef, plan, indent.length + 2));
+    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(`${indent}\t\t}`);
     lines.push(`${indent}\t\tkey_${s} := el_${s}.${dkGo}`);
     if (f.drop === "dangling") {
         // dangling: a body whose dedupeKey is the zero value (empty string) is dropped.
@@ -1609,15 +2361,12 @@ function emitFanoutArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut
         lines.push(c);
     return lines.join("\n");
 }
-/**
- * goInputHeadRef (#108) — resolve an INPUT port head for a native-expr ref (cond `if` / map `when` /
- * branches / an opt-lane port). The port's declared type comes from the shared `inputPortTypeRef` SSoT,
- * so an OPTIONAL port resolves as `{opt:…}` (native `*T`) and the compiler can see its optionality: a
- * null-compare becomes a real presence test and a coalesce a real deref-or-default, while a
- * REQUIRED-scalar slot fed by an opt fails closed. Go values are read directly off the input struct (no
- * ownership ceremony); a type with no native lowering → null (fail-closed).
- */
+/** #108: resolve an INPUT port head for a native-expr ref (cond `if` / map `when` / branches). A scalar
+ * port → `in.<Field>` of the scalar type; an array port WITH elemType → `in.<Field>` of `[]ElemT` (so
+ * `len(in.<Field>)` works); anything else → null (fail-closed). */
 function goInputHeadRef(head, comp, plan) {
+    // #139: the port's declared type comes from the inputPortTypeRef SSoT, so an OPTIONAL port resolves as
+    // {opt:…} (native *T) and the compiler sees its optionality; a type with no native lowering → null.
     const ref = inputPortTypeRef(comp.inputPorts?.[head], plan);
     if (ref === undefined)
         return null;
@@ -1635,7 +2384,11 @@ function emitCondArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut)
     const c = node.cond;
     const s = sanitize(node.id);
     const priorHere = (head) => priorNodeAt(head, atPos);
-    const resolveHead = goNativeResolveHead(comp, plan, typedNodes, priorHere);
+    const resolveHead = (head) => {
+        if (priorHere(head))
+            return { expr: typedLocal(head), ref: typedNodes.get(head) };
+        return goInputHeadRef(head, comp, plan);
+    };
     const be = makeGoExprBackend(zeroOut, resolveHead, plan);
     const compiler = new NativeExprCompiler(be);
     const cond = compiler.compileBool(c.if);
@@ -1866,14 +2619,11 @@ function makeGoExprBackend(zeroOut, resolveHead, plan) {
         // opt (`*T`) null-presence test: present = `(expr != nil)`, absent = `(expr == nil)`.
         optIsSome: (expr) => `(${expr} != nil)`,
         optIsNone: (expr) => `(${expr} == nil)`,
-        // opt (`*T`) defaulted to a PURE default. Go has no `unwrap_or`, so this is the same immediately-
-        // invoked func literal the `ternary` rendering uses (the established shape in this emitter): bind the
-        // pointer ONCE, deref it when present, else yield the default. The default sits in the else branch,
-        // so it is evaluated only when absent — run_behavior's lazy right side exactly.
+        // opt (`*T`) defaulted to a PURE default — an immediately-invoked func literal: bind the pointer ONCE,
+        // deref when present, else yield the default (evaluated only when absent — run_behavior's lazy right).
         optUnwrapOr: (optExpr, defaultExpr, innerTy) => `func() ${innerTy} { if v := ${optExpr}; v != nil { return *v }; return ${defaultExpr} }()`,
-        // opt defaulted to a FALLIBLE default — a statement if/else, NOT a func literal: the default's
-        // hoisted `return zeroOut, err` early returns must leave the ENCLOSING fn, which a func literal
-        // would swallow (it would return from the literal). Only the nil branch evaluates the default.
+        // opt defaulted to a FALLIBLE default — a statement if/else (NOT a func literal): the default's hoisted
+        // `return zeroOut, err` early returns must leave the ENCLOSING fn. Only the nil branch evaluates it.
         optCoalesceGuard: (temp, ty, optExpr, bindTemp, dStmts, dExpr) => [
             `var ${temp} ${ty}`,
             `if ${bindTemp} := ${optExpr}; ${bindTemp} != nil {`,
@@ -2037,13 +2787,15 @@ 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) {
+function emitMinimalHeader(ctx, needStrings, needSync, needFmt, needMath, needStrconv = false) {
     const sv = ctx.specVersions;
     const imports = [];
     if (needFmt)
         imports.push(`\t"fmt"`);
     if (needMath)
         imports.push(`\t"math"`);
+    if (needStrconv)
+        imports.push(`\t"strconv"`);
     if (needStrings)
         imports.push(`\t"strings"`);
     if (needSync)
@@ -2063,14 +2815,12 @@ var ExpectedSpecVersions = map[string]int64{"behavior": ${sv.behavior}, "express
 }
 // ── module assembly ──────────────────────────────────────────────────────────────────
 function emit(ctx) {
-    // The type plan is the SSoT the coverage gate + the port lowering both read (the gate ASKS the port
-    // lowering whether a port lowers), so it is built up-front — before the coverage checks.
-    const plan = buildTypePlan(ctx.ir);
     // Fail closed if a covered read SHAPE lacks the typed annotations (no silent re-box).
     for (const c of ctx.ir.components)
-        assertTypedCoverage(c, plan);
-    const native = ctx.ir.components.filter((c) => isNativeRaw(c, plan));
-    const nonNative = ctx.ir.components.filter((c) => !isNativeRaw(c, plan));
+        assertTypedCoverage(c);
+    const native = ctx.ir.components.filter(isNativeRaw);
+    const nonNative = ctx.ir.components.filter((c) => !isNativeRaw(c));
+    const plan = buildTypePlan(ctx.ir);
     const decls = emitTypeDecls(plan);
     // #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).
@@ -2083,9 +2833,16 @@ function emit(ctx) {
     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();
     for (const c of native) {
         inStructs.push(emitInStruct(c, plan));
-        const typedNodes = buildTypedNodes(c, plan);
+        const typedNodes = new Map();
+        // build the full typed-node map FIRST so a map's over-element resolution can see every node.
+        for (const n of c.body)
+            if (!isControlGate(n))
+                typedNodes.set(n.id, "map" in n ? mapNodeArrRef(n, plan) : deriveTypeRef(n.outType, plan)); // #125: control-gate typeless; map は produced-array ref に正規化
         for (const n of c.body) {
             if ("fanout" in n) {
                 // v3: a fanout node emits a per-id element ports struct + a batch struct (like a batched map).
@@ -2101,12 +2858,16 @@ function emit(ctx) {
             }
             else {
                 // #129: pass typedNodes so a leaf array port fed by a prior node's arr outType types as []ElemT.
-                structs.push(emitPortsStruct(c, n, plan, typedNodes));
+                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).
         const mm = emitMapElemMaterializers(c, typedNodes, plan);
         if (mm)
@@ -2130,7 +2891,7 @@ function emit(ctx) {
     // minimal, runtime-free header.
     if (nonNative.length > 0) {
         const rejects = nonNative
-            .map((c) => `  - component '${c.name}': ${coverageRejectReason(c, plan) ?? "not a covered native read"}`)
+            .map((c) => `  - component '${c.name}': ${coverageRejectReason(c) ?? "not a covered native read"}`)
             .join("\n");
         throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go typed-native (native codegen) surface: ${nonNative.length} component(s) are NOT a covered native read:\n${rejects}\n\n` +
             `The --typed-native (native codegen) surface is native-only and fail-closed: it does not silently ` +
@@ -2140,7 +2901,9 @@ 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;
-    const header = emitMinimalHeader(ctx, false, needSync, needFmt, needMath);
+    // `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);
     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
@@ -2164,6 +2927,12 @@ function emit(ctx) {
             ? `// 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")}`
+            : undefined,
         elemCopiers.length
             ? `// Augmented map-element copiers (over element fields + the concrete into row — pure assignment).\n${elemCopiers.join("\n\n")}`
             : undefined,
@@ -2188,8 +2957,8 @@ function emit(ctx) {
  */
 export function goTypedNativeObserve(ir, runtimeImport) {
     const components = ir.components;
+    const native = components.filter(isNativeRaw);
     const plan = buildTypePlan(ir);
-    const native = components.filter((c) => isNativeRaw(c, plan));
     const serializers = emitSerializers(plan);
     const marshallers = goTypedInternals.emitMarshallers(plan);
     const mustHelpers = emitMustHelpers(plan);
@@ -2209,6 +2978,199 @@ export function goTypedNativeObserve(ir, runtimeImport) {
     // 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.
+    const wireAdapter = anyDeBox
+        ? `// ── scripted wire adapter (TEST glue) ──
+func scriptedWireTag(v ${PKG}.Value) string {
+	switch v.(type) {
+	case nil:
+		return "NULL"
+	case bool:
+		return "BOOL"
+	case int64, float64:
+		return "N"
+	case string:
+		return "S"
+	case []${PKG}.Value:
+		return "L"
+	case *${PKG}.Obj:
+		return "M"
+	default:
+		return "UNKNOWN"
+	}
+}
+
+func scriptedWireRaw(v ${PKG}.Value) string {
+	switch t := v.(type) {
+	case nil:
+		return "null"
+	case bool:
+		if t {
+			return "true"
+		}
+		return "false"
+	case int64:
+		return strconv.FormatInt(t, 10)
+	case float64:
+		s, _ := ${PKG}.PyFloatRepr(t)
+		return s
+	case string:
+		return t
+	default:
+		return ${PKG}.EncodeValue(v)
+	}
+}
+
+func probeStringVal(v ${PKG}.Value) StringProbe {
+	if v == nil {
+		return StringProbe{Kind: probeNull, ActualWireType: "NULL", Raw: "null"}
+	}
+	if s, ok := v.(string); ok {
+		return StringProbe{Kind: probeGot, Got: s, ActualWireType: "S", Raw: s}
+	}
+	return StringProbe{Kind: probeWrong, ActualWireType: scriptedWireTag(v), Raw: scriptedWireRaw(v)}
+}
+
+func probeNumberVal(v ${PKG}.Value) NumberProbe {
+	if v == nil {
+		return NumberProbe{Kind: probeNull, ActualWireType: "NULL", Raw: "null"}
+	}
+	switch v.(type) {
+	case int64, float64:
+		return NumberProbe{Kind: probeGot, Got: scriptedWireRaw(v), ActualWireType: "N", Raw: scriptedWireRaw(v)}
+	}
+	return NumberProbe{Kind: probeWrong, ActualWireType: scriptedWireTag(v), Raw: scriptedWireRaw(v)}
+}
+
+func probeBoolVal(v ${PKG}.Value) BoolProbe {
+	if v == nil {
+		return BoolProbe{Kind: probeNull, ActualWireType: "NULL", Raw: "null"}
+	}
+	if b, ok := v.(bool); ok {
+		return BoolProbe{Kind: probeGot, Got: b, ActualWireType: "BOOL", Raw: scriptedWireRaw(v)}
+	}
+	return BoolProbe{Kind: probeWrong, ActualWireType: scriptedWireTag(v), Raw: scriptedWireRaw(v)}
+}
+
+func probeRowVal(v ${PKG}.Value) RowProbe {
+	if v == nil {
+		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: probeWrong, ActualWireType: scriptedWireTag(v), Raw: scriptedWireRaw(v)}
+}
+
+func probeListVal(v ${PKG}.Value) ListProbe {
+	if v == nil {
+		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: probeWrong, ActualWireType: scriptedWireTag(v), Raw: scriptedWireRaw(v)}
+}
+
+type scriptedWireRow struct {
+	obj *${PKG}.Obj
+}
+
+func newScriptedWireRow(v ${PKG}.Value) WireRow {
+	o, _ := v.(*${PKG}.Obj)
+	return scriptedWireRow{obj: o}
+}
+
+func (w scriptedWireRow) field(name string) (${PKG}.Value, bool) {
+	if w.obj == nil {
+		return nil, false
+	}
+	return w.obj.Get(name)
+}
+
+func (w scriptedWireRow) Keys() []string {
+	if w.obj == nil {
+		return nil
+	}
+	return w.obj.Keys
+}
+
+func (w scriptedWireRow) 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 {
+	if v, ok := w.field(field); ok {
+		return probeNumberVal(v)
+	}
+	return NumberProbe{Kind: probeAbsent}
+}
+
+func (w scriptedWireRow) 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 {
+	if v, ok := w.field(field); ok {
+		return probeRowVal(v)
+	}
+	return RowProbe{Kind: probeAbsent}
+}
+
+func (w scriptedWireRow) ProbeList(field string) ListProbe {
+	if v, ok := w.field(field); ok {
+		return probeListVal(v)
+	}
+	return ListProbe{Kind: probeAbsent}
+}
+
+type scriptedWireList 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]) }
+
+// 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
+// glue — same package as the covered module, so it may read the fields directly).
+func (e *BehaviorError) FailureDetail() (kind, model, field, expectedType, actualWireType, rawValue string, ok bool) {
+	if e.Detail == nil {
+		return "", "", "", "", "", "", false
+	}
+	d := e.Detail
+	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`;
@@ -2234,35 +3196,56 @@ ${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) {
-                // v3: scripted fanout impl — drain one batched outcome and decode the aligned []Value into the
-                // per-body elem rows (a null array element materializes to the zero elem row = dangling).
                 const f = n.fanout;
-                const elemRowRef = fanoutItemsElemRef(n, ref, plan);
+                const elemDeBox = mapFanoutElemDeBoxEligible(n, typedNodes, plan);
                 const elemT = rawElemStructName(c.name, n.id);
                 const batchT = rawRowStructName(c.name, n.id);
-                const elemDecode = emitDecodeRow(c.name, n.id, elemT, elemRowRef, plan, emittedDecode, decodeFns, "Elem");
                 const portsT = `${portsStructName(c.name, n.id)}_batch`;
                 const foBoundT = boundGoType(n, c, typedNodes, plan);
-                methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, n.id)}(_ ${portsT}, _ ${foBoundT}) (${batchT}, bool) {
+                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) {
+	src, ok := s.next(${JSON.stringify(f.component)})
+	if !ok {
+		return nil, unknownComponent(${JSON.stringify(f.component)})
+	}
+	if src.isErr {
+		return nil, leafFailure(src.err)
+	}
+	arr, _ := src.ok.([]${PKG}.Value)
+	wires := make([]WireRow, 0, len(arr))
+	for _, ev := range arr {
+		if ev == nil {
+			wires = append(wires, nil)
+			continue
+		}
+		wires = append(wires, newScriptedWireRow(ev))
+	}
+	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}{}, false
+		return ${batchT}{}, unknownComponent(${JSON.stringify(f.component)})
 	}
 	if src.isErr {
-		return ${batchT}{IsError: true, Err: src.err}, true
+		return ${batchT}{}, leafFailure(src.err)
 	}
 	arr, _ := src.ok.([]${PKG}.Value)
 	rows := make([]${elemT}, 0, len(arr))
 	for _, ev := range arr {
-		// v3: a null aligned body is a DANGLING id — decode it to the zero elem row (empty dedupeKey
-		// field), so the runner's dangling-drop excludes it (byte-equal to fanoutDedupDrop).
 		if ev == nil {
 			rows = append(rows, ${elemT}{})
 			continue
 		}
 		rows = append(rows, ${elemDecode}(ev))
 	}
-	return ${batchT}{Rows: rows}, true
+	return ${batchT}{Rows: rows}, nil
 }`);
                 continue;
             }
@@ -2270,77 +3253,172 @@ ${native.map((c) => `\t${handlerIfaceName(c.name)}`).join("\n")}
                 const m = n.map;
                 const batched = m.batched === true;
                 const arrRef = ref;
-                const elemRowRef = mapElemRowRef(n, arrRef, plan);
+                const elemDeBox = mapFanoutElemDeBoxEligible(n, typedNodes, plan);
                 const elemT = rawElemStructName(c.name, n.id);
                 const batchT = rawRowStructName(c.name, n.id);
-                const elemDecode = emitDecodeRow(c.name, n.id, elemT, elemRowRef, plan, emittedDecode, decodeFns, "Elem");
                 const portsT = batched ? `${portsStructName(c.name, n.id)}_batch` : portsStructName(c.name, n.id);
-                const retT = batched ? batchT : elemT;
                 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) {
+	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)
+	}
+	arr, _ := src.ok.([]${PKG}.Value)
+	wires := make([]WireRow, 0, len(arr))
+	for _, ev := range arr {
+		wires = append(wires, newScriptedWireRow(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}, bool) {
+                    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}{}, false
+		return ${batchT}{}, unknownComponent(${JSON.stringify(m.component)})
 	}
 	if src.isErr {
-		return ${batchT}{IsError: true, Err: src.err}, true
+		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}, true
+	return ${batchT}{Rows: rows}, nil
 }`);
                 }
                 else {
-                    methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, n.id)}(_ ${portsT}, _ ${mapBoundT}) (${elemT}, bool) {
+                    methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, n.id)}(_ ${portsT}, _ ${mapBoundT}) (${elemT}, error) {
 	src, ok := s.next(${JSON.stringify(m.component)})
 	if !ok {
-		return ${elemT}{}, false
+		return ${elemT}{}, unknownComponent(${JSON.stringify(m.component)})
 	}
 	if src.isErr {
-		return ${elemT}{IsError: true, Err: src.err}, true
+		return ${elemT}{}, leafFailure(src.err)
 	}
-	return ${elemDecode}(src.ok), true
+	return ${elemDecode}(src.ok), nil
 }`);
                 }
-                void retT;
                 continue;
             }
             const node = n;
             const rowT = rawRowStructName(c.name, node.id);
-            const decode = emitDecodeRow(c.name, node.id, rowT, ref, plan, emittedDecode, decodeFns, "");
             const nodeBoundT = boundGoType(node, c, typedNodes, plan);
-            // #129 (TEST glue): support the reference scriptedHandlers' echo forms (PROTOCOL.md §3.5) — the
-            // adapter normalizes `{"echo":"port","port":"X"}` / `{"echo":"items"}` to the port NAME, and the
-            // scripted handler
-            // ECHOES a NATIVE port back as its result. This makes a port-plane pin non-vacuous: the node's
-            // observed result IS the native value that flowed into its ports struct, so a dropped / re-boxed /
-            // zero-defaulted port diverges from run_behavior instead of passing. A port is echoable when its
-            // native type IS the node's outType (that is exactly when the row's Val can hold it); `ports` is
-            // named only when at least one port qualifies (else the param stays `_` so a non-echo node
-            // compiles clean / unused-param-free).
-            const echoable = echoablePorts(c, node, ref, plan, typedNodes);
-            const portsParam = echoable.length > 0 ? "ports" : "_";
-            // a NAMED outType row is FLATTENED (no Val) — echo a named port by copying the struct's fields;
-            // a scalar/arr/opt outType row holds the port in its single Val field.
-            const echoRow = (ep) => ref.kind === "named"
-                ? `${rowT}{${findDecl(plan, ref.name).fields.map((f) => `${goFieldName(f.name)}: ports.${goPortFieldName(ep)}.${goFieldName(f.name)}`).join(", ")}}`
-                : `${rowT}{Val: ports.${goPortFieldName(ep)}}`;
-            const echoBranch = echoable
-                .map((ep) => `\tif src.echo == ${JSON.stringify(ep)} {\n\t\treturn ${echoRow(ep)}, true\n\t}\n`)
-                .join("");
-            methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, node.id)}(${portsParam} ${portsStructName(c.name, node.id)}, _ ${nodeBoundT}) (${rowT}, bool) {
+            // 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`;
+                        }
+                    }
+                }
+                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 ${rowT}{}, false
+		return nil, unknownComponent(${JSON.stringify(node.component)})
 	}
 	if src.isErr {
-		return ${rowT}{IsError: true, Err: src.err}, true
+		return nil, leafFailure(src.err)
 	}
-${echoBranch}	return ${decode}(src.ok), true
+${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");
+            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) {
+	src, ok := s.next(${JSON.stringify(node.component)})
+	if !ok {
+		return ${rowT}{}, unknownComponent(${JSON.stringify(node.component)})
+	}
+	if src.isErr {
+		return ${rowT}{}, leafFailure(src.err)
+	}
+${echoBranch}	return ${decode}(src.ok), nil
 }`);
         }
     }
@@ -2383,15 +3461,13 @@ func NewScriptedNativeRaw(spec *${PKG}.JObj) (*ScriptedNativeRaw, error) {
 			for _, e := range entries {
 				eo, _ := e.(*${PKG}.JObj)
 				// #129: an \`echo\` directive names an input port to echo back (mirrors the reference
-				// scriptedHandlers' PROTOCOL.md §3.5 echo forms). It is drained together with the ok
-				// payload. \`{"echo":"port","port":"X"}\` is normalized to the port NAME here, so the
-				// generated node method just compares \`src.echo\` against its echoable port names —
-				// \`{"echo":"items"}\` is already that shape.
+				// scriptedHandlers' \`echo === "items"\`). It is drained together with the ok payload.
 				echo := ""
 				if echoNode, has := eo.Get("echo"); has {
 					echo, _ = echoNode.(string)
+					// normalize echo:port to the port NAME X so a de-box handler's echo comparison fires;
+					// echo:items already names the port directly.
 					if echo == "port" {
-						echo = ""
 						if portNode, hasPort := eo.Get("port"); hasPort {
 							echo, _ = portNode.(string)
 						}
@@ -2441,11 +3517,14 @@ func (s *ScriptedNativeRaw) next(component string) (scriptSrc, bool) {
 package behaviors
 
 import (
-	"sync"
+${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.
+${wireAdapter}
+
 // typed -> Value serializers (TEST glue only — the covered module has none).
 ${serializers}
 
@@ -2479,14 +3558,6 @@ ${arms}
 }
 `;
 }
-/** echoablePorts (TEST glue) — the node's ports whose NATIVE type is exactly the node's outType, in
- * declaration order. Those are the ports a scripted `echo: "<port>"` can return as the row (a scalar/arr/
- * opt row via its Val; a NAMED row via its flattened fields copied from the struct port). A port with a
- * different type is not echoable (the row could not hold it). */
-function echoablePorts(comp, node, ref, plan, typedNodes) {
-    const want = renderTypeRef(ref);
-    return Object.keys(node.ports).filter((p) => portFieldGoType(node.ports[p], comp, plan, typedNodes, `port '${p}'`) === want);
-}
 /** 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