behavior-contracts 0.8.5 → 0.8.7

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

@@ -5,7 +5,20 @@ import { goTypedInternals } from "./emit-shared-go-typed.js";
 import { buildTypePlan, deriveTypeRef, findDecl, inputPortIsOptional, inputPortTypeRef } from "./typed.js";
 import { concurrencyPlan, execPlan, analyzeSequentialOps, classifyExpr, buildComponentPlan, } from "./straightline.js";
 import { NativeExprCompiler } from "./native-expr.js";
+import { buildDeBoxPlan, notationOfRef } from "./emit-shared-debox.js";
 const PKG = "dslcontracts";
+/** resolveGoWire — the CONCRETE consumer wire type names the de-box classifies a node result against
+ * (bc#141). Default (no option) → the in-package convention names, unqualified. A configured `import`
+ * qualifies the names with the imported package's selector so a consumer can keep its wire types in its
+ * own package. `value`/`row`/`list` name the WireValue / WireRow / WireList concrete types; the covered
+ * runner + the generated Probe result structs reference them by these names. */
+function resolveGoWire(ctx) {
+    const w = ctx.goWire;
+    if (w === undefined)
+        return { value: "WireValue", row: "WireRow", list: "WireList" };
+    const sel = w.import !== undefined ? `${w.import.split("/").pop().replace(/[^A-Za-z0-9_]/g, "_")}.` : "";
+    return { value: `${sel}${w.value}`, row: `${sel}${w.row}`, list: `${sel}${w.list}`, import: w.import };
+}
 /** goErr — build the LOCAL concrete error value for a behavior/plan failure on the covered read
  * plane (runtime-free). The covered module declares `type BehaviorError struct { Code, Message string }`
  * (see emitBehaviorErrorType); a `*BehaviorError` satisfies the runner's `error` return. This REPLACES
@@ -15,14 +28,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 +63,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 +113,241 @@ const { goFieldName, renderTypeRef, goScalar, serializeTyped, emitTypeDecls, emi
 function typedLocal(nodeId) {
     return `t_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
 }
+// ── strict de-box: the ONE inline renderer over the SSoT plan ─────────────────────────────
+//
+// A covered node result de-box is compiled INLINE at its consumption point from the language-neutral
+// SSoT walk (emit-shared-debox.ts `buildDeBoxPlan`). The handler returns the consumer's WIRE (a single
+// concrete WireValue — the producer's datum); the generated de-box classifies it against the STATICALLY
+// declared node type via the CONCRETE seam methods (WireValue.As* → the top; WireRow.Probe* → a record
+// field / map value; WireList.Elem* → a list element). The consumer supplies variant classification (a
+// probe reports the producer's own wire tag as a free string); the generated code owns strictness —
+// required/optional, present/absent, error assembly, fail-closed. NO decodeWire_* helper, NO output-side
+// recursion, NO interface, NO generics, NO boxed Value: a nested record expands to a nested struct
+// build, a collection to a nested loop, and every method call resolves to a concrete consumer type.
+/** goTypeOfPlan — the CONCRETE Go type of a de-box plan node (base kind + `optDepth` `*` wraps). Equal to
+ * renderTypeRef of the ORIGINAL ref, but read off the language-neutral plan so the inline renderer can
+ * declare its temps / list-element / map-value locals without re-deriving the TypeRef. */
+function goTypeOfPlan(plan) {
+    let base;
+    switch (plan.k) {
+        case "scalar":
+            base = goScalar(plan.scalar);
+            break;
+        case "record":
+            base = plan.typeName;
+            break;
+        case "list":
+            base = `[]${goTypeOfPlan(plan.elem)}`;
+            break;
+        case "map":
+            base = `map[string]${goTypeOfPlan(plan.value)}`;
+            break;
+    }
+    return "*".repeat(plan.optDepth) + base;
+}
+/**
+ * renderGoDeBox — the ONE inline, recursive strict de-box renderer (Go). Folds a language-neutral
+ * {@link DeBoxPlan} (the SSoT walk) into FLAT Go STATEMENTS that decode the wire obtained by probing
+ * `srcExpr` per the node's access (top → `As*()`, field → `Probe*(key)`, elem → `Elem*(i)`, mapval →
+ * `Probe*(k)`) and assign the decoded native value into the lvalue `target`. The recursion runs HERE at
+ * generation time (walking the plan), so the emitted Go is fully unrolled: NO `decodeWire_*` helper, NO
+ * output-side recursion — a nested record expands to a nested struct build, a nested collection to a
+ * nested loop. A required-position mismatch runs `fail(...)` (default: `return <zero>, de_*(...)`); an
+ * optional position (optDepth>0) leaves the target pointer nil on absent/null. `ctr` hands out unique
+ * temp suffixes so nested blocks never collide; `idxExpr` is the element index / map-key argument the
+ * enclosing list / map loop supplies (empty for top / field). Mirrors the interpreter's outType check,
+ * but TOTAL over the grammar (opt(named)/arr(arr)/map(opt)…) and inlined — the type is baked all the way
+ * through by the TS compiler, and every seam call resolves to a CONCRETE consumer type (no dispatch).
+ */
+function renderGoDeBox(plan, target, srcExpr, ctr, indent, fail, idxExpr = "") {
+    const I = indent;
+    const I1 = indent + "\t";
+    const I2 = indent + "\t\t";
+    const id = ctr.n++;
+    const ml = JSON.stringify(plan.model);
+    const fl = JSON.stringify(plan.field);
+    const nl = JSON.stringify(plan.expectedType);
+    const opt = plan.optDepth > 0;
+    const pv = `p${id}`;
+    const kindSuffix = plan.k === "list" ? "List" : plan.k === "scalar" ? (plan.scalar === "string" ? "String" : plan.scalar === "bool" ? "Bool" : "Number") : "Row";
+    // the probe call for this node's access (top → As*, field/mapval → Probe*(key), elem → Elem*(i)).
+    const probeCall = (() => {
+        switch (plan.access.from) {
+            case "top":
+                return `${srcExpr}.As${kindSuffix}()`;
+            case "field":
+                return `${srcExpr}.Probe${kindSuffix}(${JSON.stringify(plan.access.key)})`;
+            case "elem":
+                return `${srcExpr}.Elem${kindSuffix}(${idxExpr})`;
+            case "mapval":
+                return `${srcExpr}.Probe${kindSuffix}(${idxExpr})`;
+        }
+    })();
+    const mismatch = fail(`deTypeMismatch(${ml}, ${fl}, ${nl}, ${pv}.ActualWireType, ${pv}.Raw)`);
+    const missing = fail(`deMissingField(${ml}, ${fl}, ${nl})`);
+    // wrap a decoded BASE-typed temp in optDepth `&` layers into target (present ⇒ &^N; absent/null ⇒ nil).
+    const wrapAssign = (baseTemp) => {
+        if (plan.optDepth === 0)
+            return [`${I1}${target} = ${baseTemp}`];
+        const out = [];
+        let cur = baseTemp;
+        for (let i = 0; i < plan.optDepth; i++) {
+            if (i === plan.optDepth - 1)
+                out.push(`${I1}${target} = &${cur}`);
+            else {
+                const w = `w${id}_${i}`;
+                out.push(`${I1}${w} := &${cur}`);
+                cur = w;
+            }
+        }
+        return out;
+    };
+    const lines = [];
+    lines.push(`${I}${pv} := ${probeCall}`);
+    lines.push(`${I}if ${pv}.Kind == probeGot {`);
+    if (plan.k === "scalar") {
+        if (plan.scalar === "string" || plan.scalar === "bool") {
+            if (plan.optDepth === 0)
+                lines.push(`${I1}${target} = ${pv}.Got`);
+            else {
+                lines.push(`${I1}sv${id} := ${pv}.Got`);
+                for (const l of wrapAssign(`sv${id}`))
+                    lines.push(l);
+            }
+        }
+        else {
+            // int/float: parse + range-check here (BC owns overflow) — no panic, a structured overflow error.
+            const parse = plan.scalar === "int" ? `strconv.ParseInt(${pv}.Got, 10, 64)` : `strconv.ParseFloat(${pv}.Got, 64)`;
+            lines.push(`${I1}n${id}, nErr${id} := ${parse}`);
+            lines.push(`${I1}if nErr${id} != nil {`);
+            lines.push(`${I2}${fail(`deOverflow(${ml}, ${fl}, ${nl}, ${pv}.ActualWireType, ${pv}.Got)`)}`);
+            lines.push(`${I1}}`);
+            for (const l of wrapAssign(`n${id}`))
+                lines.push(l);
+        }
+    }
+    else if (plan.k === "record") {
+        lines.push(`${I1}var rec${id} ${plan.typeName}`);
+        for (const f of plan.fields)
+            lines.push(renderGoDeBox(f.plan, `rec${id}.${goFieldName(f.name)}`, `${pv}.Got`, ctr, I1, fail));
+        for (const l of wrapAssign(`rec${id}`))
+            lines.push(l);
+    }
+    else if (plan.k === "list") {
+        const elemGo = goTypeOfPlan(plan.elem);
+        lines.push(`${I1}list${id} := make([]${elemGo}, 0, ${pv}.Got.Len())`);
+        lines.push(`${I1}for i${id} := 0; i${id} < ${pv}.Got.Len(); i${id}++ {`);
+        lines.push(`${I2}var el${id} ${elemGo}`);
+        lines.push(renderGoDeBox(plan.elem, `el${id}`, `${pv}.Got`, ctr, I2, fail, `i${id}`));
+        lines.push(`${I2}list${id} = append(list${id}, el${id})`);
+        lines.push(`${I1}}`);
+        for (const l of wrapAssign(`list${id}`))
+            lines.push(l);
+    }
+    else {
+        // map(V): the wire value is a producer map; enumerate its keys, decode each value as V.
+        const valGo = goTypeOfPlan(plan.value);
+        lines.push(`${I1}m${id} := make(map[string]${valGo})`);
+        lines.push(`${I1}for _, k${id} := range ${pv}.Got.Keys() {`);
+        lines.push(`${I2}var mv${id} ${valGo}`);
+        lines.push(renderGoDeBox(plan.value, `mv${id}`, `${pv}.Got`, ctr, I2, fail, `k${id}`));
+        lines.push(`${I2}m${id}[k${id}] = mv${id}`);
+        lines.push(`${I1}}`);
+        for (const l of wrapAssign(`m${id}`))
+            lines.push(l);
+    }
+    // WRONG → mismatch (required + optional). Required: NULL → mismatch, ABSENT → missing. Optional:
+    // NULL / ABSENT leave the target pointer nil (no statement — the zero value IS None).
+    lines.push(`${I}} else if ${pv}.Kind == probeWrong {`);
+    lines.push(`${I1}${mismatch}`);
+    if (!opt) {
+        lines.push(`${I}} else if ${pv}.Kind == probeNull {`);
+        lines.push(`${I1}${mismatch}`);
+        lines.push(`${I}} else {`);
+        lines.push(`${I1}${missing}`);
+    }
+    lines.push(`${I}}`);
+    return lines.join("\n");
+}
+/** returnZeroFail — the default de-box mismatch control flow: return the runner's zero output + the
+ * structured Error Value (fail/retry componentRef results + map/fanout element de-box, which fails closed
+ * regardless of elementPolicy — matching the interpreter's whole-node outType throw). */
+const returnZeroFail = (zeroOut) => (errValueExpr) => `return ${zeroOut}, ${errValueExpr}`;
+/** renderResultDeBox — inline strict de-box of a whole result WIRE (`srcExpr`, a WireValue) into the
+ * lvalue `target`, from the TOTAL SSoT plan for `ref` at the top position. `fail` selects the mismatch
+ * control flow. This is the ONE de-box call the runner arms share (componentRef result + map/fanout
+ * element) — no per-position predicate, no helper decode fn. `ctr` hands out unique temp suffixes: the
+ * sequential runner threads ONE counter across all its at-fn-scope nodes so siblings never collide;
+ * loop/if-scoped arms (map / fanout / parallel commit) may pass a fresh one. */
+function renderResultDeBox(ref, target, srcExpr, nodeId, plan, indent, fail, ctr = { n: 0 }) {
+    return renderGoDeBox(buildDeBoxPlan(ref, { from: "top" }, { model: nodeId, field: nodeId, plan }), target, srcExpr, ctr, indent, fail);
+}
+/** emitProbeWireTypes — the once-per-module probe kind consts + probe RESULT structs. A NumberProbe's
+ * Got is the raw numeric text (the de-box parses + range-checks it, so overflow is BC's to detect); every
+ * probe carries ActualWireType even on a match so overflow can report the numeric wire tag. Raw is the
+ * offending value stringified (NOT named RawValue — that token is reserved for the ErrorDetail field
+ * decl). Concrete data structs — no boxed Value on the seam. bc does NOT declare the WireValue/WireRow/
+ * WireList seam types (that would own the wire format, and a Go interface is vtable dynamic dispatch); it
+ * REFERENCES the consumer's CONCRETE types by name (RowProbe.Got is a `${wire.row}`, ListProbe.Got a
+ * `${wire.list}`) and the runner calls their methods directly (zero dynamic dispatch, zero dictionary). */
+function emitProbeWireTypes(wire) {
+    return `// Probe kinds — the outcome of classifying one wire attribute against a declared field type.
+const (
+	probeGot    uint8 = 0 // present; the wire variant matches the declared type
+	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 wire map (a DynamoDB "M") or wire array (an
+// "L"). Got is the consumer's CONCRETE ${wire.row} / ${wire.list} (a value type — no boxed Value, no
+// interface); the inline de-box probes it directly.
+type RowProbe struct {
+	Kind           uint8
+	Got            ${wire.row}
+	ActualWireType string
+	Raw            string
+}
+
+type ListProbe struct {
+	Kind           uint8
+	Got            ${wire.list}
+	ActualWireType string
+	Raw            string
+}`;
+}
+/** 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);
+}
 function goPortFieldName(wire) {
     const safe = wire.replace(/[^A-Za-z0-9_]/g, "_");
     const head = safe.charAt(0);
@@ -49,21 +358,14 @@ function portsStructName(compName, nodeId) {
     // type to implement the per-component Handler_<comp> interface's concrete Node_* method signatures.
     return `PortsNR_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
 }
-/**
- * portFieldGoType — the NATIVE Go type for a covered port field (bc#90 / runtime-free), read off the ONE
- * port lowering (compilePortNode / native-expr). The covered ports struct carries NO `dslcontracts.Value`
- * field: every port lowers to a concrete Go type, and a port that cannot lower FAILS CLOSED. The field
- * type is the compiled expression's TypeRef, so it can never disagree with the initializer (emitPortInit),
- * which is the SAME lowering read for its value. `where` names the emission site for the error.
- */
-function portFieldGoType(node, comp, plan, typedNodes, where = "port", opts) {
-    const c = compilePortNode(node, comp, plan, typedNodes, (h) => typedNodes.has(h), where, opts);
-    return c.renderedType ?? renderTypeRef(c.ref);
+/** scalar TypeRef → PortFieldType (native go scalar kind). */
+function goScalarPortField(scalar) {
+    return scalar === "string" ? "string" : scalar === "int" ? "int64" : scalar === "float" ? "float64" : "bool";
 }
 /**
  * goNativeResolveHead — the ONE ref-head resolver the runtime-free native-expr compiler reads, for cond
- * `if`/branches, a map/fanout `when` guard, AND a port (go twin — Go's value semantics need no ownership
- * ceremony). A head is a `$as` element binding, a prior body node's typed local, or an input port.
+ * `if`/branches, a map/fanout `when` guard, AND a port. A head is a `$as` element binding, a prior body
+ * node's typed local, or an input port.
  */
 function goNativeResolveHead(comp, plan, typedNodes, isPrior, opts) {
     return (head) => {
@@ -78,18 +380,14 @@ function goNativeResolveHead(comp, plan, typedNodes, isPrior, opts) {
 /**
  * compilePortNode — lower a port expression to its native ports-struct field via the runtime-free
  * native-expr compiler (native-expr.ts): the ONE port lowering. The port's field TYPE is the compiled
- * `ref`, its initializer the compiled `expr` — so the two are derived from a SINGLE lowering and can
- * never disagree. Any closed operator, a literal, a ref (input scalar/array/map, prior-node scalar/array,
- * `$as` element field), a concat, a static array, an optional-input read — all resolve here. A port that
- * cannot lower FAILS CLOSED loudly. A lowering that is FALLIBLE (hoists statements) is a covered SHAPE
- * returned here as-is; only the value site (emitPortInit) rejects it, since a ports-struct literal cannot
- * host statements — the coverage gate/type site must still see it as covered.
+ * `ref`, its initializer the compiled `expr` — derived from a SINGLE lowering, so they cannot disagree.
+ * Any closed operator, a literal, a ref (input scalar/array/map, prior-node scalar/array, `$as` element
+ * field), a concat, a static array, an optional-input read — all resolve here. A port that cannot lower
+ * FAILS CLOSED. A FALLIBLE lowering (hoists statements) is returned as-is; only emitPortInit rejects it.
  */
 function compilePortNode(node, comp, plan, typedNodes, isPrior, where, opts) {
     const resolveHead = goNativeResolveHead(comp, plan, typedNodes, isPrior, opts);
     try {
-        // zeroOut is unreachable: a fallible port is rejected at emitPortInit (a ports-struct literal hosts no
-        // statements), so the backend never renders an early-return with it.
         return new NativeExprCompiler(makeGoExprBackend("", resolveHead, plan)).compilePort(node);
     }
     catch (e) {
@@ -98,8 +396,73 @@ function compilePortNode(node, comp, plan, typedNodes, isPrior, where, opts) {
         throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go typed-native (runtime-free): ${where} ${JSON.stringify(node)} does not lower to a native Go value: ${e.message}`);
     }
 }
-/** the prior-node typed-local TypeRef map for a component (control-gate nodes are typeless; a map node
- * carries its produced-array ref). Shared by coverage, the struct surface, and the runner. */
+/**
+ * portFieldGoType — the NATIVE Go type for a covered port field (bc#90 / runtime-free). The covered
+ * ports struct carries NO `dslcontracts.Value` field: every port lowers to a concrete Go type.
+ *   - a static string-array (projection) → `[]string` (change #2);
+ *   - a bare int/float number literal (e.g. Query `limit: 20`) → `int64`/`float64`;
+ *   - a string/bool/scalar-input port → the scalar Go type (inferPortType).
+ * A port that would otherwise infer to the boxed `Value` (a dynamic operator, a non-static array, a
+ * Value-typed input) FAILS CLOSED — the covered read plane admits NO boxed escape (there is no
+ * `dslcontracts.Value` fallback on the native module). `where` names the emission site for the error.
+ */
+function portFieldGoType(node, comp, plan, typedNodes, where = "port", opts) {
+    const c = compilePortNode(node, comp, plan, typedNodes, (h) => typedNodes.has(h), where, opts);
+    return c.renderedType ?? renderTypeRef(c.ref);
+}
+function staticArrElems(node) {
+    if (node === null || typeof node !== "object" || Array.isArray(node))
+        return null;
+    const keys = Object.keys(node);
+    if (keys.length !== 1 || keys[0] !== "arr")
+        return null;
+    const arg = node.arr;
+    return Array.isArray(arg) ? arg : null;
+}
+/**
+ * isNativeRawComponent — a component covered by the combined read emitter. Strictly sequential
+ * (no real concurrency), body is ALL componentRef (no map/cond), default 'fail'/'continue'
+ * policy, relationKind is single/connection or absent, and EVERY node carries outType + the
+ * component carries outputType. relationKind:single / bindField ARE the point — inline exec makes
+ * the child-present decision from the real parent result. Ports AND the output are evaluated via
+ * the primitive SSoT over a Value-space portScope (so a dynamic operator in a port or an
+ * obj-assembly output is fine — the SSoT handles fail-closed semantics; only the RESULT plane +
+ * PORT container go native). A covered SHAPE that lacks outType is a fail-closed error raised at
+ * emit (see assertTypedCoverage) — never a silent re-box.
+ */
+/**
+ * numLiteralGoExpr — a BARE numeric port literal (JSON number, e.g. the `limit: 20` Query port).
+ * `classifyExpr` deliberately leaves a bare number `dynamic` (its checked int/float range rules are
+ * the evaluate SSoT, expr.go evalNumberLiteral), so a plain number never reaches the str/bool/null
+ * static branch. But a number literal IS statically resolvable to a native Go Value: the SAME
+ * range check the runtime applies is performed HERE at generation time (integral literal in the
+ * safe 2^53-1 window → int64; a fractional/exponent literal → the checked float64). Returns the Go
+ * expression for the literal's Value, or null when the node is not a bare number OR the integral
+ * literal is out of the safe window (that out-of-range case keeps the runtime INVALID_LITERAL
+ * semantics — the port is NOT covered natively, so the whole component falls through, never a
+ * silently-wrong inline). Mirrors coderuntime.evalNumberLiteral exactly.
+ */
+const NUM_SAFE_INT = 9007199254740991; // 2^53 - 1 (expr.go safeInt)
+function numLiteralGoExpr(node) {
+    if (typeof node !== "number" || !Number.isFinite(node))
+        return null;
+    if (Number.isInteger(node)) {
+        if (node < -NUM_SAFE_INT || node > NUM_SAFE_INT)
+            return null; // out of safe window → not covered (runtime INVALID_LITERAL)
+        return `${PKG}.Value(int64(${node}))`;
+    }
+    // fractional / exponent literal → checked float64 (finite, already guaranteed above).
+    return `${PKG}.Value(float64(${node}))`;
+}
+/** A port node is static (literal / ref / concat of those / static arr / bare number literal) —
+ * resolvable to a native Go Value with no NewObj / no evaluate interpreter. */
+/** planForComp — a TypePlan for a single component (its named types are component-scoped, so a
+ * one-component IR yields the same plan the full-IR build would for this component). */
+function planForComp(comp) {
+    return buildTypePlan({ irVersion: 1, exprVersion: 2, components: [comp] });
+}
+/** buildTypedNodes — the prior-node typed-local TypeRef map for a component (control-gate nodes are
+ * typeless; a map node carries its produced-array ref). An untyped node is omitted (not an error here). */
 function buildTypedNodes(comp, plan) {
     const typedNodes = new Map();
     for (const n of comp.body) {
@@ -114,25 +477,26 @@ function buildTypedNodes(comp, plan) {
     }
     return typedNodes;
 }
-function staticArrElems(node) {
-    if (node === null || typeof node !== "object" || Array.isArray(node))
-        return null;
-    const keys = Object.keys(node);
-    if (keys.length !== 1 || keys[0] !== "arr")
-        return null;
-    const arg = node.arr;
-    return Array.isArray(arg) ? arg : null;
+/** mapAsBinding — the `$as` element binding for a map/fanout node's element ports (the over-element
+ * TypeRef), or undefined when the over source does not resolve (an uncovered map). */
+function mapAsBinding(comp, node, typedNodes, plan) {
+    try {
+        return { name: node.map.as, ref: mapOverElemInfo(comp, node, typedNodes, plan).elemRef, plan };
+    }
+    catch {
+        return undefined;
+    }
 }
-/** Does a port lower to a native value? The ELIGIBILITY gate ASKS the one port lowering (compilePortNode
- * / native-expr) whether it can lower this port, rather than re-deriving the shape rules — so the gate
- * and the emitter can never disagree. A port that does not lower (or lowers fallibly) fails closed. */
+/** portIsStatic — the ELIGIBILITY gate ASKS the one port lowering (compilePortNode / native-expr)
+ * whether it can lower this port, rather than re-deriving the shape rules — so the gate and the emitter
+ * can never disagree. A port that does not lower (or lowers fallibly) fails closed. */
 function portIsStatic(node, comp, plan, typedNodes, asBinding) {
     try {
         compilePortNode(node, comp, plan, typedNodes, (h) => typedNodes.has(h), "port", asBinding !== undefined ? { asBinding, asBase: asBinding.name } : undefined);
         return true;
     }
     catch {
-        return false; // an eligibility probe: any lowering failure ⇒ not native-covered here.
+        return false;
     }
 }
 /** The output must lower to a typed struct/value with no Value-scope read: a ref whose head is a
@@ -180,8 +544,8 @@ function isFullyTyped(comp) {
     }
     return true;
 }
-function isNativeRaw(comp, plan) {
-    return isSequentialComponentRefRead(comp, plan) && isFullyTyped(comp);
+function isNativeRaw(comp) {
+    return isSequentialComponentRefRead(comp) && isFullyTyped(comp);
 }
 /**
  * coveredMapNode — the #86 part 2 covered map shape (nestedBatchGet). A BATCHED `map` node whose:
@@ -196,7 +560,7 @@ function isNativeRaw(comp, plan) {
  * element struct by copying the over element's typed fields + materializing the into field from the
  * aligned batch raw — NO boxed Value on any plane.
  */
-function coveredMapNode(n, bodyIds, comp, plan, typedNodes) {
+function coveredMapNode(n, bodyIds, comp) {
     if (n === null || typeof n !== "object" || !("map" in n))
         return false;
     const m = n.map;
@@ -213,7 +577,7 @@ function coveredMapNode(n, bodyIds, comp, plan, typedNodes) {
     // A map node must carry an outType (its ELEMENT type per the recorder SoT — authoring.ts recordMap
     // holds `node.outType = mapElem`, the PRE-array-wrap element; the emitter synthesizes the produced
     // `[]element`). A map WITHOUT outType is uncovered. Legacy hand-built IR that already carries the
-    // `{arr:element}` produced form is ALSO accepted — mapNodeArrRef normalizes both to the array ref.
+    // The map node's outType is the ELEMENT type; mapNodeArrRef wraps it to the produced array ref.
     const outT = n.outType;
     if (outT === undefined || typeof outT !== "object")
         return false;
@@ -233,22 +597,14 @@ function coveredMapNode(n, bodyIds, comp, plan, typedNodes) {
             return false;
     }
     const ports = m.ports;
+    const plan = planForComp(comp);
+    const typedNodes = buildTypedNodes(comp, plan);
     const asBinding = mapAsBinding(comp, n, typedNodes, plan);
     for (const p of Object.keys(ports))
         if (!portIsStatic(ports[p], comp, plan, typedNodes, asBinding))
             return false;
     return true;
 }
-/** the `$as` element binding for a covered map/fanout node's element ports (name + over-element TypeRef),
- * or undefined when the over element type does not resolve (the node is then uncovered upstream). */
-function mapAsBinding(comp, node, typedNodes, plan) {
-    try {
-        return { name: node.map.as, ref: mapOverElemInfo(comp, node, typedNodes, plan).elemRef, plan };
-    }
-    catch {
-        return undefined;
-    }
-}
 /**
  * coveredFanoutNode (v3) — a FANOUT node (first-class `@refs` id-list fan-out) is covered when:
  *   - over is a static ref to a PRIOR BODY NODE's typed arr field OR an INPUT array port with elemType,
@@ -257,7 +613,7 @@ function mapAsBinding(comp, node, typedNodes, plan) {
  * The fanout de-boxes to: one deduped batched dispatch → first-seen dedupe (by the elem's dedupeKey
  * field) + dangling drop + implicitSource strip + connection wrap {items, cursor:nil} — NO boxed Value.
  */
-function coveredFanoutNode(n, bodyIds, comp, plan, typedNodes) {
+function coveredFanoutNode(n, bodyIds, comp) {
     if (n === null || typeof n !== "object" || !("fanout" in n))
         return false;
     const f = n.fanout;
@@ -277,6 +633,8 @@ function coveredFanoutNode(n, bodyIds, comp, plan, typedNodes) {
             return false;
     }
     const ports = f.ports;
+    const plan = planForComp(comp);
+    const typedNodes = buildTypedNodes(comp, plan);
     let asBinding;
     try {
         asBinding = { name: f.as, ref: fanoutOverElemInfo(comp, n, typedNodes, plan).elemRef, plan };
@@ -294,8 +652,8 @@ function coveredFanoutNode(n, bodyIds, comp, plan, typedNodes) {
  * reads. A real-concurrency plan whose parallel members include a map / bindField-relation child is
  * NOT covered here (falls through) — the static-parallel orchestration covers the componentRef fan-out
  * (the GroupAccessRead shape); a parallel map/relation-child stage is a further shape (out of scope). */
-function isSequentialComponentRefRead(comp, plan) {
-    return coverageRejectReason(comp, plan) === null;
+function isSequentialComponentRefRead(comp) {
+    return coverageRejectReason(comp) === null;
 }
 /**
  * coverageRejectReason — the DIAGNOSTIC twin of isSequentialComponentRefRead (bc#86/#89). Returns
@@ -305,11 +663,12 @@ function isSequentialComponentRefRead(comp, plan) {
  * never disagree. This is the message the fail-closed dispatch surfaces per non-native component — the
  * user's signal to add native coverage, fix a genuinely-dynamic spec, or use the --ir dynamic surface.
  */
-function coverageRejectReason(comp, plan) {
+function coverageRejectReason(comp) {
+    const crPlan = planForComp(comp);
+    const crTypedNodes = buildTypedNodes(comp, crPlan);
     const ep = execPlan(comp);
     if (ep === null)
         return "component is not a straight-line/staged sequential exec plan (no static exec plan)";
-    const typedNodes = buildTypedNodes(comp, plan);
     // A parallel-stage member must be a componentRef node (no map) so the static parallel orchestration
     // is a clean fan-out — the bounded-concurrency error-precedence protocol is proven for that shape.
     // A map child inside a parallel stage still falls through (its per-element loop is a further shape).
@@ -354,7 +713,7 @@ function coverageRejectReason(comp, plan) {
         if ("fanout" in n) {
             // v3: a first-class fanout node (deduped connection list-in fan-out) IS covered when its over is a
             // covered ref (prior-node arr / input array with elemType) and its element ports are static.
-            if (!coveredFanoutNode(n, bodyIds, comp, plan, typedNodes))
+            if (!coveredFanoutNode(n, bodyIds, comp))
                 return `node '${n.id}' is a non-covered fanout shape (over an input array without elemType, or a dynamic element port)`;
             continue;
         }
@@ -362,7 +721,7 @@ function coverageRejectReason(comp, plan) {
             // #86 pt2 batched map...into / #93 shape 2/3 / #108 guarded map (no into) / map-over-input (with
             // elemType) ARE covered. A non-covered map shape (guard+into heterogeneous / over-input without
             // elemType) falls through to the loud fail-closed reject.
-            if (!coveredMapNode(n, bodyIds, comp, plan, typedNodes))
+            if (!coveredMapNode(n, bodyIds, comp))
                 return `node '${n.id}' is a non-covered map shape (guard+into heterogeneous, or over an input array without elemType)`;
             continue;
         }
@@ -393,7 +752,7 @@ function coverageRejectReason(comp, plan) {
         if (cr.relationKind !== undefined && cr.relationKind !== "single" && cr.relationKind !== "connection")
             return `relationKind '${cr.relationKind}' not native-covered (node '${n.id}')`;
         for (const p of Object.keys(cr.ports))
-            if (portIsStatic(cr.ports[p], comp, plan, typedNodes) === false)
+            if (portIsStatic(cr.ports[p], comp, crPlan, crTypedNodes) === false)
                 return `node '${n.id}' port '${p}' is not statically resolvable`;
     }
     if (!outputIsNativeLowerable(comp))
@@ -401,20 +760,25 @@ function coverageRejectReason(comp, plan) {
     return null;
 }
 /** Fail closed if a covered read SHAPE lacks the typed annotations (no silent boxed re-box). */
-function assertTypedCoverage(comp, plan) {
-    if (!isSequentialComponentRefRead(comp, plan))
+function assertTypedCoverage(comp) {
+    if (!isSequentialComponentRefRead(comp))
         return;
     if (isFullyTyped(comp))
         return;
     throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go combined read (bc#77): component '${comp.name}' is a sequential componentRef read but lacks outType/outputType on every node — the combined emitter de-boxes the RESULT into the node's outType struct, so a covered read MUST be fully typed (bc#45). Add outType annotations, or regenerate on go-straightline-native (boxed result).`);
 }
 // ── native ports struct + PortReader ──────────────────────────────────────────────────
-function emitPortsStruct(comp, node, plan, typedNodes, asBinding) {
+function emitPortsStruct(comp, node, asBinding, plan, typedNodes) {
     const structName = portsStructName(comp.name, node.id);
     const portNames = Object.keys(node.ports);
     if (portNames.length === 0) {
         return `// ${structName} — native ports for node '${node.id}' (${node.component}); no ports.\ntype ${structName} struct{}`;
     }
+    // a node WITH ports always resolves through the one port lowering, which needs the type plan + the
+    // prior-node map (both are supplied by every caller — narrow the optional params for the fields below).
+    if (plan === undefined || typedNodes === undefined) {
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go typed-native: ports struct for node '${node.id}' needs a type plan + prior-node map`);
+    }
     const fieldTypes = portNames.map((p) => portFieldGoType(node.ports[p], comp, plan, typedNodes, `port '${p}' of node '${node.id}'`, asBinding !== undefined ? { asBinding, asBase: asBinding.name } : undefined));
     const fieldNames = portNames.map(goPortFieldName);
     const fields = portNames
@@ -430,32 +794,11 @@ type ${structName} struct {
 ${fields}
 }`;
 }
-// ── CONCRETE per-node row structs + row→outType copiers (bc: full Go concreteness) ──────────
-//
-// The covered path no longer crosses a generic `RawValue`/`RawRow` on the RESULT plane. Each
-// covered node has a CONCRETE row struct `RawRow_<comp>_<node>` whose fields are the node's
-// projected outType fields (typed, flattened) plus a per-node error signal (IsError/Err). The
-// per-component `Handler_<comp>` interface has one method per node returning that concrete struct;
-// the runner reads `row.<Field>` DIRECTLY (no `.(RawRow)`, no `.(scalar)`, no `RawValue`) and copies
-// each field into the node's outType struct local. The `.(T)` type-assert seam that the generic
-// RawValue de-box carried is GONE on the covered path (the handler produces the typed fields).
-//
-// A scalar/arr/opt node (outType not a named struct) has a single `Val <typed>` payload field. A
-// named-struct node has one Go field per outType field (same names/types as the outType decl), so
-// `RawRow_<comp>_<node>` is structurally the outType struct + {IsError, Err}. The copier is then a
-// mechanical field-for-field assignment into the outType struct — NO dynamic value read anywhere.
-/** Row_<comp>_<node> — the concrete per-node handler-result row struct name. (Deliberately NOT
- * prefixed with the generic dynamic-accessor name — that accessor is what the concrete path removes.) */
-function rawRowStructName(compName, nodeId) {
-    return `Row_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
-}
-/** RowElem_<comp>_<node> — the concrete per-ELEMENT row struct name for a covered map node (the
- * element/into row the map handler yields per over element). */
-function rawElemStructName(compName, nodeId) {
-    return `RowElem_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
-}
-/** Handler_<comp> — the per-component concrete handler interface name (one Node_* method per node). */
-function handlerIfaceName(compName) {
+/** handlerTypeName — the per-component CONCRETE handler type name the runner takes by value (one Node_*
+ * method per node). It is NOT a bc-declared interface (a Go interface is vtable dynamic dispatch): the
+ * consumer supplies a concrete type of this name (default `Handler_<comp>`) and the runner calls
+ * `h.Node_*(...)` directly (zero dynamic dispatch, zero dictionary). */
+function handlerTypeName(compName) {
     return `Handler_${sanitize(compName)}`;
 }
 /** RunNativeRawStruct_<comp> — the EXPORTED name of the per-component struct-returning combined runner
@@ -470,76 +813,6 @@ function runnerName(compName) {
 function nodeMethodName(compName, nodeId) {
     return `Node_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
 }
-/**
- * emitRawRowStructs — emit the concrete `RawRow_<comp>_<node>` struct per covered node (and, for a
- * covered map node, the per-element `RawElem_<comp>_<node>`). A named-struct outType flattens to one
- * Go field per outType field; a scalar/arr/opt node carries a single `Val` payload. Every row carries
- * the per-node error signal (IsError/Err) so the runner interprets policy without a boxed outcome.
- */
-function emitRawRowStructs(comp, typedNodes, plan) {
-    const parts = [];
-    for (const n of comp.body) {
-        // #108: a cond node has NO handler-result row (pure Expression — no dispatch).
-        if ("cond" in n)
-            continue;
-        const ref = typedNodes.get(n.id);
-        if ("fanout" in n) {
-            // a covered fanout node: RawElem_ is the connection items element (the per-body row the batched
-            // handler yields, aligned to the deduped id list); the batch RawRow_ carries the aligned []RawElem_.
-            const elemRowRef = fanoutItemsElemRef(n, ref, plan);
-            parts.push(emitOneRowStruct(rawElemStructName(comp.name, n.id), elemRowRef, plan));
-            parts.push(`// ${rawRowStructName(comp.name, n.id)} — the BATCH row for fanout '${n.id}': the aligned per-body rows.\n` +
-                `type ${rawRowStructName(comp.name, n.id)} struct {\n\tIsError bool\n\tErr     string\n\tRows    []${rawElemStructName(comp.name, n.id)}\n}`);
-            continue;
-        }
-        if ("map" in n) {
-            // a covered map node: RawElem_<comp>_<node> is the HANDLER'S per-element return shape:
-            //   - into: the `into` field's type (the fetched item merged onto every over element);
-            //   - no-into (#93 shape 3): the element outType directly (connection-collect).
-            // The batched Node_* returns RawRow_<comp>_<node> (aligned []RawElem_ + error); a per-element
-            // dispatch Node_* returns RawElem_ directly (one physical call per element).
-            const arrRef = ref;
-            const elemRowRef = mapElemRowRef(n, arrRef, plan);
-            parts.push(emitOneRowStruct(rawElemStructName(comp.name, n.id), elemRowRef, plan));
-            parts.push(`// ${rawRowStructName(comp.name, n.id)} — the BATCH row for map '${n.id}': the aligned per-element rows.\n` +
-                `type ${rawRowStructName(comp.name, n.id)} struct {\n\tIsError bool\n\tErr     string\n\tRows    []${rawElemStructName(comp.name, n.id)}\n}`);
-            continue;
-        }
-        parts.push(emitOneRowStruct(rawRowStructName(comp.name, n.id), ref, plan));
-    }
-    return parts.join("\n\n");
-}
-/** Emit one concrete row struct: flatten a named outType to typed fields, else a single Val payload;
- * always carry IsError/Err. */
-function emitOneRowStruct(name, ref, plan) {
-    const lines = [];
-    lines.push(`// ${name} — CONCRETE handler-result row (typed fields = the node's outType; + error signal).`);
-    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) {
-            lines.push(`\t${goFieldName(f.name)} ${renderTypeRef(f.type)} // ${JSON.stringify(f.name)}`);
-        }
-    }
-    else {
-        lines.push(`\tVal ${renderTypeRef(ref)}`);
-    }
-    lines.push(`}`);
-    return lines.join("\n");
-}
-/** emitRowCopy — the statements copying a concrete row's typed fields into the node's outType local
- * `target` (a value of Go type renderTypeRef(ref)). Named: field-for-field; scalar/arr/opt: `.Val`.
- * `rowExpr` is the concrete RawRow_/RawElem_ value; `indent` tabs. No dynamic read — pure assignment. */
-function emitRowCopy(target, rowExpr, ref, plan, indent) {
-    const t = "\t".repeat(indent);
-    if (ref.kind === "named") {
-        const decl = findDecl(plan, ref.name);
-        return decl.fields.map((f) => `${t}${target}.${goFieldName(f.name)} = ${rowExpr}.${goFieldName(f.name)}`).join("\n");
-    }
-    return `${t}${target} = ${rowExpr}.Val`;
-}
 /**
  * boundGoType (change #3 — typed `bound`) — the CONCRETE Go type of a covered node's `bound` handler
  * param (bc#90 / runtime-free). `bound` is the parent-produced key (the bindField value); it replaces
@@ -569,47 +842,6 @@ function boundGoType(node, comp, typedNodes, plan) {
         return `*${renderTypeRef(bfRef.inner)}`;
     return `*${renderTypeRef(bfRef)}`;
 }
-/**
- * emitHandlerInterface — the per-component `Handler_<comp>` interface: one concrete-typed `Node_*`
- * method per covered node. Each componentRef node method takes the node's native ports struct + the
- * typed `bound` pointer (change #3 — the produced-aware parent key; NO boxed dslcontracts.Value) and
- * returns its concrete row struct + a resolved bool. A covered map node's method takes the batch
- * ports struct (batched) or the element ports struct (per-element) and returns the batch / element
- * row. This is the fully-concrete, runtime-free replacement for the generic ExecNativeRaw seam.
- */
-function emitHandlerInterface(comp, typedNodes, plan) {
-    const lines = [];
-    lines.push(`// ${handlerIfaceName(comp.name)} — the CONCRETE per-component handler seam: one typed method`);
-    lines.push(`// per covered node (native ports struct IN, concrete row struct OUT). No generic boxed-ports`);
-    lines.push(`// / boxed-value / dynamic accessor crosses the covered boundary — the consumer implements each`);
-    lines.push(`// Node_* with a decode of its own wire payload into the concrete row (see INTEGRATION.md §6).`);
-    lines.push(`type ${handlerIfaceName(comp.name)} interface {`);
-    for (const n of comp.body) {
-        if ("cond" in n)
-            continue; // #108: a cond node has no handler method (pure Expression).
-        const method = nodeMethodName(comp.name, n.id);
-        const bt = boundGoType(n, comp, typedNodes, plan);
-        if ("fanout" in n) {
-            // fanout (v3): one batched dispatch of the deduped id list. Ports = the batch struct; returns the
-            // aligned batch row (per-body rows) + resolved. The runner applies dedupe/drop/wrap after.
-            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)`);
-            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)`);
-            continue;
-        }
-        lines.push(`\t${method}(ports ${portsStructName(comp.name, n.id)}, bound ${bt}) (${rawRowStructName(comp.name, n.id)}, bool)`);
-    }
-    lines.push(`}`);
-    return lines.join("\n");
-}
 /** mapElemMaterializerName — the augmented-element copier for a covered map...into node. */
 function mapElemMaterializerName(compName, nodeId) {
     return `materializeMapElemNR_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
@@ -629,7 +861,7 @@ function emitMapPortsStructs(comp, node, typedNodes, plan) {
     // struct element). A pure-static/concat port ignores the binding.
     const { elemRef } = mapOverElemInfo(comp, node, typedNodes, plan);
     const asBinding = { name: m.as, ref: elemRef, plan };
-    const elemStruct = emitPortsStruct(comp, { id: node.id, component: m.component, ports: m.ports }, plan, typedNodes, asBinding);
+    const elemStruct = emitPortsStruct(comp, { id: node.id, component: m.component, ports: m.ports }, asBinding, plan, typedNodes);
     const batchStruct = `${structName}_batch`;
     return `${elemStruct}
 
@@ -647,7 +879,7 @@ function emitFanoutPortsStructs(comp, node, typedNodes, plan) {
     const structName = portsStructName(comp.name, node.id);
     const { elemRef } = fanoutOverElemInfo(comp, node, typedNodes, plan);
     const asBinding = { name: f.as, ref: elemRef, plan };
-    const elemStruct = emitPortsStruct(comp, { id: node.id, component: f.component, ports: f.ports }, plan, typedNodes, asBinding);
+    const elemStruct = emitPortsStruct(comp, { id: node.id, component: f.component, ports: f.ports }, asBinding, plan, typedNodes);
     const batchStruct = `${structName}_batch`;
     return `${elemStruct}
 
@@ -693,18 +925,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>. */
@@ -724,9 +954,8 @@ function mapElemRowRef(node, arrRef, plan) {
 }
 /**
  * emitMapElemMaterializers — for each covered map...into node, emit the AUGMENTED-element copier: copy
- * the over element's typed fields + assign the `into` field from the concrete per-element handler row
- * (RawElem_<comp>_<node>). Pure struct field assignment — NO dynamic value read (the handler already
- * produced the typed into row).
+ * the over element's typed fields + place the already-de-boxed `into` value into its field. Pure struct
+ * field assignment — NO dynamic value read (the inline de-box already produced the typed `into` value).
  */
 function emitMapElemMaterializers(comp, typedNodes, plan) {
     const parts = [];
@@ -748,16 +977,15 @@ function emitMapElemMaterializers(comp, typedNodes, plan) {
         const intoRowRef = mapElemRowRef(n, arrRef, plan);
         const fn = mapElemMaterializerName(comp.name, n.id);
         const overElemGo = mapOverElemType(comp, n, typedNodes, plan);
-        const elemRowGo = rawElemStructName(comp.name, n.id);
         const lines = [];
         lines.push(`// ${fn} — assemble the augmented map element '${n.id}': copy the over element's typed`);
-        lines.push(`// fields + set the '${intoKey}' (into) field from the concrete per-element handler row.`);
-        lines.push(`func ${fn}(over ${overElemGo}, into ${elemRowGo}) ${elemRef.name} {`);
+        lines.push(`// fields + set the '${intoKey}' (into) field from the already-de-boxed into value.`);
+        lines.push(`func ${fn}(over ${overElemGo}, into ${renderTypeRef(intoRowRef)}) ${elemRef.name} {`);
         lines.push(`\tvar out ${elemRef.name}`);
         for (const f of overFields) {
             lines.push(`\tout.${goFieldName(f.name)} = over.${goFieldName(f.name)}`);
         }
-        lines.push(emitRowCopy(`out.${goFieldName(intoKey)}`, "into", intoRowRef, plan, 1));
+        lines.push(`\tout.${goFieldName(intoKey)} = into`);
         lines.push(`\treturn out`);
         lines.push(`}`);
         parts.push(lines.join("\n"));
@@ -847,31 +1075,17 @@ function reconstructG(e) {
 function inStructName(compName) {
     return `In_${sanitize(compName)}`;
 }
-/**
- * inputPortGoType — the native Go type for an input port's declared type. Scalars lower to the concrete
- * scalar; `array`/`map` with a declared elemType to `[]ElemT` / `map[string]ElemT`; an OPTIONAL port
- * (`{opt:T}` → `required:false`) to `*T` — the native representation of "the value is absent" (nil).
- * A declared type with no native lowering stays the boxed Value.
- *
- * An OPTIONAL port whose inner type has no native lowering FAILS CLOSED: a boxed `Value` cannot carry
- * the presence distinction on the covered plane, and emitting the bare inner type would silently turn
- * "absent" into a zero value. A port whose optionality cannot be represented is never silently coerced.
- */
+/** Go type for an input port's declared type (scalar → concrete; array+elemType → []ElemT; else Value). */
 function inputPortGoType(schema, plan, where = "input port") {
     const ref = inputPortTypeRef(schema, plan);
     if (ref !== undefined)
         return renderTypeRef(ref);
     if (inputPortIsOptional(schema))
-        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go typed-native (runtime-free): ${where} is OPTIONAL (declared {opt:…}) but its inner type ${JSON.stringify(schema?.type)} has no native Go lowering, so "absent" has no native representation (a boxed Value would be an escape, and the bare inner type would silently read absent as a zero value). Declare an elemType for an array/map, or use a natively-lowerable scalar.`);
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go typed-native (runtime-free): ${where} is OPTIONAL (declared {opt:…}) but its inner type ${JSON.stringify(schema?.type)} has no native Go lowering, so "absent" has no native representation. Declare an elemType for an array/map, or use a natively-lowerable scalar.`);
     return `${PKG}.Value`;
 }
-/** The scalar kind a REQUIRED input port declares, or undefined when it is not a required native scalar.
- * An OPTIONAL port is deliberately NOT a scalar kind here: its native type is `*T`, and the callers of
- * this function build REQUIRED scalar slots (`in.<Field>` read straight into a non-opt port field).
- * Answering "int64" for an `{opt:"int"}` port is exactly how "absent" would silently become `0`. */
+/** The scalar kind an input port declares, or undefined if it is not a native scalar. */
 function inputScalarKind(schema) {
-    if (inputPortIsOptional(schema))
-        return undefined;
     switch (schema?.type) {
         case "string":
         case "literal": // a `"literal"` union is a constrained string (see inputPortGoType).
@@ -896,6 +1110,8 @@ function emitInStruct(comp, plan) {
         return `// ${name} — the CONCRETE input for '${comp.name}' (no input ports).\ntype ${name} struct{}`;
     }
     const names = ports.map((p) => goFieldName(p));
+    // #139: inputPortGoType reads the inputPortTypeRef SSoT — an OPTIONAL port is `*T` (absent → nil); an
+    // optional whose inner type has no native lowering FAILS CLOSED (never a boxed Value escape).
     const types = ports.map((p) => inputPortGoType(comp.inputPorts[p], plan, `input port '${p}' of component '${comp.name}'`));
     const nameW = Math.max(0, ...names.map((n) => n.length));
     const typeW = Math.max(0, ...types.map((t) => t.length));
@@ -937,15 +1153,6 @@ function emitInDecoder(comp, plan) {
         const scalar = inputScalarKind(schema);
         const et = schema.elemType;
         lines.push(`\tif v, ok := input.Get(${JSON.stringify(p)}); ok {`);
-        if (inputPortIsOptional(schema)) {
-            // An OPTIONAL port decodes into its native *T. materializeExpr's opt de-box IS the wire rule:
-            // a nil Value (null) → nil (absent), any other value → a pointer to the materialized inner. A key
-            // that never appears leaves the struct's zero value (nil) — the same absent value. Checked FIRST:
-            // optionality wraps every inner type (an optional array is *[]T, not []T).
-            lines.push(`\t\tin.${field} = ${goTypedInternals.materializeExpr("v", inputPortTypeRef(schema, plan), plan)}`);
-            lines.push(`\t}`);
-            continue;
-        }
         if ((schema?.type === "array" || schema?.type === "arr") && et !== undefined) {
             // #108: decode the boxed Value array into the native []ElemT (test glue — materialize each element
             // via the typed materializer; a non-array or non-conforming element is a fail-closed decode error).
@@ -976,11 +1183,9 @@ function emitInDecoder(comp, plan) {
             lines.push(`\t\tin.${field} = v`);
         }
         else {
-            lines.push(`\t\tt, tok := v.(${scalar})`);
-            lines.push(`\t\tif !tok {`);
-            lines.push(`\t\t\treturn in, ${PKG}.NewExprFailure("TYPE_MISMATCH", "input ${p}: expected ${scalar}, got "+${PKG}.TypeName(v))`);
-            lines.push(`\t\t}`);
-            lines.push(`\t\tin.${field} = t`);
+            // #139: materialize via the inputPortTypeRef SSoT so an OPTIONAL scalar reads as *T (present → &v);
+            // an absent optional never enters this block (Get !ok), leaving the field nil (not a required zero).
+            lines.push(`\t\tin.${field} = ${goTypedInternals.materializeExpr("v", inputPortTypeRef(schema, plan), plan)}`);
         }
         lines.push(`\t}`);
     }
@@ -988,17 +1193,25 @@ function emitInDecoder(comp, plan) {
     lines.push(`}`);
     return lines.join("\n");
 }
+/** A ref resolver for native lowering: given a ref head + remaining field path, return a native scalar
+ * Go expression (typed input field / prior-node typed struct scalar / element binding field), or null
+ * when the ref does not resolve to a REQUIRED (non-opt) native scalar (then the caller falls back to
+ * the nvVE Value path — which keeps the runtime null/opt/TYPE_MISMATCH semantics). */
 /**
- * emitPortInit — the port field initializer, read off the ONE port lowering (compilePortNode / native-
- * expr). The field's declared TYPE (portFieldGoType) is the SAME lowering's TypeRef, so type and value
- * can never disagree. `isPrior` tests whether a ref head names a settled prior node at this position;
- * `opts.asBinding`/`opts.asBase` carry a map/fanout element binding. A FALLIBLE lowering (hoisted
- * statements) is rejected HERE — a ports-struct literal cannot host statements.
+ * emitPortInit — emit the port field build for one port as a FULLY NATIVE Go expression (bc#90 /
+ * runtime-free). Every covered port lowers to a concrete Go value assigned straight into the ports
+ * struct field — NO `dslcontracts.Value`, NO nvVE helper, NO `.(T)` type-assert:
+ *   - a static string array (projection) → `[]string{"a", "b", ...}` (change #2);
+ *   - a bare int/float number literal (e.g. Query `limit: 20`) → `int64(20)` / `float64(...)`;
+ *   - a string/bool/scalar-input port → the native scalar expression (emitNativeScalar).
+ * A port that CANNOT lower natively FAILS CLOSED (there is no boxed Value fallback on the covered
+ * plane — a boxed escape would re-introduce the bc-runtime coupling this module removes). Returns the
+ * struct field initializer (`Field: <expr>`). `resolveRef` resolves a ref head for the scalar path.
  */
 function emitPortInit(pn, expr, comp, plan, typedNodes, isPrior, opts) {
     const c = compilePortNode(expr, comp, plan, typedNodes, isPrior, `port '${pn}'`, opts);
     if (c.stmts.length > 0)
-        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go typed-native (runtime-free): port '${pn}' ${JSON.stringify(expr)} lowers to a FALLIBLE expression (one that can raise INT_OVERFLOW / NAN_OR_INF / MOD_ZERO / PRECISION_LOSS). Such an expression lowers to STATEMENTS carrying an early error-return, and a port is built inline in the ports-struct literal — a position that cannot host them. (A cond/guard position CAN host them, so the same expression is covered there — the boundary is the POSITION, not the operator.) Use a non-fallible port expression.`);
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go typed-native (runtime-free): port '${pn}' ${JSON.stringify(expr)} lowers to a FALLIBLE expression (one that can raise INT_OVERFLOW / NAN_OR_INF / MOD_ZERO / PRECISION_LOSS). Such an expression lowers to STATEMENTS carrying an early error-return, and a port is built inline in the ports-struct literal — a position that cannot host them. Use a non-fallible port expression.`);
     return `${goPortFieldName(pn)}: ${c.expr}`;
 }
 /**
@@ -1022,7 +1235,7 @@ function emitPortInit(pn, expr, comp, plan, typedNodes, isPrior, opts) {
  *
  * NO RunPlan / []OpSpec / planSpec walk: the staging, the bound, and which ops are parallel are baked.
  */
-function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes, plan, priorNodeAt, zeroOut, flags) {
+function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes, plan, priorNodeAt, zeroOut, flags, wire) {
     const lines = [];
     const ids = stage.map((i) => comp.body[i].id);
     lines.push(`\t// ── bc#87 real-concurrency stage {${ids.map((x) => JSON.stringify(x)).join(", ")}} — static parallel`);
@@ -1059,9 +1272,10 @@ 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`);
+        // every member's goroutine returns the result WIRE (a single WireValue); the ascending COMMIT phase
+        // de-boxes it INLINE (so the wire — not the decode — is what the goroutine writes to its slot).
+        lines.push(`\t\tvar wire_${s} ${wire.value}`);
+        lines.push(`\t\tvar row_${s}Err error`);
         lines.push(`\t\trun_${s} := false`);
         lines.push(`\t\tvar ps_${s} ${structName}`);
         lines.push(`\t\t_ = ps_${s}`);
@@ -1133,32 +1347,43 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
         lines.push(`\t\t\t\tdefer wg.Done()`);
         lines.push(`\t\t\t\tdefer func() { <-sem }()`);
         const boundArg = node.bindField !== undefined ? `bound_${s}` : "nil";
-        lines.push(`\t\t\t\trow_${s}, row_${s}Resolved = handlers.${nodeMethodName(comp.name, node.id)}(ps_${s}, ${boundArg})`);
+        lines.push(`\t\t\t\twire_${s}, row_${s}Err = handlers.${nodeMethodName(comp.name, node.id)}(ps_${s}, ${boundArg})`);
         lines.push(`\t\t\t}()`);
         lines.push(`\t\t}`);
     }
     lines.push(`\t\twg.Wait()`);
-    // 3) COMMIT (ascending index): interpret + materialize deterministically — lowest-index failure wins.
+    // 3) COMMIT (ascending index): interpret + INLINE de-box deterministically — lowest-index failure wins.
+    // Uniform seam: every member's slot holds a single result WIRE (WireValue); the inline de-box
+    // (renderResultDeBox) classifies it against the STATICALLY declared result type and produces the
+    // structured Error Value on a mismatch (byte-equal codes to run_behavior's outType check, so ≡ holds).
     for (const i of refMembers) {
         const node = comp.body[i];
         const meta = metas[i];
         const s = sanitize(node.id);
         const ref = typedNodes.get(node.id);
-        const oc = `row_${s}`;
         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`);
+            // continue: a failed member (leaf failure OR de-box mismatch) commits no Port (defensive — covered
+            // componentRef members are always 'fail' policy today). A local skip, NOT a runner-wide propagate.
+            const nodeGo = renderTypeRef(ref);
+            const nodeZeroFail = (e) => `return ${goZero(ref)}, ${e}`;
+            lines.push(`\t\t\tif row_${s}Err == nil {`);
+            lines.push(`\t\t\t\tdec_${s}, dec_${s}DErr := func() (${nodeGo}, error) {`);
+            lines.push(`\t\t\t\t\tvar out ${nodeGo}`);
+            lines.push(renderResultDeBox(ref, "out", `wire_${s}`, node.id, plan, "\t\t\t\t\t", nodeZeroFail));
+            lines.push(`\t\t\t\t\treturn out, nil`);
+            lines.push(`\t\t\t\t}()`);
+            lines.push(`\t\t\t\tif dec_${s}DErr == nil {`);
+            lines.push(`\t\t\t\t\t${typedLocal(node.id)} = dec_${s}`);
+            lines.push(`\t\t\t\t\tproduced_${s} = true`);
+            lines.push(`\t\t\t\t}`);
             lines.push(`\t\t\t}`);
         }
         else {
-            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 row_${s}Err != nil {`);
+            lines.push(`\t\t\t\treturn ${zeroOut}, opFailed(${JSON.stringify(node.id)}, ${JSON.stringify(meta.policy === "retry" ? "retry" : "fail")}, row_${s}Err)`);
             lines.push(`\t\t\t}`);
-            lines.push(emitRowCopy(typedLocal(node.id), oc, ref, plan, 3));
+            lines.push(renderResultDeBox(ref, typedLocal(node.id), `wire_${s}`, node.id, plan, "\t\t\t", returnZeroFail(zeroOut)));
             lines.push(`\t\t\tproduced_${s} = true`);
         }
         lines.push(`\t\t}`);
@@ -1179,7 +1404,7 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
  * consumer (graphddb) drives it and keeps the struct native. A Value observation is produced ONLY
  * by the separate serialize wrapper (run_native_raw_<comp>, below), the single outer Value boundary.
  */
-function emitNativeRawRunner(comp, plan, flags) {
+function emitNativeRawRunner(comp, plan, flags, wire) {
     const ep = execPlan(comp);
     const order = ep.order;
     const cplan = buildComponentPlan(comp, goStraightlineInternals.dialect, "scope");
@@ -1200,6 +1425,9 @@ function emitNativeRawRunner(comp, plan, flags) {
     const outRef = comp.outputType !== undefined ? deriveTypeRef(comp.outputType, plan) : undefined;
     const outStructType = outRef ? renderTypeRef(outRef) : `${PKG}.Value`;
     const zeroOut = outRef ? goZero(outRef) : "nil";
+    // ONE de-box temp counter across all at-fn-scope sequential nodes so sibling reads never collide on a
+    // temp name (a gated / loop-scoped arm has its own Go scope, so it may keep a fresh counter).
+    const seqCtr = { n: 0 };
     const lines = [];
     lines.push(`// ${runnerName(comp.name)} — the STRUCT-RETURNING combined read (bc#77/#87): the fully`);
     lines.push(`// de-plumbed path. Ports are a native struct (direct field assignment); the handler`);
@@ -1213,11 +1441,12 @@ function emitNativeRawRunner(comp, plan, flags) {
     lines.push(`// index order so the observed value / op multiset / failure precedence byte-match run_behavior`);
     lines.push(`// (the goroutine spawn is the ONLY runtime element — the WHAT is baked). The output is a typed`);
     lines.push(`// struct/value assembled by struct literal + field access — the consumer keeps it native.`);
-    // FULLY CONCRETE: GENERIC over the per-component CONCRETE handler interface ${handlerIfaceName(comp.name)},
-    // whose Node_* methods return the concrete per-node row struct (typed fields = the node's outType).
-    // The covered result plane carries no boxed ports / boxed value / dynamic accessor / semantic type-
-    // assert on a row value — the runner reads row.<Field> directly and copies each into the outType local.
-    lines.push(`func ${runnerName(comp.name)}[H ${handlerIfaceName(comp.name)}](handlers H, in ${inStructName(comp.name)}) (${outStructType}, error) {`);
+    // FULLY CONCRETE + NON-GENERIC: the runner takes the consumer's CONCRETE ${handlerTypeName(comp.name)}
+    // handler by value and calls h.Node_*(...) DIRECTLY (a Go generic method call goes through a dictionary,
+    // a Go interface through a vtable — BOTH are dynamic dispatch, so the covered plane uses neither). Each
+    // Node_* returns the node's result WIRE (a single ${wire.value}); the runner de-boxes it INLINE
+    // (fully-unrolled probe/match — no decode helper, no output recursion) into the node's outType struct.
+    lines.push(`func ${runnerName(comp.name)}(handlers ${handlerTypeName(comp.name)}, in ${inStructName(comp.name)}) (${outStructType}, error) {`);
     lines.push(`\t_ = in`);
     for (const k of order.keys()) {
         const node = comp.body[order[k]];
@@ -1241,7 +1470,7 @@ function emitNativeRawRunner(comp, plan, flags) {
         // ascending-sorted stages), so we emit the block at the first member and skip the rest.
         const stage = ep.parallelStageOf.get(i);
         if (stage !== undefined && stage[0] === i) {
-            lines.push(emitParallelStageArm(comp, stage, k, ep.concurrency, metas, typedNodes, plan, priorNodeAt, zeroOut, flags));
+            lines.push(emitParallelStageArm(comp, stage, k, ep.concurrency, metas, typedNodes, plan, priorNodeAt, zeroOut, flags, wire));
             k += stage.length - 1;
             continue;
         }
@@ -1317,22 +1546,35 @@ function emitNativeRawRunner(comp, plan, flags) {
             inits.push(emitPortInit(pn, node.ports[pn], comp, plan, typedNodes, (h) => priorNodeAt(h, k)));
         }
         lines.push(`${indent}ports_${s} := ${structName}{${inits.join(", ")}}`);
-        const oc = `row_${s}`;
-        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);
+        // uniform seam: the handler returns a single result WIRE (${wire.value}); the inline de-box
+        // (renderResultDeBox) classifies it against the STATICALLY declared result type and produces the
+        // structured Error Value on a mismatch (byte-equal codes to run_behavior's outType check, so ≡ holds).
         if (meta.policy === "continue") {
-            lines.push(`${indent}if !${oc}.IsError {`);
-            lines.push(copy(indent + "\t"));
-            lines.push(`${indent}\tproduced_${s} = true`);
+            // continue: a failed node (leaf failure OR de-box mismatch) produces no Port — the downstream Skip
+            // propagation is what `continue` means. The inline de-box runs in a local closure so a mismatch is a
+            // LOCAL skip (not a runner-wide propagate); only a clean decode commits. (Covered componentRef nodes
+            // are always 'fail' policy today — this arm is defensive.)
+            const nodeGo = renderTypeRef(ref);
+            const nodeZeroFail = (e) => `return ${goZero(ref)}, ${e}`;
+            lines.push(`${indent}if wire_${s}, wire_${s}Err := handlers.${nodeMethodName(comp.name, node.id)}(ports_${s}, ${boundArg}); wire_${s}Err == nil {`);
+            lines.push(`${indent}\tdec_${s}, dec_${s}DErr := func() (${nodeGo}, error) {`);
+            lines.push(`${indent}\t\tvar out ${nodeGo}`);
+            lines.push(renderResultDeBox(ref, "out", `wire_${s}`, node.id, plan, `${indent}\t\t`, nodeZeroFail, seqCtr));
+            lines.push(`${indent}\t\treturn out, nil`);
+            lines.push(`${indent}\t}()`);
+            lines.push(`${indent}\tif dec_${s}DErr == nil {`);
+            lines.push(`${indent}\t\t${typedLocal(node.id)} = dec_${s}`);
+            lines.push(`${indent}\t\tproduced_${s} = true`);
+            lines.push(`${indent}\t}`);
             lines.push(`${indent}}`);
         }
         else {
-            const 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`)}`);
+            const policyLit = JSON.stringify(meta.policy === "retry" ? "retry" : "fail");
+            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(copy(indent));
+            lines.push(renderResultDeBox(ref, typedLocal(node.id), `wire_${s}`, node.id, plan, indent, returnZeroFail(zeroOut), seqCtr));
             lines.push(`${indent}produced_${s} = true`);
         }
         for (const c of closers)
@@ -1408,7 +1650,8 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, f
         if (!hasGuard)
             return null;
         const resolveHead = goNativeResolveHead(comp, plan, typedNodes, priorHere, { asBinding: { name: asName, ref: overElemRef, plan }, asBase: elemVar });
-        return new NativeExprCompiler(makeGoExprBackend(zeroOut, resolveHead, plan)).compileBool(m.when);
+        const be = makeGoExprBackend(zeroOut, resolveHead, plan);
+        return new NativeExprCompiler(be).compileBool(m.when);
     };
     // emit the per-element native ports struct build (shared; `il` is the indent inside the element
     // loop, `elemVar` the over element loop variable). Returns the lines building `ep_<s>`.
@@ -1430,7 +1673,13 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, f
     // over collection (typed field access to the parent node's arr — no serialize).
     lines.push(`${indent}over_${s} := ${overExpr}`);
     lines.push(`${indent}${typedLocal(node.id)} = make(${elemGo}, 0, len(over_${s}))`);
+    // each element is de-boxed strictly INLINE: the handler returns the per-element WIRE and the arm decodes
+    // it against the element ref (the `into` field's type for map...into, else the element type). A de-box
+    // mismatch fails closed regardless of elementPolicy (matching the interpreter's whole-node outType
+    // throw); elementPolicy still governs the handler's own leaf failures only.
     const elemRowRef = mapElemRowRef(node, arrRef, plan);
+    const elemRowGo = renderTypeRef(elemRowRef);
+    const renderElemDeBox = (target, src, il) => renderResultDeBox(elemRowRef, target, src, node.id, plan, il, returnZeroFail(zeroOut));
     // emit the per-element guard keep-gate (#108). `il` = indent, `elemVar` = the over element loop var.
     // On skip: batched → `continue` (element excluded from items + keptOver); non-batched → `continue`.
     const emitGuard = (il, elemVar) => {
@@ -1447,9 +1696,9 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, f
     };
     if (batched) {
         // BATCHED (#86 pt2 into / #93 shape 3 no-into / #108 guarded no-into): build kept-element ports,
-        // dispatch ONCE. The concrete Node_* returns RawRow{IsError,Err,Rows []RawElem} aligned to items.
+        // dispatch ONCE. The concrete Node_* returns the aligned per-element WIRES ([]WireValue) or an error.
         // With a guard, `items` (and, for into, `keptOver`) hold only kept elements — matching run_behavior's
-        // keptIdx-aligned batch. `into` is never combined with a guard (rejected). no-into collects each row.
+        // keptIdx-aligned batch. `into` is never combined with a guard (rejected). Each wire is de-boxed inline.
         lines.push(`${indent}items_${s} := make([]${structName}, 0, len(over_${s}))`);
         if (hasInto)
             lines.push(`${indent}keptOver_${s} := make([]${overElemGo}, 0, len(over_${s}))`);
@@ -1465,22 +1714,24 @@ 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}`);
+        lines.push(`${indent}\tif len(mo_${s}) != len(items_${s}) {`, `${indent}\t\treturn ${zeroOut}, ${goErr("MAP_BATCH_RESULT_MISMATCH", `fmt.Sprintf("map '${node.id}': batched handler must return a list aligned to items (want %d)", len(items_${s}))`)}`, `${indent}\t}`);
         if (hasInto) {
-            // #86 pt2: zip-attach the into field onto each kept over element (augmented element copier).
+            // #86 pt2: de-box each aligned element wire (into the `into` field's type), then zip-attach onto the
+            // kept over element (augmented element copier).
             lines.push(`${indent}\tfor mk_${s} := range keptOver_${s} {`);
-            lines.push(`${indent}\t\tel_${s} := ${elemMat}(keptOver_${s}[mk_${s}], mo_${s}.Rows[mk_${s}])`);
+            lines.push(`${indent}\t\tvar dec_${s} ${elemRowGo}`);
+            lines.push(renderElemDeBox(`dec_${s}`, `mo_${s}[mk_${s}]`, `${indent}\t\t`));
+            lines.push(`${indent}\t\tel_${s} := ${elemMat}(keptOver_${s}[mk_${s}], dec_${s})`);
             lines.push(`${indent}\t\t${typedLocal(node.id)} = append(${typedLocal(node.id)}, el_${s})`);
             lines.push(`${indent}\t}`);
         }
         else {
-            // #93 shape 3 / #108: collect each element DIRECTLY from the aligned per-element row (field copy).
-            lines.push(`${indent}\tfor mk_${s} := range mo_${s}.Rows {`);
+            // #93 shape 3 / #108: de-box each aligned per-element wire DIRECTLY into the element (result = kept).
+            lines.push(`${indent}\tfor mk_${s} := 0; mk_${s} < len(mo_${s}); mk_${s}++ {`);
             lines.push(`${indent}\t\tvar el_${s} ${renderTypeRef(arrRef.elem)}`);
-            lines.push(emitRowCopy(`el_${s}`, `mo_${s}.Rows[mk_${s}]`, elemRowRef, plan, indent.length + 2));
+            lines.push(renderElemDeBox(`el_${s}`, `mo_${s}[mk_${s}]`, `${indent}\t\t`));
             lines.push(`${indent}\t\t${typedLocal(node.id)} = append(${typedLocal(node.id)}, el_${s})`);
             lines.push(`${indent}\t}`);
         }
@@ -1489,7 +1740,7 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, f
     else {
         // #93 shape 2 / #108: NON-batched map — dispatch the child handler ONCE PER KEPT ELEMENT (N physical
         // requests, matching run_behavior's per-element loop). A guarded element that fails `when` is skipped
-        // (no dispatch, excluded from the result). The concrete Node_* returns ONE RawElem_.
+        // (no dispatch, excluded from the result). The concrete Node_* returns ONE element WIRE (WireValue).
         lines.push(`${indent}for mk_${s} := range over_${s} {`);
         lines.push(`${indent}\t${elemLocal(s)} := over_${s}[mk_${s}]`);
         for (const l of emitGuard(indent + "\t", elemLocal(s)))
@@ -1499,15 +1750,27 @@ 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}`);
+        }
+        // the element's wire is de-boxed strictly INLINE. A de-box mismatch fails closed regardless of
+        // elementPolicy (≡ the interpreter's whole-node outType throw); elementPolicy governs the handler's
+        // own leaf failures only (above).
         if (hasInto) {
-            lines.push(`${indent}\tel_${s} := ${elemMat}(${elemLocal(s)}, mo_${s})`);
+            lines.push(`${indent}\tvar dec_${s} ${elemRowGo}`);
+            lines.push(renderElemDeBox(`dec_${s}`, `mo_${s}`, `${indent}\t`));
+            lines.push(`${indent}\tel_${s} := ${elemMat}(${elemLocal(s)}, dec_${s})`);
         }
         else {
             lines.push(`${indent}\tvar el_${s} ${renderTypeRef(arrRef.elem)}`);
-            lines.push(emitRowCopy(`el_${s}`, `mo_${s}`, elemRowRef, plan, indent.length + 1));
+            lines.push(renderElemDeBox(`el_${s}`, `mo_${s}`, `${indent}\t`));
         }
         lines.push(`${indent}\t${typedLocal(node.id)} = append(${typedLocal(node.id)}, el_${s})`);
         lines.push(`${indent}}`);
@@ -1578,19 +1841,22 @@ 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 handler returns the aligned per-id element WIRES (one nilable WireValue per id); each present
+    // body is de-boxed strictly INLINE (a de-box mismatch fails closed). A DANGLING id is a nil wire → the
+    // zero element (empty dedupeKey), which the dangling drop below excludes.
+    lines.push(`${indent}\tfo_${s}, fo_${s}Err := handlers.${nodeMethodName(comp.name, node.id)}(bp_${s}, nil)`);
+    lines.push(`${indent}\tif fo_${s}Err != nil {`, `${indent}\t\treturn ${zeroOut}, opFailed(${JSON.stringify(node.id)}, "fail", fo_${s}Err)`, `${indent}\t}`);
+    lines.push(`${indent}\tif len(fo_${s}) != len(pi_${s}) {`, `${indent}\t\treturn ${zeroOut}, ${goErr("FANOUT_BATCH_RESULT_MISMATCH", `fmt.Sprintf("fanout '${node.id}': batched handler must return a list aligned to the deduped id list (want %d)", len(pi_${s}))`)}`, `${indent}\t}`);
     // ── 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(renderResultDeBox(elemRef, `el_${s}`, `(*fo_${s}[fi_${s}])`, node.id, plan, `${indent}\t\t\t`, returnZeroFail(zeroOut)));
+    lines.push(`${indent}\t\t}`);
     lines.push(`${indent}\t\tkey_${s} := el_${s}.${dkGo}`);
     if (f.drop === "dangling") {
         // dangling: a body whose dedupeKey is the zero value (empty string) is dropped.
@@ -1609,15 +1875,12 @@ function emitFanoutArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut
         lines.push(c);
     return lines.join("\n");
 }
-/**
- * goInputHeadRef (#108) — resolve an INPUT port head for a native-expr ref (cond `if` / map `when` /
- * branches / an opt-lane port). The port's declared type comes from the shared `inputPortTypeRef` SSoT,
- * so an OPTIONAL port resolves as `{opt:…}` (native `*T`) and the compiler can see its optionality: a
- * null-compare becomes a real presence test and a coalesce a real deref-or-default, while a
- * REQUIRED-scalar slot fed by an opt fails closed. Go values are read directly off the input struct (no
- * ownership ceremony); a type with no native lowering → null (fail-closed).
- */
+/** #108: resolve an INPUT port head for a native-expr ref (cond `if` / map `when` / branches). A scalar
+ * port → `in.<Field>` of the scalar type; an array port WITH elemType → `in.<Field>` of `[]ElemT` (so
+ * `len(in.<Field>)` works); anything else → null (fail-closed). */
 function goInputHeadRef(head, comp, plan) {
+    // #139: the port's declared type comes from the inputPortTypeRef SSoT, so an OPTIONAL port resolves as
+    // {opt:…} (native *T) and the compiler sees its optionality; a type with no native lowering → null.
     const ref = inputPortTypeRef(comp.inputPorts?.[head], plan);
     if (ref === undefined)
         return null;
@@ -1635,7 +1898,11 @@ function emitCondArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut)
     const c = node.cond;
     const s = sanitize(node.id);
     const priorHere = (head) => priorNodeAt(head, atPos);
-    const resolveHead = goNativeResolveHead(comp, plan, typedNodes, priorHere);
+    const resolveHead = (head) => {
+        if (priorHere(head))
+            return { expr: typedLocal(head), ref: typedNodes.get(head) };
+        return goInputHeadRef(head, comp, plan);
+    };
     const be = makeGoExprBackend(zeroOut, resolveHead, plan);
     const compiler = new NativeExprCompiler(be);
     const cond = compiler.compileBool(c.if);
@@ -1866,14 +2133,11 @@ function makeGoExprBackend(zeroOut, resolveHead, plan) {
         // opt (`*T`) null-presence test: present = `(expr != nil)`, absent = `(expr == nil)`.
         optIsSome: (expr) => `(${expr} != nil)`,
         optIsNone: (expr) => `(${expr} == nil)`,
-        // opt (`*T`) defaulted to a PURE default. Go has no `unwrap_or`, so this is the same immediately-
-        // invoked func literal the `ternary` rendering uses (the established shape in this emitter): bind the
-        // pointer ONCE, deref it when present, else yield the default. The default sits in the else branch,
-        // so it is evaluated only when absent — run_behavior's lazy right side exactly.
+        // opt (`*T`) defaulted to a PURE default — an immediately-invoked func literal: bind the pointer ONCE,
+        // deref when present, else yield the default (evaluated only when absent — run_behavior's lazy right).
         optUnwrapOr: (optExpr, defaultExpr, innerTy) => `func() ${innerTy} { if v := ${optExpr}; v != nil { return *v }; return ${defaultExpr} }()`,
-        // opt defaulted to a FALLIBLE default — a statement if/else, NOT a func literal: the default's
-        // hoisted `return zeroOut, err` early returns must leave the ENCLOSING fn, which a func literal
-        // would swallow (it would return from the literal). Only the nil branch evaluates the default.
+        // opt defaulted to a FALLIBLE default — a statement if/else (NOT a func literal): the default's hoisted
+        // `return zeroOut, err` early returns must leave the ENCLOSING fn. Only the nil branch evaluates it.
         optCoalesceGuard: (temp, ty, optExpr, bindTemp, dStmts, dExpr) => [
             `var ${temp} ${ty}`,
             `if ${bindTemp} := ${optExpr}; ${bindTemp} != nil {`,
@@ -2037,17 +2301,23 @@ 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, wireImport) {
     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)
         imports.push(`\t"sync"`);
+    // a configured consumer wire package (goWire.import) — the covered module references its CONCRETE
+    // WireValue/WireRow/WireList types (default: in-package, no import).
+    if (wireImport !== undefined)
+        imports.push(`\t${JSON.stringify(wireImport)}`);
     const importBlock = imports.length > 0 ? `\nimport (\n${imports.join("\n")}\n)\n` : "";
     return `// GENERATED by behavior-contracts (bc#90, go-typed-native — the RUNTIME-FREE covered read de-box) — DO NOT EDIT.
 // Input: portable component-graph IR only. Every component here is a COVERED READ (sequential typed
@@ -2063,29 +2333,33 @@ var ExpectedSpecVersions = map[string]int64{"behavior": ${sv.behavior}, "express
 }
 // ── module assembly ──────────────────────────────────────────────────────────────────
 function emit(ctx) {
-    // The type plan is the SSoT the coverage gate + the port lowering both read (the gate ASKS the port
-    // lowering whether a port lowers), so it is built up-front — before the coverage checks.
-    const plan = buildTypePlan(ctx.ir);
     // Fail closed if a covered read SHAPE lacks the typed annotations (no silent re-box).
     for (const c of ctx.ir.components)
-        assertTypedCoverage(c, plan);
-    const native = ctx.ir.components.filter((c) => isNativeRaw(c, plan));
-    const nonNative = ctx.ir.components.filter((c) => !isNativeRaw(c, plan));
+        assertTypedCoverage(c);
+    const native = ctx.ir.components.filter(isNativeRaw);
+    const nonNative = ctx.ir.components.filter((c) => !isNativeRaw(c));
+    const plan = buildTypePlan(ctx.ir);
     const decls = emitTypeDecls(plan);
     // #108: reset the native-expr helper-usage accumulator (set by the cond/guard compiler when it emits
     // a fallible checked-arith helper call — determines whether the helper library + `math` import ship).
     goExprUsed.helpers = false;
+    const wire = resolveGoWire(ctx);
     // Emit the runners first so the nv* helper usage flags are known.
     const flags = { bind: false, field: false, cat: false, arr: false };
     const structs = [];
     const inStructs = [];
-    const rowStructs = [];
-    const handlerIfaces = [];
     const elemCopiers = [];
     const runnerCodes = [];
+    // every covered node returns a WireValue the inline de-box classifies — the wire seam (probe kind
+    // consts + probe RESULT structs) is emitted once whenever any handler node exists.
+    const anyWire = native.some((c) => c.body.some((n) => !("cond" in n)));
     for (const c of native) {
         inStructs.push(emitInStruct(c, plan));
-        const typedNodes = buildTypedNodes(c, plan);
+        const typedNodes = new Map();
+        // build the full typed-node map FIRST so a map's over-element resolution can see every node.
+        for (const n of c.body)
+            if (!isControlGate(n))
+                typedNodes.set(n.id, "map" in n ? mapNodeArrRef(n, plan) : deriveTypeRef(n.outType, plan)); // #125: control-gate typeless; map は produced-array ref に正規化
         for (const n of c.body) {
             if ("fanout" in n) {
                 // v3: a fanout node emits a per-id element ports struct + a batch struct (like a batched map).
@@ -2101,17 +2375,14 @@ function emit(ctx) {
             }
             else {
                 // #129: pass typedNodes so a leaf array port fed by a prior node's arr outType types as []ElemT.
-                structs.push(emitPortsStruct(c, n, plan, typedNodes));
+                structs.push(emitPortsStruct(c, n, undefined, plan, typedNodes));
             }
         }
-        // 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));
-        // augmented-element copiers for covered map...into nodes (over fields + concrete into row).
+        // augmented-element copiers for covered map...into nodes (over fields + the de-boxed into value).
         const mm = emitMapElemMaterializers(c, typedNodes, plan);
         if (mm)
             elemCopiers.push(mm);
-        const r = emitNativeRawRunner(c, plan, flags);
+        const r = emitNativeRawRunner(c, plan, flags, wire);
         runnerCodes.push(r.code);
     }
     const structSurface = emitStructSurface(native);
@@ -2130,7 +2401,7 @@ function emit(ctx) {
     // minimal, runtime-free header.
     if (nonNative.length > 0) {
         const rejects = nonNative
-            .map((c) => `  - component '${c.name}': ${coverageRejectReason(c, plan) ?? "not a covered native read"}`)
+            .map((c) => `  - component '${c.name}': ${coverageRejectReason(c) ?? "not a covered native read"}`)
             .join("\n");
         throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go typed-native (native codegen) surface: ${nonNative.length} component(s) are NOT a covered native read:\n${rejects}\n\n` +
             `The --typed-native (native codegen) surface is native-only and fail-closed: it does not silently ` +
@@ -2140,30 +2411,32 @@ 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 inline de-box parses a numeric field (int/float range check).
+    const needStrconv = runnerCodes.some((c) => c.includes("strconv."));
+    const header = emitMinimalHeader(ctx, false, needSync, needFmt, needMath, needStrconv, wire.import);
     const banner = `// COMBINED READ layer (bc#90 — the RUNTIME-FREE read de-box; STRUCT-ONLY, FULLY-NATIVE surface). A
 // covered read is a strictly-sequential typed componentRef chain (point reads + relationKind:single
 // children), emitted ONLY here: each node builds a native ports struct by direct field assignment (every
 // port is a CONCRETE Go value — string / bool / []string projection / int64 limit — NO boxed Value, NO
-// PortReader accessor); the CONCRETE per-component handler interface (Handler_<comp>) takes a typed
-// produced-aware 'bound' pointer and returns a CONCRETE per-node row struct (Row_<comp>_<node>, typed
-// fields = the node's outType) whose fields the runner reads DIRECTLY and copies into the node's outType
-// struct. The covered plane carries NO bc-runtime reference at all — failures use the LOCAL
-// *BehaviorError (same codes, byte-equal to run_behavior). Exec is INLINE sequential (no plan driver) so
-// a relation child reads the parent's REAL struct result via direct field access and the child-present
+// PortReader accessor); the runner takes the consumer's CONCRETE Handler_<comp> handler by
+// value and calls h.Node_*(...) DIRECTLY (no interface, no generics — zero dynamic dispatch). Each Node_*
+// takes a typed produced-aware 'bound' pointer and returns the node's result WIRE (a single ${wire.value});
+// the runner de-boxes it INLINE (fully-unrolled probe/match — no decode helper, no output recursion) into
+// the node's outType struct. The covered plane carries NO bc-runtime reference at all — failures use the
+// LOCAL *BehaviorError (same codes, byte-equal to run_behavior). Exec is INLINE sequential (no plan driver)
+// so a relation child reads the parent's REAL struct result via direct field access and the child-present
 // decision is made from the real parent value — relationSingle / connection converge with run_behavior
-// (fixes #323/#74). The exposed API is the STRUCT-returning RunNativeRawStruct_<comp> (the consumer
-// keeps the model native — no serialization on the read hot path). This module is FULLY NATIVE: a naive
-// grep for boxing primitives OR for the bc-runtime package finds nothing, by design (bc#90/runtime-free).`;
+// (fixes #323/#74). The exposed API is the STRUCT-returning RunNativeRawStruct_<comp> (the consumer keeps
+// the model native — no serialization on the read hot path). This module is FULLY NATIVE: a naive grep for
+// boxing primitives OR for the bc-runtime package finds nothing, by design (bc#90/runtime-free).`;
     const sections = [
         banner,
         `// Local concrete failure type (runtime-free) — a covered runner returns *BehaviorError (satisfies\n// error) instead of a bc-runtime failure, so the fully-covered module imports ZERO bc runtime.\n${behaviorErrorType}`,
         decls ? `// Typed struct declarations (outType-derived; hash-dedup — shared type plan).\n${decls}` : undefined,
         `// Per-component CONCRETE input structs (fields = inputPorts; the consumer builds them natively —\n// no generic *Obj crosses the covered read boundary).\n${inStructs.join("\n\n")}`,
-        rowStructs.some((r) => r.trim().length > 0)
-            ? `// CONCRETE per-node handler-result row structs (typed fields = the node's outType; + error signal).\n${rowStructs.filter((r) => r.trim().length > 0).join("\n\n")}`
+        anyWire
+            ? `// strict de-box wire seam — the consumer supplies CONCRETE ${wire.value} / ${wire.row} / ${wire.list}\n// types (variant classification) and the runner classifies each node result against the STATICALLY\n// declared type via their methods; the generated INLINE de-box owns strictness (required/optional,\n// present/absent, error assembly, fail-closed). bc emits only the probe RESULT structs — concrete data,\n// no boxed Value, no interface, no dictionary crosses the seam.\n${emitProbeWireTypes(wire)}`
             : undefined,
-        `// Per-component CONCRETE handler interfaces (one typed Node_* method per covered node).\n${handlerIfaces.join("\n\n")}`,
         elemCopiers.length
             ? `// Augmented map-element copiers (over element fields + the concrete into row — pure assignment).\n${elemCopiers.join("\n\n")}`
             : undefined,
@@ -2188,8 +2461,8 @@ function emit(ctx) {
  */
 export function goTypedNativeObserve(ir, runtimeImport) {
     const components = ir.components;
+    const native = components.filter(isNativeRaw);
     const plan = buildTypePlan(ir);
-    const native = components.filter((c) => isNativeRaw(c, plan));
     const serializers = emitSerializers(plan);
     const marshallers = goTypedInternals.emitMarshallers(plan);
     const mustHelpers = emitMustHelpers(plan);
@@ -2203,27 +2476,215 @@ export function goTypedNativeObserve(ir, runtimeImport) {
         // decode the generic *Obj input into the CONCRETE In_<comp> struct (test glue — ONE decode at the
         // top, OUTSIDE the covered hot path; a REQUIRED declared input is present so an absent key is a
         // fail-closed decode error surfaced here, never on the native runner path).
-        return `\tif name == ${JSON.stringify(c.name)} {\n\t\tin, ierr := decode_${inStructName(c.name)}(input)\n\t\tif ierr != nil {\n\t\t\treturn nil, ierr\n\t\t}\n\t\ttv, err := ${runnerName(c.name)}(handlers, in)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\treturn ${ser}, nil\n\t}`;
+        return `\tif name == ${JSON.stringify(c.name)} {\n\t\tin, ierr := decode_${inStructName(c.name)}(input)\n\t\tif ierr != nil {\n\t\t\treturn nil, ierr\n\t\t}\n\t\ttv, err := ${runnerName(c.name)}(${handlerTypeName(c.name)}{handlers}, in)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\treturn ${ser}, nil\n\t}`;
     })
         .join("\n");
     // input decoders (TEST glue): generic *Obj -> concrete In_<comp>. Scalar fields read the typed value
     // (a `.(T)` here is on the SDK/wire Value in the OBSERVE companion, never in the covered module).
     const inDecoders = native.map((c) => emitInDecoder(c, plan)).join("\n\n");
-    // The observe companion drives EVERY covered component, so its handler type param H must satisfy
-    // EVERY per-component concrete Handler_<comp> interface — a combined constraint embeds them all.
-    const combinedConstraint = `allNativeRawHandlers`;
-    const constraintDecl = `// ${combinedConstraint} — the combined constraint embedding every covered component's concrete
-// handler interface, so one handler value drives all covered runners (test glue only).
-type ${combinedConstraint} interface {
-${native.map((c) => `\t${handlerIfaceName(c.name)}`).join("\n")}
-}`;
-    // ── concrete scripted adapter (TEST glue): implements every Node_* method by draining a per-
-    // COMPONENT scripted-outcome queue and DECODING the scripted ok Value into the CONCRETE row struct.
-    // This is where the generic scripted source (a Value queue) meets the concrete per-node seam: the
-    // decode is generated (it knows the concrete row type), so the runner stays fully concrete. ──
-    const decodeFns = [];
+    // every covered node returns a WireValue the inline de-box classifies — so the scripted wire adapter is
+    // needed whenever any component has a handler node.
+    const anyDeBox = native.some((c) => c.body.some((n) => !("cond" in n)));
+    // scripted wire adapter (TEST glue): wraps a scripted bc Value as the CONCRETE WireValue / WireRow /
+    // WireList (the in-package default seam types the covered module references) and classifies each datum's
+    // native type into a DynamoDB-flavored wire tag (S/N/BOOL/L/M/NULL). A real consumer supplies its OWN
+    // concrete WireValue over its AttributeValue payload; this exists only so the harness drives the
+    // generated inline de-box from the same scripted vectors run_behavior uses — so actualWireType observed
+    // in a mismatch is the PRODUCER tag (e.g. "N"), not the collapsed native type.
+    const wireAdapter = anyDeBox
+        ? `// ── scripted wire adapter (TEST glue) ──
+func scriptedWireTag(v ${PKG}.Value) string {
+	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: WireRow{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: WireList{items: a}, ActualWireType: "L"}
+	}
+	return ListProbe{Kind: probeWrong, ActualWireType: scriptedWireTag(v), Raw: scriptedWireRaw(v)}
+}
+
+// WireValue — the CONCRETE scripted node-result wire (the in-package default seam type the covered runner
+// classifies via As*). A top value is always present, so As* never observes Absent; a scripted null is a
+// nil Value → Null. A real consumer supplies its own concrete WireValue over its AttributeValue payload.
+type WireValue struct {
+	v ${PKG}.Value
+}
+
+func (w WireValue) AsString() StringProbe { return probeStringVal(w.v) }
+func (w WireValue) AsNumber() NumberProbe { return probeNumberVal(w.v) }
+func (w WireValue) AsBool() BoolProbe     { return probeBoolVal(w.v) }
+func (w WireValue) AsRow() RowProbe       { return probeRowVal(w.v) }
+func (w WireValue) AsList() ListProbe     { return probeListVal(w.v) }
+
+// WireRow / WireList — the CONCRETE scripted wire map / array (the in-package default seam types), probed
+// per declared field / element by the generated inline de-box (their methods return bc's probe structs).
+type WireRow struct {
+	obj *${PKG}.Obj
+}
+
+func (w WireRow) field(name string) (${PKG}.Value, bool) {
+	if w.obj == nil {
+		return nil, false
+	}
+	return w.obj.Get(name)
+}
+
+func (w WireRow) Keys() []string {
+	if w.obj == nil {
+		return nil
+	}
+	return w.obj.Keys
+}
+
+func (w WireRow) ProbeString(field string) StringProbe {
+	if v, ok := w.field(field); ok {
+		return probeStringVal(v)
+	}
+	return StringProbe{Kind: probeAbsent}
+}
+
+func (w WireRow) ProbeNumber(field string) NumberProbe {
+	if v, ok := w.field(field); ok {
+		return probeNumberVal(v)
+	}
+	return NumberProbe{Kind: probeAbsent}
+}
+
+func (w WireRow) ProbeBool(field string) BoolProbe {
+	if v, ok := w.field(field); ok {
+		return probeBoolVal(v)
+	}
+	return BoolProbe{Kind: probeAbsent}
+}
+
+func (w WireRow) ProbeRow(field string) RowProbe {
+	if v, ok := w.field(field); ok {
+		return probeRowVal(v)
+	}
+	return RowProbe{Kind: probeAbsent}
+}
+
+func (w WireRow) ProbeList(field string) ListProbe {
+	if v, ok := w.field(field); ok {
+		return probeListVal(v)
+	}
+	return ListProbe{Kind: probeAbsent}
+}
+
+type WireList struct {
+	items []${PKG}.Value
+}
+
+func (l WireList) Len() int                     { return len(l.items) }
+func (l WireList) ElemString(i int) StringProbe { return probeStringVal(l.items[i]) }
+func (l WireList) ElemNumber(i int) NumberProbe { return probeNumberVal(l.items[i]) }
+func (l WireList) ElemBool(i int) BoolProbe     { return probeBoolVal(l.items[i]) }
+func (l WireList) ElemRow(i int) RowProbe       { return probeRowVal(l.items[i]) }
+func (l WireList) ElemList(i int) ListProbe     { return probeListVal(l.items[i]) }
+
+// FailureDetail exposes the structured Error Value fields WITHOUT naming the local ErrorDetail type, so
+// the harness can assert the de-box's kind / field / expectedType / actualWireType / rawValue (TEST
+// 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
+}`
+        : "";
+    // Handler_<comp> wrapper types: the covered runner takes the CONCRETE per-component handler by value
+    // (non-generic). One scripted queue backs every component, so each Handler_<comp> embeds the shared
+    // *ScriptedNativeRaw — the Node_* methods (on *ScriptedNativeRaw) are promoted, so the runner's direct
+    // h.Node_*(...) call resolves to a concrete method (no interface, no dictionary). Test glue only.
+    const handlerWrappers = native
+        .map((c) => `// ${handlerTypeName(c.name)} — the CONCRETE handler the '${c.name}' runner takes by value (embeds the\n// shared scripted queue; the Node_* methods are promoted).\ntype ${handlerTypeName(c.name)} struct {\n\t*ScriptedNativeRaw\n}`)
+        .join("\n\n");
+    // ── concrete scripted adapter (TEST glue): implements every Node_* method by draining a per-COMPONENT
+    // scripted-outcome queue and returning the scripted ok Value wrapped as a WireValue (the generic
+    // scripted source — a Value queue — meets the uniform CONCRETE wire seam). ──
     const methodImpls = [];
-    const emittedDecode = new Set();
     for (const c of native) {
         const typedNodes = new Map();
         for (const n of c.body)
@@ -2234,113 +2695,117 @@ ${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).
+                // fanout: return the aligned per-id element WIRES ([]*WireValue); a null aligned body is a
+                // DANGLING id → nil (the covered runner maps it to the zero element).
                 const f = n.fanout;
-                const elemRowRef = fanoutItemsElemRef(n, ref, 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) {
+                methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, n.id)}(_ ${portsT}, _ ${foBoundT}) ([]*WireValue, error) {
 	src, ok := s.next(${JSON.stringify(f.component)})
 	if !ok {
-		return ${batchT}{}, false
+		return nil, unknownComponent(${JSON.stringify(f.component)})
 	}
 	if src.isErr {
-		return ${batchT}{IsError: true, Err: src.err}, true
+		return nil, leafFailure(src.err)
 	}
 	arr, _ := src.ok.([]${PKG}.Value)
-	rows := make([]${elemT}, 0, len(arr))
+	wires := make([]*WireValue, 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}{})
+			wires = append(wires, nil)
 			continue
 		}
-		rows = append(rows, ${elemDecode}(ev))
+		wv := WireValue{v: ev}
+		wires = append(wires, &wv)
 	}
-	return ${batchT}{Rows: rows}, true
+	return wires, nil
 }`);
                 continue;
             }
             if ("map" in n) {
+                // map: batched → one WIRE per element ([]WireValue); non-batched → one element WIRE (WireValue).
                 const m = n.map;
                 const batched = m.batched === true;
-                const arrRef = ref;
-                const elemRowRef = mapElemRowRef(n, arrRef, 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 (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}) ([]WireValue, error) {
 	src, ok := s.next(${JSON.stringify(m.component)})
 	if !ok {
-		return ${batchT}{}, false
+		return nil, unknownComponent(${JSON.stringify(m.component)})
 	}
 	if src.isErr {
-		return ${batchT}{IsError: true, Err: src.err}, true
+		return nil, leafFailure(src.err)
 	}
 	arr, _ := src.ok.([]${PKG}.Value)
-	rows := make([]${elemT}, 0, len(arr))
+	wires := make([]WireValue, 0, len(arr))
 	for _, ev := range arr {
-		rows = append(rows, ${elemDecode}(ev))
+		wires = append(wires, WireValue{v: ev})
 	}
-	return ${batchT}{Rows: rows}, true
+	return wires, 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}) (WireValue, error) {
 	src, ok := s.next(${JSON.stringify(m.component)})
 	if !ok {
-		return ${elemT}{}, false
+		return WireValue{}, unknownComponent(${JSON.stringify(m.component)})
 	}
 	if src.isErr {
-		return ${elemT}{IsError: true, Err: src.err}, true
+		return WireValue{}, leafFailure(src.err)
 	}
-	return ${elemDecode}(src.ok), true
+	return WireValue{v: src.ok}, nil
 }`);
                 }
-                void retT;
                 continue;
             }
+            // componentRef: return the whole result WIRE (one WireValue wrapping the scripted ok Value); the
+            // covered runner's INLINE de-box classifies it. A real consumer returns its own wire payload.
             const node = n;
-            const rowT = rawRowStructName(c.name, node.id);
-            const decode = emitDecodeRow(c.name, node.id, rowT, ref, plan, emittedDecode, decodeFns, "");
             const nodeBoundT = boundGoType(node, c, typedNodes, plan);
-            // #129 (TEST glue): support the reference scriptedHandlers' echo forms (PROTOCOL.md §3.5) — the
-            // adapter normalizes `{"echo":"port","port":"X"}` / `{"echo":"items"}` to the port NAME, and the
-            // scripted handler
-            // ECHOES a NATIVE port back as its result. This makes a port-plane pin non-vacuous: the node's
-            // observed result IS the native value that flowed into its ports struct, so a dropped / re-boxed /
-            // zero-defaulted port diverges from run_behavior instead of passing. A port is echoable when its
-            // native type IS the node's outType (that is exactly when the row's Val can hold it); `ports` is
-            // named only when at least one port qualifies (else the param stays `_` so a non-echo node
-            // compiles clean / unused-param-free).
-            const echoable = echoablePorts(c, node, ref, plan, typedNodes);
-            const portsParam = echoable.length > 0 ? "ports" : "_";
-            // a NAMED outType row is FLATTENED (no Val) — echo a named port by copying the struct's fields;
-            // a scalar/arr/opt outType row holds the port in its single Val field.
-            const echoRow = (ep) => ref.kind === "named"
-                ? `${rowT}{${findDecl(plan, ref.name).fields.map((f) => `${goFieldName(f.name)}: ports.${goPortFieldName(ep)}.${goFieldName(f.name)}`).join(", ")}}`
-                : `${rowT}{Val: ports.${goPortFieldName(ep)}}`;
-            const echoBranch = echoable
-                .map((ep) => `\tif src.echo == ${JSON.stringify(ep)} {\n\t\treturn ${echoRow(ep)}, true\n\t}\n`)
-                .join("");
-            methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, node.id)}(${portsParam} ${portsStructName(c.name, node.id)}, _ ${nodeBoundT}) (${rowT}, bool) {
+            // echo (#129/#141 fixtures): the scripted leaf can ECHO an input PORT back as its result wire, so the
+            // input-port value flows into the de-boxed result and the runtime non-vacuity asserts survive.
+            const echoBranches = [];
+            if (ref.kind === "named") {
+                const decl = findDecl(plan, ref.name);
+                const field = decl !== undefined && decl.fields.length === 1 ? decl.fields[0] : undefined;
+                const fieldGo = field !== undefined ? renderTypeRef(field.type) : null;
+                const recordGo = renderTypeRef(ref);
+                for (const pn of Object.keys(node.ports)) {
+                    let portGo = null;
+                    try {
+                        portGo = portFieldGoType(node.ports[pn], c, plan, typedNodes, `echo port '${pn}'`);
+                    }
+                    catch {
+                        portGo = null;
+                    }
+                    if (portGo === recordGo) {
+                        // the port IS the whole record → echo it DIRECTLY (matching run_behavior's plain echo:port).
+                        echoBranches.push(`\tif src.echo == ${JSON.stringify(pn)} {\n\t\treturn WireValue{v: ${serializeTyped(`ports.${goPortFieldName(pn)}`, ref, plan)}}, nil\n\t}`);
+                    }
+                    else if (fieldGo !== null && field !== undefined && portGo === fieldGo) {
+                        // a scalar port wraps into the record's single field ({v: ports.X}).
+                        echoBranches.push(`\tif src.echo == ${JSON.stringify(pn)} {\n\t\treturn WireValue{v: ${serializeTyped(`${recordGo}{${goFieldName(field.name)}: ports.${goPortFieldName(pn)}}`, ref, plan)}}, nil\n\t}`);
+                    }
+                }
+            }
+            else if (ref.kind === "arr" && Object.prototype.hasOwnProperty.call(node.ports, "items")) {
+                // #129: an arr node with an `items` port echoes the NATIVE port array (serialized to a Value array)
+                // so the node→leaf array dataflow test is non-vacuous.
+                echoBranches.push(`\tif src.echo == "items" {\n\t\treturn WireValue{v: ${serializeTyped(`ports.${goPortFieldName("items")}`, ref, plan)}}, nil\n\t}`);
+            }
+            const canEcho = echoBranches.length > 0;
+            const portsParam = canEcho ? "ports" : "_";
+            const echoBlock = canEcho ? `${echoBranches.join("\n")}\n` : "";
+            methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, node.id)}(${portsParam} ${portsStructName(c.name, node.id)}, _ ${nodeBoundT}) (WireValue, error) {
 	src, ok := s.next(${JSON.stringify(node.component)})
 	if !ok {
-		return ${rowT}{}, false
+		return WireValue{}, unknownComponent(${JSON.stringify(node.component)})
 	}
 	if src.isErr {
-		return ${rowT}{IsError: true, Err: src.err}, true
+		return WireValue{}, leafFailure(src.err)
 	}
-${echoBranch}	return ${decode}(src.ok), true
+${echoBlock}	return WireValue{v: src.ok}, nil
 }`);
         }
     }
@@ -2355,10 +2820,10 @@ type scriptSrc struct {
 	ok    ${PKG}.Value
 }
 
-// ScriptedNativeRaw — the CONCRETE test handler: it satisfies every Handler_<comp> interface by
-// draining a per-COMPONENT scripted queue and decoding the ok Value into the concrete row struct.
-// The decode (decodeRow_*) is generated, so the covered runner drives fully-concrete Node_* methods.
-// EXPORTED so the runner glue (a separate package) can name it for the generic instantiation.
+// ScriptedNativeRaw — the CONCRETE test handler: its Node_* methods drain a per-COMPONENT scripted queue
+// and return the ok Value wrapped as a WireValue (the covered runner de-boxes it inline). Each runner
+// takes a Handler_<comp> value that embeds this, so the Node_* calls stay fully concrete (no interface).
+// EXPORTED so the runner glue (a separate package) can name it.
 type ScriptedNativeRaw struct {
 	mu     sync.Mutex
 	queues map[string][]scriptSrc
@@ -2383,15 +2848,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)
 						}
@@ -2434,86 +2897,52 @@ func (s *ScriptedNativeRaw) next(component string) (scriptSrc, bool) {
 }`;
     return `// GENERATED test-only observe companion (bc#77) — NOT part of the covered module. Serializes the
 // struct-native runner's result to a canonical Value for the equivalence pin, and carries the CONCRETE
-// scripted test handler (scriptedNativeRaw) that satisfies every Handler_<comp> interface by decoding a
-// scripted Value into the concrete per-node row. The consumer never uses this (it keeps the model
-// native + implements Handler_<comp> over its own wire payload); it exists only so the test harness can
-// byte-compare the STRUCT-only covered read against run_behavior. Same package as the covered module.
+// scripted test handler (ScriptedNativeRaw) + the CONCRETE WireValue/WireRow/WireList seam types +
+// per-component Handler_<comp> wrappers the runner takes. The consumer never uses this (it keeps the
+// model native + supplies its own concrete WireValue + Handler_<comp>); it exists only so the test
+// harness can byte-compare the STRUCT-only covered read against run_behavior. Same package as the module.
 package behaviors
 
 import (
-	"sync"
+${anyDeBox ? '\t"strconv"\n\n' : ""}	"sync"
 
 	${PKG} "${runtimeImport ?? "github.com/foo-ogawa/behavior-contracts/go"}"
 )
 
+// scripted wire adapter (TEST glue) — the CONCRETE WireValue/WireRow/WireList the covered module references.
+${wireAdapter}
+
 // typed -> Value serializers (TEST glue only — the covered module has none).
 ${serializers}
 
-// Value -> typed struct marshallers (+ must* helpers) for the concrete-row decode (TEST glue only).
+// Value -> typed struct marshallers (+ must* helpers) for the input decoders (TEST glue only).
 ${marshallers}
 
 ${mustHelpers}
 
 ${arrOptHelpers}
 
-// per-node concrete-row decoders (scripted Value -> RawRow_/RawElem_ struct).
-${decodeFns.join("\n\n")}
-
 // input decoders (generic *Obj -> concrete In_<comp>; TEST glue, one decode at the observe boundary).
 ${inDecoders}
 
 ${adapter}
 
-${constraintDecl}
+// per-component CONCRETE handler wrappers (the runner takes one by value — embeds the shared queue).
+${handlerWrappers}
 
-// scriptedNativeRaw method impls (one per covered node — the concrete Node_* seam, test glue).
+// ScriptedNativeRaw method impls (one per covered node — the concrete Node_* seam returning WireValue).
 ${methodImpls.join("\n\n")}
 
-// ObserveNativeRaw drives the struct-native runner and serializes to a canonical Value (test only).
-// GENERIC over the CONCRETE combined handler type H — so each enclosed RunNativeRawStruct_* call is
-// instantiated at the concrete handler type (direct, devirtualized per-node method calls), not at an
-// interface. Instantiate with your concrete handler type to preserve the covered path's concreteness.
-func ObserveNativeRaw[H ${combinedConstraint}](name string, handlers H, input *${PKG}.Obj) (${PKG}.Value, error) {
+// ObserveNativeRaw drives the struct-native runner and serializes to a canonical Value (test only). It
+// takes the CONCRETE *ScriptedNativeRaw and wraps it per component in the runner's Handler_<comp> value —
+// each enclosed RunNativeRawStruct_* call is a NON-generic call over a concrete handler (direct,
+// devirtualized per-node method calls), never an interface or a generic dictionary.
+func ObserveNativeRaw(name string, handlers *ScriptedNativeRaw, input *${PKG}.Obj) (${PKG}.Value, error) {
 ${arms}
 	return nil, ${PKG}.NewBehaviorFailure("UNKNOWN_ENTRY", "component '"+name+"' is not a covered read (fail-closed)")
 }
 `;
 }
