behavior-contracts 0.8.4 → 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,61 +614,43 @@ 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, "_")}`;
 }
-function inferPortType(node, inputPorts, asBinding) {
-    if (staticArrElems(node) !== null)
-        return "Value";
-    const e = classifyExpr(node);
-    switch (e.kind) {
-        case "str":
-        case "concat":
-            return "string";
-        case "bool":
-            return "bool";
-        case "ref": {
-            // #108: a `$as`-headed ref (map element binding) — resolve the element field's scalar type.
-            if (asBinding !== undefined && e.path[0] === asBinding.name) {
-                try {
-                    const { ref } = goTypedInternals.typedFieldAccess(asBinding.name, asBinding.ref, e.path.slice(1), asBinding.plan);
-                    if (ref.kind === "scalar" && ref.scalar !== "null")
-                        return goScalarPortField(ref.scalar);
-                }
-                catch {
-                    return "Value";
-                }
-                return "Value";
-            }
-            // a ref to a REQUIRED scalar input port → that scalar. An OPTIONAL port has no required-scalar
-            // kind (its native type is *T) and is lowered by the opt lane ahead of this — reaching here with
-            // one means the shape is uncovered, and "Value" routes it to the caller's loud fail-closed.
-            if (e.path.length === 1) {
-                const sc = inputScalarKind(inputPorts[e.path[0]]);
-                if (sc !== undefined)
-                    return sc;
-            }
-            return "Value";
-        }
-        default:
-            return "Value";
-    }
-}
 /** scalar TypeRef → PortFieldType (native go scalar kind). */
 function goScalarPortField(scalar) {
     return scalar === "string" ? "string" : scalar === "int" ? "int64" : scalar === "float" ? "float64" : "bool";
 }
-/** A static string-array port (every element a static string literal) — the graphddb `projection`
- * shape. Returns the list of literal strings, or null when the node is not that shape. */
-function staticStringArrElems(node) {
-    const arr = staticArrElems(node);
-    if (arr === null)
-        return null;
-    const out = [];
-    for (const el of arr) {
-        const e = classifyExpr(el);
-        if (e.kind !== "str")
-            return null;
-        out.push(e.value);
+/**
+ * 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. 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) => {
+        if (opts?.asBinding !== undefined && opts.asBase !== undefined && head === opts.asBinding.name) {
+            return { expr: opts.asBase, ref: opts.asBinding.ref };
+        }
+        if (isPrior(head))
+            return { expr: typedLocal(head), ref: typedNodes.get(head) };
+        return goInputHeadRef(head, comp, plan);
+    };
+}
+/**
+ * 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` — 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 {
+        return new NativeExprCompiler(makeGoExprBackend("", resolveHead, plan)).compilePort(node);
+    }
+    catch (e) {
+        if (!(e instanceof GeneratorFailure))
+            throw e;
+        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}`);
     }
-    return out;
 }
 /**
  * portFieldGoType — the NATIVE Go type for a covered port field (bc#90 / runtime-free). The covered
@@ -115,96 +662,9 @@ function staticStringArrElems(node) {
  * 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, inputPorts, where = "port", asBinding, plan, typedNodes) {
-    // A port reading an OPTIONAL input port lowers through the shared native-expr compiler (the *T
-    // pass-through / the coalesce default). It runs FIRST so an optional input can never fall into the
-    // required-scalar inference below (which has no way to say "absent").
-    const optPort = optPortCompileG(node, inputPorts, where, plan);
-    if (optPort !== null)
-        return renderTypeRef(optPort.ref);
-    if (staticStringArrElems(node) !== null)
-        return "[]string";
-    // #110: a componentRef port bound to a runtime array input port (with a resolvable elemType) → []ElemT.
-    const arrElem = portArrayElemRef(node, inputPorts, plan);
-    if (arrElem !== null)
-        return `[]${renderTypeRef(arrElem)}`;
-    // #129: a leaf port that is a ref into a PRIOR NODE's typed arr outType (node→leaf array dataflow) → []ElemT.
-    const priorArr = priorNodeArrElemInfo(node, typedNodes, plan);
-    if (priorArr !== null)
-        return `[]${renderTypeRef(priorArr.elemRef)}`;
-    const num = numLiteralGoExpr(node);
-    if (num !== null)
-        return Number.isInteger(node) ? "int64" : "float64";
-    // a ref to a `$as` element field (or an input map port) whose type is a MAP or NAMED struct (NOT a bare
-    // scalar) → the native map/struct type (#108-map: a `{map:V}` write port lowers to map[string]V).
-    const composite = portCompositeRef(node, inputPorts, asBinding, plan);
-    if (composite !== null)
-        return renderTypeRef(composite);
-    const ft = inferPortType(node, inputPorts, asBinding);
-    if (ft === "Value") {
-        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go combined read (bc#90 / runtime-free): ${where} '${JSON.stringify(node)}' does not lower to a native Go type (would need a boxed dslcontracts.Value). The covered read plane is runtime-free and admits NO boxed escape. ${GO_STATIC_PORT_FORMS} Regenerate on the boxed straight-line path if this port is genuinely dynamic.`);
-    }
-    return ft;
-}
-/** portCompositeRef (go twin) — the full TypeRef of a port that is a `{ref:[...]}` into a `$as` element
- * MAP or NAMED field (or an input MAP port with elemType). Returns null otherwise (caller falls through
- * to scalar/array inference). #108-map: enables a `{map:V}` write port to lower to map[string]V. */
-function portCompositeRef(node, inputPorts, asBinding, plan) {
-    const e = classifyExpr(node);
-    if (e.kind !== "ref" || plan === undefined)
-        return null;
-    let ref = null;
-    if (asBinding !== undefined && e.path[0] === asBinding.name) {
-        try {
-            ref = goTypedInternals.typedFieldAccess(asBinding.name, asBinding.ref, e.path.slice(1), asBinding.plan).ref;
-        }
-        catch {
-            return null;
-        }
-    }
-    else if (e.path.length === 1) {
-        const s = inputPorts[e.path[0]];
-        if (s !== undefined && s.type === "map") {
-            const et = s.elemType;
-            if (et !== undefined)
-                return { kind: "map", value: deriveTypeRef(et, plan) };
-        }
-        return null;
-    }
-    if (ref === null)
-        return null;
-    if (ref.kind === "map" || ref.kind === "named")
-        return ref;
-    return null;
-}
-/** emitCompositePortValue (go twin) — the OWNED native value expr for a `{map:V}`/named port ref: a typed
- * field access `<elemBase>.<field>` (native map/struct, ZERO boxed Value). `elemBaseExpr` is the map arm's
- * element base for a `$as`-headed ref (omitted at top level — only input map-port refs resolve there). */
-function emitCompositePortValue(node, inputPorts, asBinding, plan, elemBaseExpr) {
-    const e = classifyExpr(node);
-    if (e.kind !== "ref")
-        return null;
-    if (asBinding !== undefined && elemBaseExpr !== undefined && e.path[0] === asBinding.name) {
-        let acc;
-        try {
-            acc = goTypedInternals.typedFieldAccess(elemBaseExpr, asBinding.ref, e.path.slice(1), plan);
-        }
-        catch {
-            return null;
-        }
-        if (acc.ref.kind !== "map" && acc.ref.kind !== "named")
-            return null;
-        return acc.expr;
-    }
-    // a WHOLE-port ref to an input MAP port (with elemType) — valid at top level OR inside a map node (a
-    // ref head that is NOT the `$as` element binding). Reads the native map[string]V off the input struct.
-    if ((asBinding === undefined || e.path[0] !== asBinding.name) && e.path.length === 1) {
-        const s = inputPorts[e.path[0]];
-        if (s !== undefined && s.type === "map" && s.elemType !== undefined) {
-            return `in.${goFieldName(e.path[0])}`;
-        }
-    }
-    return null;
+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))
@@ -215,36 +675,6 @@ function staticArrElems(node) {
     const arg = node.arr;
     return Array.isArray(arg) ? arg : null;
 }