-/** echoablePorts (TEST glue) — the node's ports whose NATIVE type is exactly the node's outType, in
- * declaration order. Those are the ports a scripted `echo: "<port>"` can return as the row (a scalar/arr/
- * opt row via its Val; a NAMED row via its flattened fields copied from the struct port). A port with a
- * different type is not echoable (the row could not hold it). */
-function echoablePorts(comp, node, ref, plan, typedNodes) {
-    const want = renderTypeRef(ref);
-    return Object.keys(node.ports).filter((p) => portFieldGoType(node.ports[p], comp, plan, typedNodes, `port '${p}'`) === want);
-}
-/** emitDecodeRow — emit (once, deduped) a decoder `decodeRow_<comp>_<node><suffix>(v Value) <rowT>`
- * that materializes the scripted ok Value into the concrete row struct (typed fields = the outType /
- * elem-row type). Named: reuse the Value->struct marshaller + copy fields; scalar/arr/opt: materialize
- * into .Val. TEST glue only (the production consumer decodes its own wire payload). */
-function emitDecodeRow(compName, nodeId, rowT, ref, plan, emitted, out, suffix) {
-    const fn = `decodeRow_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}${suffix}`;
-    if (emitted.has(fn))
-        return fn;
-    emitted.add(fn);
-    const lines = [];
-    lines.push(`func ${fn}(v ${PKG}.Value) ${rowT} {`);
-    lines.push(`\tvar out ${rowT}`);
-    if (ref.kind === "named") {
-        const decl = findDecl(plan, ref.name);
-        lines.push(`\tt := ${goTypedInternals.materializeExpr("v", ref, plan)}`);
-        for (const f of decl.fields) {
-            lines.push(`\tout.${goFieldName(f.name)} = t.${goFieldName(f.name)}`);
-        }
-    }
-    else {
-        lines.push(`\tout.Val = ${goTypedInternals.materializeExpr("v", ref, plan)}`);
-    }
-    lines.push(`\treturn out`);
-    lines.push(`}`);
-    out.push(lines.join("\n"));
-    return fn;
-}
 /**
  * goTypedNativeEmitter — language id `go-typed-native` (bc#77). Emits the generic straight-line
  * body (for non-covered components / helpers) plus the COMBINED READ layer (native ports struct