-/**
- * portArrayElemRef (#110) — resolve a componentRef input port that binds a RUNTIME ARRAY (an IN-list /
- * array-bound WHERE head) to its native element TypeRef, or null when the port is not a covered array.
- * The covered shape is a SINGLE-SEGMENT, non-opt `ref` into an INPUT ARRAY port that carries a resolvable
- * `elemType` (scp-ir-architecture.md §5.2 / PortSchema.elemType — BC does NOT infer, consumer-interface
- * C3). The port then lowers to a native `[]ElemT` field fed straight from `in.<Field>` — ZERO boxed Value
- * on the read hot path. This REUSES the bc#108 `elemType` element lowering (deriveTypeRef over the input
- * port's elemType), extended from the `map…over` element-source path to a plain componentRef port.
- *
- * A static string array is a DIFFERENT covered shape ([]string, staticStringArrElems) — handled ahead of
- * this. An array port with NO resolvable elemType, an opt/multi-segment ref, or a non-array input schema
- * resolves to null here → the caller keeps its existing fail-closed behaviour (never a silent box).
- * Requires a TypePlan (an obj elemType maps to a named decl); without one it stays null (fail-closed).
- */
-function portArrayElemRef(node, inputPorts, plan) {
-    if (plan === undefined)
-        return null;
-    if (staticStringArrElems(node) !== null)
-        return null; // the static-string-array port ([]string) — not this shape.
-    const e = classifyExpr(node);
-    if (e.kind !== "ref" || e.opt || e.path.length !== 1)
-        return null;
-    const schema = inputPorts?.[e.path[0]];
-    if (schema === undefined || (schema.type !== "array" && schema.type !== "arr"))
-        return null;
-    const et = schema.elemType;
-    if (et === undefined)
-        return null;
-    return deriveTypeRef(et, plan);
-}
 /**
  * isNativeRawComponent — a component covered by the combined read emitter. Strictly sequential
  * (no real concurrency), body is ALL componentRef (no map/cond), default 'fail'/'continue'
@@ -280,31 +710,49 @@ function numLiteralGoExpr(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 / an
- * optional-input read) — resolvable to a native Go value with no NewObj / no evaluate interpreter. This
- * is the SHAPE gate that decides native ELIGIBILITY; the lowering itself (portFieldGoType / emitPortInit)
- * is what proves each shape, and fails closed loudly on one it cannot lower. */
-function portIsStatic(node, inputPorts) {
-    const arr = staticArrElems(node);
-    if (arr !== null)
-        return arr.every((el) => portIsStatic(el, inputPorts));
-    if (numLiteralGoExpr(node) !== null)
-        return true; // bare number literal (e.g. Query `limit`)
-    // An optional-input read (`opt($.x)` / `coalesce(opt($.x), 20)` / `ne(opt($.x), null)`) is a
-    // statically-resolvable port — the opt lane lowers it (or fails closed with the specific reason).
-    if (inputPorts !== undefined && exprReadsOptionalInput(node, inputPorts))
+/** A port node is static (literal / ref / concat of those / static arr / bare number literal) —
+ * resolvable to a native 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) {
+        if (isControlGate(n))
+            continue;
+        try {
+            typedNodes.set(n.id, "map" in n ? mapNodeArrRef(n, plan) : deriveTypeRef(n.outType, plan));
+        }
+        catch {
+            /* untyped node — omit */
+        }
+    }
+    return typedNodes;
+}
+/** mapAsBinding — the `$as` element binding for a map/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;
+    }
+}
+/** 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;
-    const e = classifyExpr(node);
-    switch (e.kind) {
-        case "str":
-        case "bool":
-        case "null":
-        case "ref":
-            return true;
-        case "concat":
-            return e.parts.every((p) => portIsStatic(reconstructG(p), inputPorts));
-        default:
-            return false;
+    }
+    catch {
+        return false;
     }
 }
 /** The output must lower to a typed struct/value with no Value-scope read: a ref whose head is a
@@ -385,7 +833,7 @@ function coveredMapNode(n, bodyIds, comp) {
     // 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;
@@ -405,8 +853,11 @@ function coveredMapNode(n, bodyIds, comp) {
             return false;
     }
     const ports = m.ports;
+    const plan = planForComp(comp);
+    const typedNodes = buildTypedNodes(comp, plan);
+    const asBinding = mapAsBinding(comp, n, typedNodes, plan);
     for (const p of Object.keys(ports))
-        if (!portIsStatic(ports[p], comp.inputPorts))
+        if (!portIsStatic(ports[p], comp, plan, typedNodes, asBinding))
             return false;
     return true;
 }
@@ -438,8 +889,17 @@ function coveredFanoutNode(n, bodyIds, comp) {
             return false;
     }
     const ports = f.ports;
+    const plan = planForComp(comp);
+    const typedNodes = buildTypedNodes(comp, plan);
+    let asBinding;
+    try {
+        asBinding = { name: f.as, ref: fanoutOverElemInfo(comp, n, typedNodes, plan).elemRef, plan };
+    }
+    catch {
+        asBinding = undefined;
+    }
     for (const p of Object.keys(ports))
-        if (!portIsStatic(ports[p], comp.inputPorts))
+        if (!portIsStatic(ports[p], comp, plan, typedNodes, asBinding))
             return false;
     return true;
 }
@@ -460,6 +920,8 @@ function isSequentialComponentRefRead(comp) {
  * user's signal to add native coverage, fix a genuinely-dynamic spec, or use the --ir dynamic surface.
  */
 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)";
@@ -546,7 +1008,7 @@ function coverageRejectReason(comp) {
         if (cr.relationKind !== undefined && cr.relationKind !== "single" && cr.relationKind !== "connection")
             return `relationKind '${cr.relationKind}' not native-covered (node '${n.id}')`;
         for (const p of Object.keys(cr.ports))
-            if (portIsStatic(cr.ports[p], comp.inputPorts) === false)
+            if (portIsStatic(cr.ports[p], comp, crPlan, crTypedNodes) === false)
                 return `node '${n.id}' port '${p}' is not statically resolvable`;
     }
     if (!outputIsNativeLowerable(comp))
@@ -568,7 +1030,12 @@ function emitPortsStruct(comp, node, asBinding, plan, typedNodes) {
     if (portNames.length === 0) {
         return `// ${structName} — native ports for node '${node.id}' (${node.component}); no ports.\ntype ${structName} struct{}`;
     }
-    const fieldTypes = portNames.map((p) => portFieldGoType(node.ports[p], comp.inputPorts, `port '${p}' of node '${node.id}'`, asBinding, plan, typedNodes));
+    // a node WITH ports always resolves through the one port lowering, which needs the type plan + the
+    // prior-node map (both are supplied by every caller — narrow the optional params for the fields below).
+    if (plan === undefined || typedNodes === undefined) {
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `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
         .map((p, i) => `\t${fieldNames[i]} ${fieldTypes[i]} // ${JSON.stringify(p)}`)
@@ -587,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
@@ -595,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.) */
@@ -627,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 = [];
@@ -642,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) {
@@ -655,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));
@@ -663,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) {
@@ -744,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");
@@ -782,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 }, asBinding, plan);
+    const elemStruct = emitPortsStruct(comp, { id: node.id, component: m.component, ports: m.ports }, asBinding, plan, typedNodes);
     const batchStruct = `${structName}_batch`;
     return `${elemStruct}
 
@@ -800,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 }, asBinding, plan);
+    const elemStruct = emitPortsStruct(comp, { id: node.id, component: f.component, ports: f.ports }, asBinding, plan, typedNodes);
     const batchStruct = `${structName}_batch`;
     return `${elemStruct}
 
@@ -846,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>. */
@@ -947,43 +1421,6 @@ function mapOverElemInfo(comp, node, typedNodes, plan) {
 function mapOverElemType(comp, node, typedNodes, plan) {
     return renderTypeRef(mapOverElemInfo(comp, node, typedNodes, plan).elemRef);
 }
-/**
- * priorNodeArrElemInfo (#129) — resolve a leaf port that is a `ref` into a PRIOR BODY NODE whose
- * annotated `outType` is (or reaches, through a field path) a native array, to its element TypeRef +
- * the native Go slice expression that yields it. This GENERALIZES the `map…over` prior-node-arr
- * dataflow (mapOverElemInfo's first branch) to ANY leaf input port: a fold/dedup leaf whose `items`
- * port is `{ref:["<priorNode>"]}` (or `.items` of a prior connection node) now lowers to `[]ElemT`
- * fed straight from the prior node's typed local — ZERO boxed Value on the read hot path.
- *
- * The element type comes STRICTLY from the prior node's EXPLICIT `outType` annotation walked through
- * typedFieldAccess (BC does NOT infer — consumer-interface C3 / [[graphddb-typed-native-static-link]]):
- * if the head is not a prior body node, or its outType (through the field path) is not an `arr`, this
- * returns null and the caller keeps its existing fail-closed behaviour (never a silent box). A
- * single-segment INPUT-array port (elemType) is a DIFFERENT covered shape (portArrayElemRef) — handled
- * ahead of this. Requires the typedNodes map (prior-node outType TypeRefs) and a TypePlan.
- */
-function priorNodeArrElemInfo(node, typedNodes, plan) {
-    if (typedNodes === undefined || plan === undefined)
-        return null;
-    if (staticArrElems(node) !== null)
-        return null; // a static array literal — not a prior-node ref.
-    const e = classifyExpr(node);
-    if (e.kind !== "ref" || e.opt || e.path.length < 1)
-        return null;
-    if (!typedNodes.has(e.path[0]))
-        return null; // head is not a prior body node → not this shape.
-    const baseRef = typedNodes.get(e.path[0]);
-    let acc;
-    try {
-        acc = goTypedInternals.typedFieldAccess(typedLocal(e.path[0]), baseRef, e.path.slice(1), plan);
-    }
-    catch {
-        return null; // the field path does not resolve on the prior node's outType → fail-closed at caller.
-    }
-    if (acc.ref.kind !== "arr")
-        return null; // the prior-node result (through the path) is not an array.
-    return { elemRef: acc.ref.elem, overExpr: acc.expr };
-}
 function classifyPort(node) {
     if (staticArrElems(node) !== null)
         return "static";
@@ -1037,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).
@@ -1086,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));
@@ -1127,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).
@@ -1166,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}`);
     }
@@ -1178,53 +1592,10 @@ function emitInDecoder(comp, plan) {
     lines.push(`}`);
     return lines.join("\n");
 }
-/** The port forms the STATIC (non-optional) lane lowers — named in its reject message so the message
- * describes what is actually covered rather than a stale corpus list. */
-const GO_STATIC_PORT_FORMS = "This port does not read an optional input, so it lowers through the STATIC port forms: a string / bool / number literal, a static string-array (projection), a ref to a REQUIRED scalar input port, a ref to an input array/map port or a prior node's array (declared elemType), a ref to a `$as` element field, or a concat of native strings. A dynamic operator at port position is not covered on this lane. (A port that DOES read an optional input lowers through the full native expression compiler, which admits the whole closed operator set — so the covered operator set at port position currently depends on the lane, not on the operator.)";
-/**
- * emitNativeScalar — lower a static port expr to a NATIVE Go expression of the concrete `want` scalar
- * type, or null if it cannot be statically proven that type. Literals: a string literal is native for
- * `want==="string"`, a bool literal for `want==="bool"`. A ref resolves via `resolveRef` (typed input
- * field / prior-node scalar / element binding). A concat lowers ONLY into `string` and only when EVERY
- * part is itself a native string (so the concat's strings-only TYPE_MISMATCH can never fire — the parts
- * are statically strings), emitting `p0 + p1 + …`. Returns null (fall back to the Value path) otherwise.
- */
-function emitNativeScalar(node, want, resolveRef) {
-    // a static arr is a Value port (never a scalar) — not native-lowerable here.
-    if (staticArrElems(node) !== null)
-        return null;
-    const e = classifyExpr(node);
-    switch (e.kind) {
-        case "str":
-            return want === "string" ? JSON.stringify(e.value) : null;
-        case "bool":
-            return want === "bool" ? (e.value ? "true" : "false") : null;
-        case "null":
-            return null; // a null literal is a Value(nil), never a required native scalar
-        case "ref": {
-            const sc = resolveRef(e.path[0], e.path.slice(1), e.opt);
-            if (sc === null || sc.scalar !== want)
-                return null;
-            return sc.expr;
-        }
-        case "concat": {
-            if (want !== "string")
-                return null;
-            const parts = [];
-            for (const p of e.parts) {
-                const sub = emitNativeScalar(reconstructG(p), "string", resolveRef);
-                if (sub === null)
-                    return null;
-                // parenthesize a `+` sub-expression so string concatenation binds correctly (a ref/literal is
-                // atomic; a nested concat is already a single `a + b` — wrap to keep it one operand).
-                parts.push(sub.includes(" + ") ? `(${sub})` : sub);
-            }
-            return parts.join(" + ");
-        }
-        default:
-            return null;
-    }
-}
+/** 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 — 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
@@ -1236,66 +1607,11 @@ function emitNativeScalar(node, want, resolveRef) {
  * 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, fieldGoType, resolveRef, inputPorts, plan, typedNodes, asBinding, elemBaseExpr) {
-    const fieldName = goPortFieldName(pn);
-    // The OPTIONAL-input lane (*T pass-through / coalesce default) — same shared compile as
-    // portFieldGoType, so the field type and its initializer are derived from ONE lowering.
-    const optPort = optPortCompileG(expr, inputPorts ?? {}, `port '${pn}'`, plan);
-    if (optPort !== null)
-        return `${fieldName}: ${optPort.expr}`;
-    // #108-map: a port that is a ref to a `$as` element MAP/NAMED field (or an input map port) → the typed
-    // composite value directly off the element/input (native map[string]V / struct — ZERO boxed Value).
-    if (plan !== undefined) {
-        const compExpr = emitCompositePortValue(expr, inputPorts ?? {}, asBinding, plan, elemBaseExpr);
-        if (compExpr !== null)
-            return `${fieldName}: ${compExpr}`;
-    }
-    // #110: a componentRef port bound to a runtime array input port (with elemType) → the native []ElemT,
-    // read straight from the concrete input struct (`in.<Field>`) — ZERO boxed Value on the read hot path.
-    // The over-elem/element-source case (map…over) already resolves via mapOverElemInfo; this is the plain
-    // componentRef port (an IN-list / array-bound WHERE head).
-    if (inputPorts !== undefined && portArrayElemRef(expr, inputPorts, plan) !== null) {
-        const e = classifyExpr(expr);
-        if (e.kind === "ref" && e.path.length === 1) {
-            return `${fieldName}: in.${goFieldName(e.path[0])}`;
-        }
-    }
-    // #129: a leaf port that is a ref into a PRIOR NODE's typed arr outType (node→leaf array dataflow) →
-    // the native []ElemT read straight off the prior node's typed local (`t_<node>.Field…`) — ZERO boxed
-    // Value on the read hot path. The over-source case (map…over) resolves via mapOverElemInfo; this is
-    // the plain leaf array input port (a fold/dedup leaf whose `items` = a prior node's array result).
-    const priorArr = priorNodeArrElemInfo(expr, typedNodes, plan);
-    if (priorArr !== null)
-        return `${fieldName}: ${priorArr.overExpr}`;
-    // change #2: a static string array (projection) → a native `[]string{...}` literal.
-    const strArr = staticStringArrElems(expr);
-    if (strArr !== null) {
-        if (fieldGoType !== "[]string") {
-            throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go combined read (bc#90): port '${pn}' is a static string array but its field type is '${fieldGoType}' (expected []string).`);
-        }
-        return `${fieldName}: []string{${strArr.map((s) => JSON.stringify(s)).join(", ")}}`;
-    }
-    // a bare number literal (e.g. Query `limit: 20`): the SSoT range check ran in numLiteralGoExpr —
-    // emit the concrete native int64/float64 (unwrap the dslcontracts.Value(...) box: it was only there
-    // for the old boxed path; the range check is what matters, and it already passed).
-    const num = numLiteralGoExpr(expr);
-    if (num !== null) {
-        if (fieldGoType === "int64")
-            return `${fieldName}: int64(${expr})`;
-        if (fieldGoType === "float64")
-            return `${fieldName}: float64(${expr})`;
-        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go combined read (bc#90): port '${pn}' is a number literal but its field type is '${fieldGoType}'.`);
-    }
-    // string / bool / scalar-input / concat → native scalar expression (no Value, no `.(T)`).
-    const scalarWant = fieldGoType;
-    const native = emitNativeScalar(expr, scalarWant, resolveRef);
-    if (native !== null) {
-        return `${fieldName}: ${native}`;
-    }
-    // FAIL CLOSED: the covered read plane is runtime-free — no boxed Value fallback (that would
-    // re-couple the covered module to bc-runtime). If a genuinely-dynamic port reaches here, the
-    // component is not native-eligible and must regenerate on the boxed straight-line path.
-    throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go combined read (bc#90 / runtime-free): port '${pn}' (${JSON.stringify(expr)}) does not lower to a native Go value of type '${fieldGoType}'. The covered read plane admits NO boxed dslcontracts.Value escape. ${GO_STATIC_PORT_FORMS} Regenerate on the boxed straight-line path if this port is genuinely dynamic.`);
+function emitPortInit(pn, expr, comp, plan, typedNodes, isPrior, opts) {
+    const c = compilePortNode(expr, comp, plan, typedNodes, isPrior, `port '${pn}'`, opts);
+    if (c.stmts.length > 0)
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `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}`;
 }
 /**
  * emitParallelStageArm (bc#87) — EXPLICIT static parallel orchestration for a real-concurrency stage.
@@ -1318,7 +1634,7 @@ function emitPortInit(pn, expr, fieldGoType, resolveRef, inputPorts, plan, typed
  *
  * NO RunPlan / []OpSpec / planSpec walk: the staging, the bound, and which ops are parallel are baked.
  */
-function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes, plan, priorNodeAt, zeroOut, flags, resolveRefAt) {
+function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes, plan, priorNodeAt, zeroOut, flags) {
     const lines = [];
     const ids = stage.map((i) => comp.body[i].id);
     lines.push(`\t// ── bc#87 real-concurrency stage {${ids.map((x) => JSON.stringify(x)).join(", ")}} — static parallel`);
@@ -1355,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}`);
@@ -1407,11 +1731,8 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
             }
         }
         const inits = [];
-        const resolveRef = resolveRefAt(atPos);
         for (const pn of Object.keys(node.ports)) {
-            const expr = node.ports[pn];
-            const fieldGoType = portFieldGoType(expr, comp.inputPorts, `port '${pn}' of node '${node.id}'`, undefined, plan, typedNodes);
-            inits.push(emitPortInit(pn, expr, fieldGoType, resolveRef, comp.inputPorts, plan, typedNodes));
+            inits.push(emitPortInit(pn, node.ports[pn], comp, plan, typedNodes, (h) => priorNodeAt(h, atPos)));
         }
         lines.push(`${ind}ps_${s} = ${structName}{${inits.join(", ")}}`);
         lines.push(`${ind}run_${s} = true`);
@@ -1432,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}`);
     }
@@ -1444,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}`);
@@ -1518,35 +1873,6 @@ function emitNativeRawRunner(comp, plan, flags) {
     // assert on a row value — the runner reads row.<Field> directly and copies each into the outType local.
     lines.push(`func ${runnerName(comp.name)}[H ${handlerIfaceName(comp.name)}](handlers H, in ${inStructName(comp.name)}) (${outStructType}, error) {`);
     lines.push(`\t_ = in`);
-    // resolveNativeRef for this runner: a ref head is either a PRIOR NODE (read its typed struct field
-    // directly) or an INPUT PORT (read the typed `in.<Field>`). A REQUIRED scalar resolves to a native
-    // Go expression; an opt / non-scalar / refOpt resolves to null (falls back to the nvVE Value path).
-    const resolveRefAt = (atPos) => (head, restPath, opt) => {
-        if (opt)
-            return null; // a refOpt may be nil at runtime — keep the Value path (opt-nil semantics)
-        if (priorNodeAt(head, atPos)) {
-            const baseRef = typedNodes.get(head);
-            let acc;
-            let expr;
-            try {
-                const r = goTypedInternals.typedFieldAccess(typedLocal(head), baseRef, restPath, plan);
-                expr = r.expr;
-                acc = r.ref;
-            }
-            catch {
-                return null;
-            }
-            if (acc.kind !== "scalar" || acc.scalar === "null")
-                return null;
-            return { expr, scalar: goScalar(acc.scalar) };
-        }
-        if (restPath.length !== 0)
-            return null; // input.<field> path is a Value walk — not a native scalar
-        const scalar = inputScalarKind(comp.inputPorts?.[head]);
-        if (scalar === undefined)
-            return null;
-        return { expr: `in.${goFieldName(head)}`, scalar };
-    };
     for (const k of order.keys()) {
         const node = comp.body[order[k]];
         const id = node.id;
@@ -1569,7 +1895,7 @@ function emitNativeRawRunner(comp, plan, flags) {
         // ascending-sorted stages), so we emit the block at the first member and skip the rest.
         const stage = ep.parallelStageOf.get(i);
         if (stage !== undefined && stage[0] === i) {
-            lines.push(emitParallelStageArm(comp, stage, k, ep.concurrency, metas, typedNodes, plan, priorNodeAt, zeroOut, flags, resolveRefAt));
+            lines.push(emitParallelStageArm(comp, stage, k, ep.concurrency, metas, typedNodes, plan, priorNodeAt, zeroOut, flags));
             k += stage.length - 1;
             continue;
         }
@@ -1641,30 +1967,80 @@ function emitNativeRawRunner(comp, plan, flags) {
         // dslcontracts.Value, ZERO nvVE helper, ZERO `.(T)`. A genuinely-dynamic port FAILS CLOSED.
         const inits = [];
         const boundArg = node.bindField !== undefined ? `bound_${s}` : "nil";
-        const resolveRef = resolveRefAt(k);
         for (const pn of portNames) {
-            const expr = node.ports[pn];
-            const fieldGoType = portFieldGoType(expr, comp.inputPorts, `port '${pn}' of node '${node.id}'`, undefined, plan, typedNodes);
-            inits.push(emitPortInit(pn, expr, fieldGoType, resolveRef, comp.inputPorts, plan, typedNodes));
+            inits.push(emitPortInit(pn, node.ports[pn], comp, plan, typedNodes, (h) => priorNodeAt(h, k)));
         }
         lines.push(`${indent}ports_${s} := ${structName}{${inits.join(", ")}}`);
         const oc = `row_${s}`;
-        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);
@@ -1738,67 +2114,16 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, f
     const mkGuard = (elemVar) => {
         if (!hasGuard)
             return null;
-        const resolveHead = (head) => {
-            if (head === asName)
-                return { expr: elemVar, ref: overElemRef };
-            if (priorHere(head))
-                return { expr: typedLocal(head), ref: typedNodes.get(head) };
-            return goInputHeadRef(head, comp, plan);
-        };
+        const resolveHead = goNativeResolveHead(comp, plan, typedNodes, priorHere, { asBinding: { name: asName, ref: overElemRef, plan }, asBase: elemVar });
         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>`.
     const buildPorts = (il, elemVar) => {
-        const out = [];
-        const inits = [];
-        // resolveNativeRef for a map element port: a ref head is the element binding ($as → the over element
-        // typed struct field `elemVar.<Field>`), a PRIOR NODE (its typed struct field), or an INPUT PORT
-        // (`in.<Field>`). A REQUIRED scalar lowers to a native Go expr; opt / non-scalar → null (Value path).
-        const resolveRef = (head, restPath, opt) => {
-            if (opt)
-                return null;
-            let baseExpr;
-            let baseRef;
-            if (head === asName) {
-                baseExpr = elemVar;
-                baseRef = overElemRef;
-            }
-            else if (priorHere(head)) {
-                baseExpr = typedLocal(head);
-                baseRef = typedNodes.get(head);
-            }
-            else {
-                if (restPath.length !== 0)
-                    return null;
-                const scalar = inputScalarKind(comp.inputPorts?.[head]);
-                if (scalar === undefined)
-                    return null;
-                return { expr: `in.${goFieldName(head)}`, scalar };
-            }
-            let acc;
-            let expr;
-            try {
-                const r = goTypedInternals.typedFieldAccess(baseExpr, baseRef, restPath, plan);
-                expr = r.expr;
-                acc = r.ref;
-            }
-            catch {
-                return null;
-            }
-            if (acc.kind !== "scalar" || acc.scalar === "null")
-                return null;
-            return { expr, scalar: goScalar(acc.scalar) };
-        };
         const asBinding = { name: asName, ref: overElemRef, plan };
-        for (const pn of portNames) {
-            const fieldGoType = portFieldGoType(m.ports[pn], comp.inputPorts, `map port '${pn}' of node '${node.id}'`, asBinding, plan);
-            // #108-map: pass the element binding + base expr so a `$as` MAP/NAMED field port reads the typed composite.
-            inits.push(emitPortInit(pn, m.ports[pn], fieldGoType, resolveRef, comp.inputPorts, plan, undefined, asBinding, elemLocal(s)));
-        }
-        out.push(`${il}ep_${s} := ${structName}{${inits.join(", ")}}`);
-        return out;
+        const inits = portNames.map((pn) => emitPortInit(pn, m.ports[pn], comp, plan, typedNodes, priorHere, { asBinding, asBase: elemVar }));
+        return [`${il}ep_${s} := ${structName}{${inits.join(", ")}}`];
     };
     const lines = [];
     const closers = [];
@@ -1814,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) => {
@@ -1830,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}))`);
@@ -1848,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}`);
         }
@@ -1882,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}}`);
@@ -1936,47 +2299,8 @@ function emitFanoutArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut
     const dkGo = goFieldName(f.dedupeKey);
     // per-id native ports build (same as a batched map's per-element ports). $as → the over id value.
     const buildPorts = (il, elemVar) => {
-        const inits = [];
-        const resolveRef = (head, restPath, opt) => {
-            if (opt)
-                return null;
-            let baseExpr;
-            let baseRef;
-            if (head === asName) {
-                baseExpr = elemVar;
-                baseRef = overElemRef;
-            }
-            else if (priorHere(head)) {
-                baseExpr = typedLocal(head);
-                baseRef = typedNodes.get(head);
-            }
-            else {
-                if (restPath.length !== 0)
-                    return null;
-                const scalar = inputScalarKind(comp.inputPorts?.[head]);
-                if (scalar === undefined)
-                    return null;
-                return { expr: `in.${goFieldName(head)}`, scalar };
-            }
-            let acc;
-            let expr;
-            try {
-                const r = goTypedInternals.typedFieldAccess(baseExpr, baseRef, restPath, plan);
-                expr = r.expr;
-                acc = r.ref;
-            }
-            catch {
-                return null;
-            }
-            if (acc.kind !== "scalar" || acc.scalar === "null")
-                return null;
-            return { expr, scalar: goScalar(acc.scalar) };
-        };
         const asBinding = { name: asName, ref: overElemRef, plan };
-        for (const pn of portNames) {
-            const fieldGoType = portFieldGoType(f.ports[pn], comp.inputPorts, `fanout port '${pn}' of node '${node.id}'`, asBinding, plan);
-            inits.push(emitPortInit(pn, f.ports[pn], fieldGoType, resolveRef, comp.inputPorts, plan));
-        }
+        const inits = portNames.map((pn) => emitPortInit(pn, f.ports[pn], comp, plan, typedNodes, priorHere, { asBinding, asBase: elemVar }));
         return [`${il}ep_${s} := ${structName}{${inits.join(", ")}}`];
     };
     const lines = [];
@@ -2000,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.
@@ -2031,73 +2361,17 @@ 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;
     return { expr: `in.${goFieldName(head)}`, ref };
 }
-/**
- * optPortCompileG — the OPTIONAL-input port lane (go). The rust twin's mirror: a component may
- * declare an input port `{opt:T}` (PortSchema `required:false`), and the only native representation of
- * "the value is absent" is `*T`, so such a port never lowers through the required-scalar inference. The
- * port expression compiles with the SHARED runtime-free native-expr compiler (native-expr.ts — the same
- * traversal, type-inference and fail-closed discipline rust uses, so the two agree by construction):
- *
- *   - `opt($.x)` / `$.x` at port position  → `*T` (the leaf receives the absent value as null, exactly
- *     as run_behavior's `evalPorts` passes it).
- *   - `coalesce(opt($.x), <literal>)`      → the native deref-or-default — a native `T`, no boxed Value.
- *   - `ne(opt($.x), null)` / `eq(…, null)` → the native presence test (`!= nil` / `== nil`).
- *
- * Returns null when the port expression reads NO optional input (the caller keeps its existing lowering).
- * A port that DOES read one but does not compile — or that compiles to a fallible expression, which this
- * position cannot hoist — FAILS CLOSED loudly rather than degrade to a required type or a zero value.
- */
-function optPortCompileG(node, inputPorts, where, plan) {
-    if (plan === undefined)
-        return null;
-    if (!exprReadsOptionalInput(node, inputPorts))
-        return null;
-    const resolveHead = (head) => goInputHeadRef(head, { inputPorts }, plan);
-    let c;
-    try {
-        // zeroOut is unreachable here: a port expression that needs an error return is rejected below
-        // (stmts.length > 0), so the backend never renders an early-return with it.
-        c = new NativeExprCompiler(makeGoExprBackend("", resolveHead, plan)).compilePort(node);
-    }
-    catch (e) {
-        if (!(e instanceof GeneratorFailure))
-            throw e;
-        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go typed-native (runtime-free): ${where} ${JSON.stringify(node)} reads an OPTIONAL input port but does not lower to a native Go value: ${e.message}`);
-    }
-    if (c.stmts.length > 0)
-        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go typed-native (runtime-free): ${where} ${JSON.stringify(node)} reads an OPTIONAL input port through a FALLIBLE expression (one that can raise INT_OVERFLOW / NAN_OR_INF / MOD_ZERO / PRECISION_LOSS). Such an expression lowers to STATEMENTS carrying an early error-return, and a port is built inline in the ports-struct literal — a position that cannot host them. (A cond/guard position CAN host them, so the same expression is covered there — the boundary is the POSITION, not the operator.) Use a non-fallible port expression.`);
-    return c;
-}
-/** exprReadsOptionalInput — does this port expression reference an OPTIONAL (`required:false`) input
- * port? Language-neutral scan for `ref`/`refOpt` heads bound to an optional port. Decides ONLY which
- * lane a port takes; the lane itself then proves the lowering (or fails closed). */
-function exprReadsOptionalInput(node, inputPorts) {
-    if (node === null || typeof node !== "object")
-        return false;
-    if (Array.isArray(node))
-        return node.some((el) => exprReadsOptionalInput(el, inputPorts));
-    const rec = node;
-    const keys = Object.keys(rec);
-    if (keys.length === 1 && (keys[0] === "ref" || keys[0] === "refOpt")) {
-        const path = rec[keys[0]];
-        return Array.isArray(path) && typeof path[0] === "string" && inputPortIsOptional(inputPorts?.[path[0]]);
-    }
-    return keys.some((k) => exprReadsOptionalInput(rec[k], inputPorts));
-}
 /**
  * emitCondArm — the struct-native exec of a covered cond node (#108). Mirrors run_behavior's cond
  * lower (behavior.ts:425-429): compile `if` to a native bool, materialize the TAKEN branch to the
@@ -2337,19 +2611,19 @@ function makeGoExprBackend(zeroOut, resolveHead, plan) {
         notOp: (a) => `(!${a})`,
         structLit: (name, inits) => `${name}{${inits.map((i) => `${goFieldName(i.field)}: ${i.expr}`).join(", ")}}`,
         arrLit: (elemTy, items) => `[]${elemTy}{${items.join(", ")}}`,
+        // a projection port of static string literals — bare `[]string{"a", "b"}` (Go string literals are
+        // already allocation-free; no divergence from the general arr path, so no golden churn).
+        staticStrArr: (literals) => ({ expr: `[]string{${literals.map((s) => JSON.stringify(s)).join(", ")}}`, type: "[]string" }),
         // an opt (`*T`) NONE literal is `nil` (the inner type is not needed for the untyped nil in Go).
         optNone: (_innerTy) => "nil",
         // 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 {`,
@@ -2513,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)
@@ -2557,6 +2833,9 @@ 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 = new Map();
@@ -2582,9 +2861,13 @@ function emit(ctx) {
                 structs.push(emitPortsStruct(c, n, undefined, plan, typedNodes));
             }
         }
+        // fail closed for a record inside a non-named top (never a silent trust) — before emitting anything.
+        assertDeBoxableResults(c, typedNodes, plan);
         // CONCRETE per-node row structs + the per-component handler interface (the fully-concrete seam).
         rowStructs.push(emitRawRowStructs(c, typedNodes, plan));
         handlerIfaces.push(emitHandlerInterface(c, typedNodes, plan));
+        // the strict de-box functions for this component's de-box-eligible (named-record) reads.
+        emitNodeDecodeFns(c, typedNodes, plan, decodeEmitted, decodeFns);
         // augmented-element copiers for covered map...into nodes (over fields + concrete into row).
         const mm = emitMapElemMaterializers(c, typedNodes, plan);
         if (mm)
@@ -2618,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
@@ -2642,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,
@@ -2687,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`;
@@ -2712,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;
             }
@@ -2748,72 +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" : "_";
-            const echoBranch = echoable
-                .map((ep) => `\tif src.echo == ${JSON.stringify(ep)} {\n\t\treturn ${rowT}{Val: ports.${goPortFieldName(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
 }`);
         }
     }
@@ -2856,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)
 						}
@@ -2914,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}
 
@@ -2952,16 +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's Val. A port
- * with a different type is not echoable (the row could not hold it), and a NAMED outType has no Val at
- * all (its row carries the struct's fields flattened — see emitDecodeRow). */
-function echoablePorts(comp, node, ref, plan, typedNodes) {
-    if (ref.kind === "named")
-        return [];
-    const want = renderTypeRef(ref);
-    return Object.keys(node.ports).filter((p) => portFieldGoType(node.ports[p], comp.inputPorts, `port '${p}'`, undefined, plan, typedNodes) === 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