behavior-contracts 0.4.0 → 0.6.0

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

@@ -0,0 +1,2260 @@
+import { GeneratorFailure } from "./core.js";
+import { goStraightlineInternals } from "./emit-shared-go.js";
+import { goTypedInternals } from "./emit-shared-go-typed.js";
+import { buildTypePlan, deriveTypeRef, findDecl } from "./typed.js";
+import { concurrencyPlan, execPlan, analyzeSequentialOps, classifyExpr, buildComponentPlan, } from "./straightline.js";
+import { NativeExprCompiler } from "./native-expr.js";
+const PKG = "dslcontracts";
+/** 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
+ * the old `dslcontracts.NewBehaviorFailure`/`NewPlanFailure` (the last error-plane runtime coupling) —
+ * the SAME codes are preserved verbatim so the observed failure is byte-equal to run_behavior. */
+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`. */
+function emitBehaviorErrorType() {
+    return `// 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).
+type BehaviorError struct {
+	Code    string
+	Message string
+}
+
+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 }`;
+}
+const { sanitize, emitExpr } = goStraightlineInternals;
+const { goFieldName, renderTypeRef, goScalar, serializeTyped, emitTypeDecls, emitSerializers, emitTypedValue, emitMustHelpers, } = goTypedInternals;
+/** typed node-result local — MUST match goTypedInternals.typedLocal (`t_<id>`) so the reused
+ * emitTypedValue (output assembly via struct field access) reads the same locals. */
+function typedLocal(nodeId) {
+    return `t_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
+}
+function goPortFieldName(wire) {
+    const safe = wire.replace(/[^A-Za-z0-9_]/g, "_");
+    const head = safe.charAt(0);
+    return /[a-z]/.test(head) ? head.toUpperCase() + safe.slice(1) : "F_" + safe;
+}
+function portsStructName(compName, nodeId) {
+    // EXPORTED so a consumer (and the test bench, both in a DIFFERENT Go package) can name the ports
+    // type to implement the per-component Handler_<comp> interface's concrete Node_* method signatures.
+    return `PortsNR_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
+}
+function inferPortType(node, inputPorts, asBinding) {
+    if (staticArrElems(node) !== null)
+        return "Value";
+    const e = classifyExpr(node);
+    switch (e.kind) {
+        case "str":
+        case "concat":
+            return "string";
+        case "bool":
+            return "bool";
+        case "ref": {
+            // #108: a `$as`-headed ref (map element binding) — resolve the element field's scalar type.
+            if (asBinding !== undefined && e.path[0] === asBinding.name) {
+                try {
+                    const { ref } = goTypedInternals.typedFieldAccess(asBinding.name, asBinding.ref, e.path.slice(1), asBinding.plan);
+                    if (ref.kind === "scalar" && ref.scalar !== "null")
+                        return goScalarPortField(ref.scalar);
+                }
+                catch {
+                    return "Value";
+                }
+                return "Value";
+            }
+            if (e.path.length === 1) {
+                const s = inputPorts[e.path[0]];
+                if (s) {
+                    if (s.type === "string")
+                        return "string";
+                    if (s.type === "int")
+                        return "int64";
+                    if (s.type === "float")
+                        return "float64";
+                    if (s.type === "bool")
+                        return "bool";
+                }
+            }
+            return "Value";
+        }
+        default:
+            return "Value";
+    }
+}
+/** scalar TypeRef → PortFieldType (native go scalar kind). */
+function goScalarPortField(scalar) {
+    return scalar === "string" ? "string" : scalar === "int" ? "int64" : scalar === "float" ? "float64" : "bool";
+}
+/** A static string-array port (every element a static string literal) — the graphddb `projection`
+ * shape. Returns the list of literal strings, or null when the node is not that shape. */
+function staticStringArrElems(node) {
+    const arr = staticArrElems(node);
+    if (arr === null)
+        return null;
+    const out = [];
+    for (const el of arr) {
+        const e = classifyExpr(el);
+        if (e.kind !== "str")
+            return null;
+        out.push(e.value);
+    }
+    return out;
+}
+/**
+ * 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, inputPorts, where = "port", asBinding) {
+    if (staticStringArrElems(node) !== null)
+        return "[]string";
+    const num = numLiteralGoExpr(node);
+    if (num !== null)
+        return Number.isInteger(node) ? "int64" : "float64";
+    const ft = inferPortType(node, inputPorts, asBinding);
+    if (ft === "Value") {
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go combined read (bc#90 / runtime-free): ${where} '${JSON.stringify(node)}' does not lower to a native Go type (would need a boxed dslcontracts.Value). The covered read plane is runtime-free and admits NO boxed escape — the covered corpus ports are string / bool / static-string-array (projection) / bare-number (limit) only. Regenerate on the boxed straight-line path if this port is genuinely dynamic.`);
+    }
+    return ft;
+}
+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. */
+function portIsStatic(node) {
+    const arr = staticArrElems(node);
+    if (arr !== null)
+        return arr.every(portIsStatic);
+    if (numLiteralGoExpr(node) !== null)
+        return true; // bare number literal (e.g. Query `limit`)
+    const e = classifyExpr(node);
+    switch (e.kind) {
+        case "str":
+        case "bool":
+        case "null":
+        case "ref":
+            return true;
+        case "concat":
+            return e.parts.every((p) => portIsStatic(reconstructG(p)));
+        default:
+            return false;
+    }
+}
+/** The output must lower to a typed struct/value with no Value-scope read: a ref whose head is a
+ * BODY NODE (typed), an obj/arr of native-lowerable outputs, or a concat of them. A ref to an
+ * input param or a non-concat operator is NOT native-lowerable here (falls through). */
+function outputIsNativeLowerable(comp) {
+    const bodyIds = new Set(comp.body.map((n) => n.id));
+    const walk = (node) => {
+        const arr = staticArrElems(node);
+        if (arr !== null)
+            return arr.every(walk);
+        if (node !== null && typeof node === "object" && !Array.isArray(node)) {
+            const keys = Object.keys(node);
+            if (keys.length === 1 && keys[0] === "obj") {
+                const obj = node.obj;
+                return Object.keys(obj).every((k) => walk(obj[k]));
+            }
+            if (keys.length === 1 && keys[0] === "arr")
+                return true; // handled by staticArrElems above
+        }
+        const e = classifyExpr(node);
+        if (e.kind === "str" || e.kind === "bool" || e.kind === "null")
+            return true;
+        // ref OR refOpt to a body node (typed). refOpt is how a produced-aware output reads a skippable
+        // relationSingle child: the head node's produced flag gates it, yielding opt-nil when unproduced.
+        if (e.kind === "ref")
+            return bodyIds.has(e.path[0]); // must ref a body node (typed), not input
+        if (e.kind === "concat")
+            return e.parts.every((p) => walk(reconstructG(p)));
+        return false;
+    };
+    return walk(comp.output);
+}
+/** A native-raw component MUST be fully typed (outType on every node + outputType). */
+function isFullyTyped(comp) {
+    if (comp.outputType === undefined)
+        return false;
+    for (const n of comp.body) {
+        if (n.outType === undefined)
+            return false;
+    }
+    return true;
+}
+function isNativeRaw(comp) {
+    return isSequentialComponentRefRead(comp) && isFullyTyped(comp);
+}
+/**
+ * coveredMapNode — the #86 part 2 covered map shape (nestedBatchGet). A BATCHED `map` node whose:
+ *   - over is a static ref (to a prior node's typed collection field OR an input array),
+ *   - `into` is set (zip-attach the batched handler result onto every over element),
+ *   - every element port is static (literal / ref into the element binding / concat / static arr),
+ *   - element outType is a NAMED struct (the augmented element type — over element + the into field),
+ *   - no `when` guard (guard+into => heterogeneous elements, not one []T — stays boxed),
+ *   - default 'fail' policy, relationKind single/connection or absent.
+ * This is the struct-native de-box of a typed `map...into` element collection: build the per-element
+ * native ports struct, dispatch the batched handler ONCE (RawValue out), and assemble each augmented
+ * 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) {
+    if (n === null || typeof n !== "object" || !("map" in n))
+        return false;
+    const m = n.map;
+    // #86 pt2: batched map...into. #93 shape 2/3: (non-)batched map...into / connection-collect. #108:
+    // a guarded map (`when`) IS covered when it has NO `into` (guard+into is heterogeneous — skipped
+    // elements lack the into field, cannot de-box into one []T; keep it fail-closed, matching the typed
+    // straightline reject). A guarded map over a native-typed element collection drops skipped elements.
+    if (m.when !== undefined && m.into !== undefined)
+        return false;
+    if (m.policy !== undefined && m.policy !== "fail")
+        return false;
+    if (m.relationKind !== undefined && m.relationKind !== "single" && m.relationKind !== "connection")
+        return false;
+    // `over` element type must be STATICALLY resolvable: a ref to a PRIOR BODY NODE's typed arr field
+    // (mapOverElemType) OR a ref to an INPUT array port that carries `elemType` (#108 — the C3 "BC does
+    // not infer" rule: an input array WITHOUT elemType stays fail-closed / uncovered).
+    const overE = classifyExpr(m.over);
+    if (overE.kind !== "ref")
+        return false;
+    const head = overE.path[0];
+    if (!bodyIds.has(head)) {
+        // input-array over: covered only when the input port declares elemType (#108).
+        if (overE.path.length !== 1)
+            return false;
+        const schema = comp.inputPorts?.[head];
+        if (schema === undefined || schema.elemType === undefined)
+            return false;
+    }
+    const ports = m.ports;
+    for (const p of Object.keys(ports))
+        if (!portIsStatic(ports[p]))
+            return false;
+    return true;
+}
+/** A covered read SHAPE (typing-independent) — sequential componentRef reads + covered map...into,
+ * OR a real-concurrency staged plan (bc#87) whose parallel-stage members are plain componentRef point
+ * 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) {
+    return coverageRejectReason(comp) === null;
+}
+/**
+ * coverageRejectReason — the DIAGNOSTIC twin of isSequentialComponentRefRead (bc#86/#89). Returns
+ * null when the component IS a covered native read; otherwise a SPECIFIC human-readable reason naming
+ * the exact disqualifier and the offending node id. The predicate logic is IDENTICAL to
+ * isSequentialComponentRefRead (which is defined as `coverageRejectReason(c) === null`) so the two can
+ * 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) {
+    const ep = execPlan(comp);
+    if (ep === null)
+        return "component is not a straight-line/staged sequential exec plan (no static exec plan)";
+    // A parallel-stage member must be a plain componentRef point read (no map, no bindField) so the
+    // static parallel orchestration is a clean fan-out — the bounded-concurrency error-precedence
+    // protocol is proven for that shape. A map / bindField child inside a parallel stage falls through.
+    for (const [i] of ep.parallelStageOf) {
+        const n = comp.body[i];
+        if (!("component" in n))
+            return `node '${n.id}' is a non-componentRef member of a parallel stage (not native-covered)`;
+        if (n.bindField !== undefined)
+            return `node '${n.id}' is a bindField relation child inside a parallel stage (not native-covered)`;
+    }
+    const bodyIds = new Set(comp.body.map((b) => b.id));
+    for (const n of comp.body) {
+        if ("cond" in n) {
+            // #108: a cond node is native-covered — its `if`/`then`/`else` compile to native expressions via
+            // the runtime-free NativeExprCompiler (byte-equal to run_behavior's cond lower). If an expression
+            // is not statically compilable (uncovered op / refOpt / opt operand / type mismatch), the compiler
+            // fails closed at emit (a loud GeneratorFailure) — never a silent box. cond requires outType.
+            if (n.outType === undefined)
+                return `node '${n.id}' cond has no outType (required to de-box the branch join)`;
+            continue;
+        }
+        if ("map" in n) {
+            // #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))
+                return `node '${n.id}' is a non-covered map shape (guard+into heterogeneous, or over an input array without elemType)`;
+            continue;
+        }
+        if (!("component" in n))
+            return `node '${n.id}' is not a componentRef, map, or cond node (not native-covered)`;
+        const cr = n;
+        // Only default 'fail' policy on covered reads: 'continue' (and any skip source, incl. bindField)
+        // makes a node UNPRODUCED at runtime, whose output ref must yield the unproduced rep — a
+        // produced-aware output lowering the struct-only path does not do yet (documented follow-up).
+        // Such components fall through to the boxed typed / straight-line path (correct, just not
+        // struct-de-plumbed). relationKind:single WITHOUT bindField (the #74/#323 core) IS covered.
+        if (cr.policy !== undefined && cr.policy !== "fail")
+            return `node '${n.id}' componentRef policy '${cr.policy}' (produced-aware output not yet native-covered)`;
+        // #86 part 1: a relationKind:single child WITH bindField (relationSingle) IS covered. When the
+        // bound parent field is null/absent the child is UNPRODUCED — the produced-aware output lowering
+        // (emitProducedAwareValue) then yields the unproduced rep (null / opt-nil) for a ref/refOpt into
+        // it, matching run_behavior's writeUnproduced. #93 shape 1: a bindField on a relationKind:connection
+        // child is ALSO covered — the connection's unproduced rep is the empty connection {items:[],cursor:null}
+        // (unproducedValue("connection")), which emitProducedAwareValue emits explicitly for a skipped
+        // connection node (a ref into it yields {items:[],cursor:null}, matching run_behavior).
+        if (cr.bindField !== undefined && cr.relationKind !== "single" && cr.relationKind !== "connection")
+            return `node '${n.id}' relationKind '${cr.relationKind ?? "point"}' not native-covered (bindField only supports single|connection)`;
+        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]) === false)
+                return `node '${n.id}' port '${p}' is not statically resolvable`;
+    }
+    if (!outputIsNativeLowerable(comp))
+        return "output is not natively lowerable";
+    return null;
+}
+/** Fail closed if a covered read SHAPE lacks the typed annotations (no silent boxed re-box). */
+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, asBinding) {
+    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{}`;
+    }
+    const fieldTypes = portNames.map((p) => portFieldGoType(node.ports[p], comp.inputPorts, `port '${p}' of node '${node.id}'`, asBinding));
+    const fieldNames = portNames.map(goPortFieldName);
+    const fields = portNames
+        .map((p, i) => `\t${fieldNames[i]} ${fieldTypes[i]} // ${JSON.stringify(p)}`)
+        .join("\n");
+    // NO PortReader `Port(name)` method: the covered handler reads the TYPED struct fields (ports.F_PK)
+    // DIRECTLY, so the boxed-Value PortReader impl (the last per-port `dslcontracts.Value` wrap on the
+    // covered plane) is DEAD — dropping it makes the ports struct fully native (bc#90 / runtime-free).
+    return `// ${structName} — NATIVE ports for node '${node.id}' (${node.component}). Typed fields per the
+// static port type; built by direct field assignment (no map alloc, no per-port boxing). The consumer
+// reads the typed fields DIRECTLY (no PortReader / boxed-Value accessor) — the covered read is native.
+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) {
+    return `Handler_${sanitize(compName)}`;
+}
+/** RunNativeRawStruct_<comp> — the EXPORTED name of the per-component struct-returning combined runner
+ * (bc#102). It MUST be an exported Go identifier so a consumer in a DIFFERENT package can call it (a
+ * leading-lowercase name is unexported / uncallable cross-package). The `RunNativeRawStruct_` prefix
+ * guarantees the leading char is uppercase regardless of how the component name sanitizes, and the
+ * sanitized component suffix keeps it unique per covered component. */
+function runnerName(compName) {
+    return `RunNativeRawStruct_${sanitize(compName)}`;
+}
+/** Node_<comp>_<nodeId> — the concrete per-node handler method name. */
+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 ("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
+ * the old boxed `dslcontracts.Value`. We represent PRODUCED-vs-UNPRODUCED with a POINTER: a non-nil
+ * `*T` means the parent value was produced/present (an empty string is a VALID produced value — a
+ * non-nil `*string` to ""); a nil pointer means UNPRODUCED/skip (exactly the old `!= nil` guard ≡
+ * run_behavior). The pointed-to type is the bindField's concrete Go type (a string key here). A node
+ * WITHOUT a bindField never receives a bound value — its param is a `*string` placeholder always
+ * passed `nil` (a typed nil, so the ABI stays uniform and carries NO dslcontracts.Value).
+ */
+function boundGoType(node, comp, typedNodes, plan) {
+    if (node.bindField === undefined || node.parent === undefined)
+        return "*string";
+    const parentRef = typedNodes.get(node.parent);
+    if (parentRef === undefined)
+        return "*string";
+    let bfRef;
+    try {
+        bfRef = goTypedInternals.typedFieldAccess(typedLocal(node.parent), parentRef, [node.bindField], plan).ref;
+    }
+    catch {
+        return "*string";
+    }
+    // opt bindField: the field is already a *T — the bound pointed-to type is the inner. A required
+    // scalar bindField: the bound pointed-to type is that scalar's Go type.
+    if (bfRef.kind === "opt")
+        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 ("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, "_")}`;
+}
+/**
+ * emitMapPortsStructs — the per-element native ports struct + the batch struct for a covered map
+ * node (bc#90 / runtime-free). The element struct is the same shape as a componentRef ports struct
+ * (typed fields per the static port type). The batch struct carries `Items []<elemStruct>` — a NATIVE
+ * slice of the concrete per-element ports structs (NO `[]dslcontracts.Value`, NO PortReader accessor);
+ * the consumer reads `bp.Items[i].F_PK` directly.
+ */
+function emitMapPortsStructs(comp, node, typedNodes, plan) {
+    const m = node.map;
+    const structName = portsStructName(comp.name, node.id);
+    // #108: the element ports may read the `$as` binding ($id / $g.field) — resolve the over element
+    // type so those ports type their struct field natively (map-over-input scalar element / prior-node
+    // struct element). A pure-static/concat port ignores the binding.
+    const { elemRef } = mapOverElemInfo(comp, node, typedNodes, plan);
+    const asBinding = { name: m.as, ref: elemRef, plan };
+    const elemStruct = emitPortsStruct(comp, { id: node.id, component: m.component, ports: m.ports }, asBinding);
+    const batchStruct = `${structName}_batch`;
+    return `${elemStruct}
+
+// ${batchStruct} — NATIVE batched ports for map '${node.id}': Items is a native slice of the concrete
+// per-element ports structs (${structName}). The consumer reads Items[i].<Field> DIRECTLY — no boxed
+// []Value, no PortReader accessor, no key-value object (bc#90 / runtime-free).
+type ${batchStruct} struct {
+	Items []${structName}
+}`;
+}
+/** 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>. */
+function mapElemRowRef(node, arrRef, plan) {
+    const m = node.map;
+    if (m.into === undefined)
+        return arrRef.elem;
+    if (arrRef.elem.kind !== "named") {
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go combined map (#86 pt2): node '${node.id}' element outType must be a named struct (got ${JSON.stringify(arrRef.elem.kind)}) — the augmented element de-boxes into a struct. Regenerate as boxed typed/straight-line.`);
+    }
+    const decl = findDecl(plan, arrRef.elem.name);
+    const intoField = decl.fields.find((f) => f.name === m.into);
+    if (!intoField) {
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go combined map (#86 pt2): element struct '${arrRef.elem.name}' has no '${m.into}' (into) field.`);
+    }
+    return intoField.type;
+}
+/**
+ * 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).
+ */
+function emitMapElemMaterializers(comp, typedNodes, plan) {
+    const parts = [];
+    for (const n of comp.body) {
+        if (!("map" in n))
+            continue;
+        const m = n.map;
+        // #93 shape 3: a map with NO `into` collects each element DIRECTLY from the per-element handler row
+        // (RawElem_ IS the element outType) — no over-element merge, so no augmented-element copier here.
+        if (m.into === undefined)
+            continue;
+        const arrRef = typedNodes.get(n.id);
+        const elemRef = arrRef.elem;
+        const decl = findDecl(plan, elemRef.name);
+        const intoKey = m.into;
+        // over element type (all element fields EXCEPT the into field): these come from the over element
+        // struct (the parent collection element). We copy each by same-named field access.
+        const overFields = decl.fields.filter((f) => f.name !== intoKey);
+        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(`\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(`\treturn out`);
+        lines.push(`}`);
+        parts.push(lines.join("\n"));
+    }
+    return parts.join("\n\n");
+}
+/**
+ * mapOverElemInfo — resolve a covered map's `over` collection: its element TypeRef + the Go expression
+ * that yields the native over slice. Two sources (#108):
+ *   - a ref to a PRIOR BODY NODE's typed arr field (`t_root.Groups`) — element type from the parent struct;
+ *   - a ref to an INPUT ARRAY port carrying `elemType` (`in.Ids`) — element type from PortSchema.elemType.
+ * A map over an input array WITHOUT elemType is fail-closed (BC does not infer — consumer-interface C3).
+ */
+function mapOverElemInfo(comp, node, typedNodes, plan) {
+    const m = node.map;
+    const e = classifyExpr(m.over);
+    if (e.kind === "ref" && e.path.length >= 1 && typedNodes.has(e.path[0])) {
+        const baseRef = typedNodes.get(e.path[0]);
+        const { expr, ref } = goTypedInternals.typedFieldAccess(typedLocal(e.path[0]), baseRef, e.path.slice(1), plan);
+        if (ref.kind === "arr")
+            return { elemRef: ref.elem, overExpr: expr };
+    }
+    // input-array over (#108): the head is an input port; its declared elemType is the element type.
+    if (e.kind === "ref" && e.path.length === 1) {
+        const schema = comp.inputPorts?.[e.path[0]];
+        const et = schema?.elemType;
+        if (et !== undefined) {
+            return { elemRef: deriveTypeRef(et, plan), overExpr: `in.${goFieldName(e.path[0])}` };
+        }
+    }
+    throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go combined map (#108): map '${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(m.over)}). BC does not infer input-array element types (consumer-interface C3).`);
+}
+/** The Go type of the over-element (back-compat shim). */
+function mapOverElemType(comp, node, typedNodes, plan) {
+    return renderTypeRef(mapOverElemInfo(comp, node, typedNodes, plan).elemRef);
+}
+function classifyPort(node) {
+    if (staticArrElems(node) !== null)
+        return "static";
+    const e = classifyExpr(node);
+    switch (e.kind) {
+        case "str":
+        case "bool":
+        case "null":
+        case "ref":
+            return "static";
+        case "concat":
+            return e.parts.every((p) => classifyPort(reconstructG(p)) === "static") ? "static" : "dynamic";
+        default:
+            return "dynamic";
+    }
+}
+function reconstructG(e) {
+    switch (e.kind) {
+        case "str":
+            return e.value;
+        case "bool":
+            return e.value;
+        case "null":
+            return null;
+        case "ref":
+            return { [e.opt ? "refOpt" : "ref"]: e.path };
+        case "concat":
+            return { concat: e.parts.map(reconstructG) };
+        case "dynamic":
+            return e.node;
+    }
+}
+// bc#90 / runtime-free: the old nvVE-based `emitStaticVE` / `valueLeaf` port lowering (which built
+// `dslcontracts.Value` leaves via the nv* helpers) is REMOVED — every covered port now lowers to a
+// FULLY NATIVE Go value in emitPortInit (string / bool / static-string-array / number literal), and a
+// genuinely-dynamic port fails closed. There is no boxed-Value fallback on the covered read plane.
+// ── typed input struct (In_<comp>) + NATIVE scalar port lowering ─────────────────────────────
+//
+// A covered runner takes a CONCRETE per-component input struct `In_<comp>` (fields = the component's
+// inputPorts with their declared Go types) instead of a generic *Obj. A simple string/scalar port —
+// a literal, a ref to a typed input field (`in.UserId`), a ref to a prior node's typed struct scalar
+// field, or a concat of statically-string parts — then lowers DIRECTLY to a native Go expression
+// (`"USER#" + in.UserId`) assigned straight into the concrete ports-struct field: NO dslcontracts.Value,
+// NO nvVE/nvBindVE helper, NO `.(string)` type-assert. The value is statically the concrete type (the
+// input schema / prior-node outType guarantee it, and literals are self-evidently typed), so dropping
+// the runtime TYPE_MISMATCH check is semantics-preserving. A port that CANNOT be statically proven the
+// concrete type (a ref to a non-matching-typed input, a refOpt / opt field, or a dynamic operator)
+// falls back to the nvVE Value path (documented — the only place a `.(T)` could survive; the covered
+// string key/table/projection ports never hit it).
+/** In_<comp> — the concrete per-component input struct name (fields = inputPorts). */
+function inStructName(compName) {
+    return `In_${sanitize(compName)}`;
+}
+/** Go type for an input port's declared type (scalar → concrete; array+elemType → []ElemT; else Value). */
+function inputPortGoType(schema, plan) {
+    switch (schema?.type) {
+        case "string":
+            return "string";
+        case "int":
+            return "int64";
+        case "float":
+            return "float64";
+        case "bool":
+            return "bool";
+        case "array":
+        case "arr": {
+            // #108: an input ARRAY port with a declared elemType lowers to a native []ElemT (the map-over-input
+            // $as element type source). Without elemType or a plan, it stays a boxed Value (uncovered / fail-closed).
+            const et = schema.elemType;
+            if (et !== undefined && plan !== undefined)
+                return `[]${renderTypeRef(deriveTypeRef(et, plan))}`;
+            return `${PKG}.Value`;
+        }
+        default:
+            return `${PKG}.Value`;
+    }
+}
+/** The scalar kind an input port declares, or undefined if it is not a native scalar. */
+function inputScalarKind(schema) {
+    switch (schema?.type) {
+        case "string":
+            return "string";
+        case "int":
+            return "int64";
+        case "float":
+            return "float64";
+        case "bool":
+            return "bool";
+        default:
+            return undefined;
+    }
+}
+/** emitInStruct — the concrete input struct declaration for a covered component (fields = inputPorts,
+ * declaration order = Object key order; gofmt-aligned). Empty inputPorts => empty struct. */
+function emitInStruct(comp, plan) {
+    const name = inStructName(comp.name);
+    const ports = Object.keys(comp.inputPorts ?? {});
+    if (ports.length === 0) {
+        return `// ${name} — the CONCRETE input for '${comp.name}' (no input ports).\ntype ${name} struct{}`;
+    }
+    const names = ports.map((p) => goFieldName(p));
+    const types = ports.map((p) => inputPortGoType(comp.inputPorts[p], plan));
+    const nameW = Math.max(0, ...names.map((n) => n.length));
+    const typeW = Math.max(0, ...types.map((t) => t.length));
+    const fields = ports
+        .map((p, i) => `\t${names[i].padEnd(nameW)} ${types[i].padEnd(typeW)} // ${JSON.stringify(p)}`)
+        .join("\n");
+    return `// ${name} — the CONCRETE input for '${comp.name}' (fields = inputPorts; typed, consumer-built —
+// NO generic *Obj, NO per-field boxing crosses the covered read boundary).
+type ${name} struct {
+${fields}
+}`;
+}
+/**
+ * emitInDecoder — the TEST-glue decoder `decode_In_<comp>(input *Obj) (In_<comp>, error)`. It reads
+ * each declared input port from the generic *Obj into the concrete In_<comp> field (scalar → typed
+ * read with a `.(T)` on the SDK/wire Value; Value-typed field → the raw Value). Lives ONLY in the
+ * observe companion (test harness), never in the covered module — the covered runner takes In_<comp>
+ * pre-built by the consumer. A missing key leaves the zero value (every covered input is required +
+ * always supplied by the corpus); a present-but-wrong-scalar is a fail-closed decode error.
+ */
+function emitInDecoder(comp, plan) {
+    const name = inStructName(comp.name);
+    const ports = Object.keys(comp.inputPorts ?? {});
+    const lines = [];
+    lines.push(`func decode_${name}(input *${PKG}.Obj) (${name}, error) {`);
+    lines.push(`\tvar in ${name}`);
+    if (ports.length === 0 || comp.inputPorts === undefined) {
+        lines.push(`\t_ = input`);
+        lines.push(`\treturn in, nil`);
+        lines.push(`}`);
+        return lines.join("\n");
+    }
+    lines.push(`\tif input == nil {`);
+    lines.push(`\t\treturn in, nil`);
+    lines.push(`\t}`);
+    for (const p of ports) {
+        const field = goFieldName(p);
+        const schema = comp.inputPorts[p];
+        const scalar = inputScalarKind(schema);
+        const et = schema.elemType;
+        lines.push(`\tif v, ok := input.Get(${JSON.stringify(p)}); ok {`);
+        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).
+            const elemRef = deriveTypeRef(et, plan);
+            const elemGo = renderTypeRef(elemRef);
+            lines.push(`\t\tarr, isArr := v.([]${PKG}.Value)`);
+            lines.push(`\t\tif !isArr {`);
+            lines.push(`\t\t\treturn in, ${PKG}.NewExprFailure("TYPE_MISMATCH", "input ${p}: expected array, got "+${PKG}.TypeName(v))`);
+            lines.push(`\t\t}`);
+            lines.push(`\t\tdec := make([]${elemGo}, 0, len(arr))`);
+            lines.push(`\t\tfor _, ev := range arr {`);
+            // materializeExpr returns the must*-based decode (panics on a malformed corpus element — test glue).
+            lines.push(`\t\t\tdec = append(dec, ${goTypedInternals.materializeExpr("ev", elemRef, plan)})`);
+            lines.push(`\t\t}`);
+            lines.push(`\t\tin.${field} = dec`);
+            lines.push(`\t}`);
+            continue;
+        }
+        if (scalar === undefined) {
+            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`);
+        }
+        lines.push(`\t}`);
+    }
+    lines.push(`\treturn in, nil`);
+    lines.push(`}`);
+    return lines.join("\n");
+}
+/**
+ * emitNativeScalar — lower a static port expr to a NATIVE Go expression of the concrete `want` scalar
+ * type, or null if it cannot be statically proven that type. Literals: a string literal is native for
+ * `want==="string"`, a bool literal for `want==="bool"`. A ref resolves via `resolveRef` (typed input
+ * field / prior-node scalar / element binding). A concat lowers ONLY into `string` and only when EVERY
+ * part is itself a native string (so the concat's strings-only TYPE_MISMATCH can never fire — the parts
+ * are statically strings), emitting `p0 + p1 + …`. Returns null (fall back to the Value path) otherwise.
+ */
+function emitNativeScalar(node, want, resolveRef) {
+    // a static arr is a Value port (never a scalar) — not native-lowerable here.
+    if (staticArrElems(node) !== null)
+        return null;
+    const e = classifyExpr(node);
+    switch (e.kind) {
+        case "str":
+            return want === "string" ? JSON.stringify(e.value) : null;
+        case "bool":
+            return want === "bool" ? (e.value ? "true" : "false") : null;
+        case "null":
+            return null; // a null literal is a Value(nil), never a required native scalar
+        case "ref": {
+            const sc = resolveRef(e.path[0], e.path.slice(1), e.opt);
+            if (sc === null || sc.scalar !== want)
+                return null;
+            return sc.expr;
+        }
+        case "concat": {
+            if (want !== "string")
+                return null;
+            const parts = [];
+            for (const p of e.parts) {
+                const sub = emitNativeScalar(reconstructG(p), "string", resolveRef);
+                if (sub === null)
+                    return null;
+                // parenthesize a `+` sub-expression so string concatenation binds correctly (a ref/literal is
+                // atomic; a nested concat is already a single `a + b` — wrap to keep it one operand).
+                parts.push(sub.includes(" + ") ? `(${sub})` : sub);
+            }
+            return parts.join(" + ");
+        }
+        default:
+            return null;
+    }
+}
+/**
+ * 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, fieldGoType, resolveRef) {
+    const fieldName = goPortFieldName(pn);
+    // change #2: a static string array (projection) → a native `[]string{...}` literal.
+    const strArr = staticStringArrElems(expr);
+    if (strArr !== null) {
+        if (fieldGoType !== "[]string") {
+            throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go combined read (bc#90): port '${pn}' is a static string array but its field type is '${fieldGoType}' (expected []string).`);
+        }
+        return `${fieldName}: []string{${strArr.map((s) => JSON.stringify(s)).join(", ")}}`;
+    }
+    // a bare number literal (e.g. Query `limit: 20`): the SSoT range check ran in numLiteralGoExpr —
+    // emit the concrete native int64/float64 (unwrap the dslcontracts.Value(...) box: it was only there
+    // for the old boxed path; the range check is what matters, and it already passed).
+    const num = numLiteralGoExpr(expr);
+    if (num !== null) {
+        if (fieldGoType === "int64")
+            return `${fieldName}: int64(${expr})`;
+        if (fieldGoType === "float64")
+            return `${fieldName}: float64(${expr})`;
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go combined read (bc#90): port '${pn}' is a number literal but its field type is '${fieldGoType}'.`);
+    }
+    // string / bool / scalar-input / concat → native scalar expression (no Value, no `.(T)`).
+    const scalarWant = fieldGoType;
+    const native = emitNativeScalar(expr, scalarWant, resolveRef);
+    if (native !== null) {
+        return `${fieldName}: ${native}`;
+    }
+    // FAIL CLOSED: the covered read plane is runtime-free — no boxed Value fallback (that would
+    // re-couple the covered module to bc-runtime). If a genuinely-dynamic port reaches here, the
+    // component is not native-eligible and must regenerate on the boxed straight-line path.
+    throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go combined read (bc#90 / runtime-free): port '${pn}' (${JSON.stringify(expr)}) does not lower to a native Go value of type '${fieldGoType}'. The covered read plane admits NO boxed dslcontracts.Value escape — regenerate on the boxed straight-line path if this port is genuinely dynamic.`);
+}
+/**
+ * emitParallelStageArm (bc#87) — EXPLICIT static parallel orchestration for a real-concurrency stage.
+ * The stage's members are statically known (from plan.groups), each a plain componentRef point read.
+ * We reproduce plan.go's bounded-parallel protocol EXACTLY, so the observed value / emitted op multiset
+ * / failure PRECEDENCE / skip reps byte-match run_behavior:
+ *
+ *   1. PREFLIGHT (ascending index): for each member, decide run/skip from the SETTLED prior-stage
+ *      results (a plain `produced_<parent>` gate — members are mutually independent, §1) and build its
+ *      native ports struct. The ports are computed BEFORE dispatch (never inside the goroutine) so the
+ *      order-of-evaluation is deterministic and a port ExprFailure surfaces in ascending index order.
+ *   2. DISPATCH (bounded): one `go func(){…}()` per RUNNABLE member, bound to the static plan.concurrency
+ *      via a semaphore channel of known size (min(concurrency, member count)); a sync.WaitGroup joins
+ *      them. Each goroutine ONLY calls the handler and stores its RawOutcome into a per-member struct
+ *      local — the goroutine spawn is the SOLE runtime element.
+ *   3. COMMIT (ascending index): interpret Policy Kind + materialize the RawValue into the outType
+ *      struct, in ascending index order. Under 'fail'/'retry', the FIRST (lowest-index) failing member
+ *      wins — a race can NEVER change which failure surfaces, because interpretation is committed
+ *      deterministically after all execs settle (collect-then-apply, mirroring plan.go's commit loop).
+ *
+ * NO RunPlan / []OpSpec / planSpec walk: the staging, the bound, and which ops are parallel are baked.
+ */
+function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes, plan, priorNodeAt, zeroOut, flags, resolveRefAt) {
+    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`);
+    lines.push(`\t// orchestration (goroutine per op, bound=${concurrency}); preflight+commit in ascending index order.`);
+    lines.push(`\t{`);
+    // per-member outcome + resolved-flag + ports locals, declared at STAGE scope (assigned in the
+    // ascending preflight, read at dispatch/commit — a goroutine closes over the ports local).
+    for (const i of stage) {
+        const s = sanitize(comp.body[i].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`);
+        lines.push(`\t\trun_${s} := false`);
+        lines.push(`\t\tvar ps_${s} ${structName}`);
+        lines.push(`\t\t_ = ps_${s}`);
+    }
+    // 1) PREFLIGHT (ascending): parent-produced gate + ports build, per member (BEFORE dispatch).
+    for (const i of stage) {
+        const node = comp.body[i];
+        const s = sanitize(node.id);
+        const structName = portsStructName(comp.name, node.id);
+        let ind = "\t\t";
+        const closers = [];
+        if (node.parent !== undefined && priorNodeAt(node.parent, atPos)) {
+            lines.push(`${ind}if produced_${sanitize(node.parent)} {`);
+            closers.unshift(`${ind}}`);
+            ind += "\t";
+        }
+        const inits = [];
+        const resolveRef = resolveRefAt(atPos);
+        for (const pn of Object.keys(node.ports)) {
+            const expr = node.ports[pn];
+            const fieldGoType = portFieldGoType(expr, comp.inputPorts, `port '${pn}' of node '${node.id}'`);
+            inits.push(emitPortInit(pn, expr, fieldGoType, resolveRef));
+        }
+        lines.push(`${ind}ps_${s} = ${structName}{${inits.join(", ")}}`);
+        lines.push(`${ind}run_${s} = true`);
+        for (const c of closers)
+            lines.push(c);
+    }
+    // 2) DISPATCH (bounded): one goroutine per runnable member, bound by a semaphore of the static size.
+    const bound = Math.min(concurrency, stage.length);
+    lines.push(`\t\tvar wg sync.WaitGroup`);
+    lines.push(`\t\tsem := make(chan struct{}, ${bound})`);
+    for (const i of stage) {
+        const node = comp.body[i];
+        const s = sanitize(node.id);
+        lines.push(`\t\tif run_${s} {`);
+        lines.push(`\t\t\twg.Add(1)`);
+        lines.push(`\t\t\tsem <- struct{}{}`);
+        lines.push(`\t\t\tgo func() {`);
+        lines.push(`\t\t\t\tdefer wg.Done()`);
+        lines.push(`\t\t\t\tdefer func() { <-sem }()`);
+        lines.push(`\t\t\t\trow_${s}, row_${s}Resolved = handlers.${nodeMethodName(comp.name, node.id)}(ps_${s}, nil)`);
+        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.
+    for (const i of stage) {
+        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`);
+            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\t}`);
+            lines.push(emitRowCopy(typedLocal(node.id), oc, ref, plan, 3));
+            lines.push(`\t\t\tproduced_${s} = true`);
+        }
+        lines.push(`\t\t}`);
+    }
+    lines.push(`\t}`);
+    return lines.join("\n");
+}
+/**
+ * emitNativeRawRunner — the combined read exec for one component, as a STRUCT-RETURNING runner
+ * (the fully de-plumbed path): native ports struct IN (direct field assignment), raw struct result
+ * OUT (marshalRaw_* straight into the node's outType struct — no boxed Value on the row plane),
+ * INLINE sequential (NO RunPlan). Node results are TYPED STRUCT locals; a relation child reads the
+ * parent's REAL struct result inline (typed field access — no serialize), and the child-present /
+ * bindField / continue-skip decision is made from the real parent value — so relationSingle /
+ * connection converge with run_behavior. The output is assembled as a TYPED STRUCT/value (via the
+ * typed output lowering — struct literal + struct-field access, ZERO NewObj/.Set). For a covered
+ * read whose ports/output are input-static + cross-node refs, this runner allocates ZERO *Obj: the
+ * 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) {
+    const ep = execPlan(comp);
+    const order = ep.order;
+    const cplan = buildComponentPlan(comp, goStraightlineInternals.dialect, "scope");
+    const metas = analyzeSequentialOps(cplan.opsLiteral, order);
+    const fn = sanitize(comp.name);
+    const typedNodes = new Map();
+    for (const n of comp.body)
+        typedNodes.set(n.id, deriveTypeRef(n.outType, plan));
+    const idToPos = new Map();
+    order.forEach((opIdx, k) => idToPos.set(comp.body[opIdx].id, k));
+    const priorNodeAt = (head, atPos) => {
+        const p = idToPos.get(head);
+        return p !== undefined && p < atPos;
+    };
+    const outRef = comp.outputType !== undefined ? deriveTypeRef(comp.outputType, plan) : undefined;
+    const outStructType = outRef ? renderTypeRef(outRef) : `${PKG}.Value`;
+    const zeroOut = outRef ? goZero(outRef) : "nil";
+    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`);
+    lines.push(`// result is materialized straight into the node's outType struct. Node results are typed`);
+    lines.push(`// struct locals; a relation child reads the parent's REAL struct result via direct field`);
+    lines.push(`// access (child-present decision from the real parent value — relationSingle / connection`);
+    lines.push(`// converge). A strictly-sequential plan is a plain statement list (no plan driver); a`);
+    lines.push(`// real-concurrency stage (bc#87) is EXPLICIT static parallel orchestration — one goroutine`);
+    lines.push(`// per statically-known parallel op, bounded by the static plan.concurrency via a semaphore`);
+    lines.push(`// of known size, with a sync.WaitGroup; preflight + interpret are committed in ascending`);
+    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) {`);
+    lines.push(`\t_ = in`);
+    // resolveNativeRef for this runner: a ref head is either a PRIOR NODE (read its typed struct field
+    // directly) or an INPUT PORT (read the typed `in.<Field>`). A REQUIRED scalar resolves to a native
+    // Go expression; an opt / non-scalar / refOpt resolves to null (falls back to the nvVE Value path).
+    const resolveRefAt = (atPos) => (head, restPath, opt) => {
+        if (opt)
+            return null; // a refOpt may be nil at runtime — keep the Value path (opt-nil semantics)
+        if (priorNodeAt(head, atPos)) {
+            const baseRef = typedNodes.get(head);
+            let acc;
+            let expr;
+            try {
+                const r = goTypedInternals.typedFieldAccess(typedLocal(head), baseRef, restPath, plan);
+                expr = r.expr;
+                acc = r.ref;
+            }
+            catch {
+                return null;
+            }
+            if (acc.kind !== "scalar" || acc.scalar === "null")
+                return null;
+            return { expr, scalar: goScalar(acc.scalar) };
+        }
+        if (restPath.length !== 0)
+            return null; // input.<field> path is a Value walk — not a native scalar
+        const scalar = inputScalarKind(comp.inputPorts?.[head]);
+        if (scalar === undefined)
+            return null;
+        return { expr: `in.${goFieldName(head)}`, scalar };
+    };
+    for (const k of order.keys()) {
+        const id = comp.body[order[k]].id;
+        lines.push(`\tvar ${typedLocal(id)} ${renderTypeRef(typedNodes.get(id))}`);
+        lines.push(`\tproduced_${sanitize(id)} := false`);
+        lines.push(`\t_ = ${typedLocal(id)}`);
+        lines.push(`\t_ = produced_${sanitize(id)}`);
+    }
+    const idToPosAll = new Map();
+    order.forEach((opIdx, k) => idToPosAll.set(opIdx, k));
+    for (let k = 0; k < order.length; k++) {
+        const i = order[k];
+        // bc#87: a real-concurrency stage — emit static parallel orchestration for ALL its members here,
+        // then advance past them. The stage members are consecutive in `order` (execPlan concatenates
+        // ascending-sorted stages), so we emit the block at the first member and skip the rest.
+        const stage = ep.parallelStageOf.get(i);
+        if (stage !== undefined && stage[0] === i) {
+            lines.push(emitParallelStageArm(comp, stage, k, ep.concurrency, metas, typedNodes, plan, priorNodeAt, zeroOut, flags, resolveRefAt));
+            k += stage.length - 1;
+            continue;
+        }
+        // #86 pt2: a covered batched map...into node — struct-native element collection + into enrichment.
+        if ("map" in comp.body[i]) {
+            lines.push(emitMapArm(comp, comp.body[i], k, typedNodes, plan, priorNodeAt, zeroOut, flags));
+            continue;
+        }
+        // #108: a cond node — pure Expression (no handler). Compile `if` to a native bool + materialize the
+        // taken branch to the node's outType, assigning the node's typed cell. Byte-equal to run_behavior's
+        // cond lower ({cond:[if,then,else]}, strict-bool, only the taken branch evaluated).
+        if ("cond" in comp.body[i]) {
+            lines.push(emitCondArm(comp, comp.body[i], k, typedNodes, plan, priorNodeAt, zeroOut));
+            continue;
+        }
+        const node = comp.body[i];
+        const meta = metas[i];
+        const s = sanitize(node.id);
+        const structName = portsStructName(comp.name, node.id);
+        const portNames = Object.keys(node.ports);
+        const ref = typedNodes.get(node.id);
+        lines.push(`\t// ── op '${node.id}' (${node.component}${node.relationKind ? ", relationKind:" + node.relationKind : ""}${node.parent ? ", parent:" + node.parent : ""}) ──`);
+        let indent = "\t";
+        const closers = [];
+        if (node.parent !== undefined && priorNodeAt(node.parent, k)) {
+            lines.push(`${indent}if produced_${sanitize(node.parent)} {`);
+            closers.unshift(`${indent}}`);
+            indent += "\t";
+            if (node.bindField !== undefined) {
+                // bind (change #3 — typed produced-aware bound): read the parent struct field DIRECTLY (typed
+                // access — no serialize). `bound_<s>` is a TYPED POINTER (`*T`) — nil => UNPRODUCED/skip, non-nil
+                // => produced (an empty string is a VALID produced value, a non-nil *string to ""). This is the
+                // EXACT `!= nil` skip-gate ≡ run_behavior's preflightOp, now runtime-free (NO dslcontracts.Value).
+                const parentRef = typedNodes.get(node.parent);
+                const { expr: bfExpr, ref: bfRef } = goTypedInternals.typedFieldAccess(typedLocal(node.parent), parentRef, [node.bindField], plan);
+                if (bfRef.kind === "opt") {
+                    // an opt bindField is ALREADY a *T: nil => skip, non-nil => produced. Use it directly.
+                    lines.push(`${indent}bound_${s} := ${bfExpr}`);
+                }
+                else {
+                    // a required scalar bindField is always PRESENT (never skips on null): take its address so
+                    // the produced pointer is non-nil, preserving the "produced" semantics of the old guard.
+                    lines.push(`${indent}boundV_${s} := ${bfExpr}`);
+                    lines.push(`${indent}bound_${s} := &boundV_${s}`);
+                }
+                lines.push(`${indent}if bound_${s} != nil {`);
+                closers.unshift(`${indent}}`);
+                indent += "\t";
+            }
+        }
+        // ports: build the native struct by direct field assignment (bc#90 / runtime-free). Every covered
+        // port lowers to a concrete Go value (literal / input-param ref / cross-node typed field / concat /
+        // static string array / number literal) assigned straight into the ports field — ZERO
+        // dslcontracts.Value, ZERO nvVE helper, ZERO `.(T)`. A genuinely-dynamic port FAILS CLOSED.
+        const inits = [];
+        const boundArg = node.bindField !== undefined ? `bound_${s}` : "nil";
+        const resolveRef = resolveRefAt(k);
+        for (const pn of portNames) {
+            const expr = node.ports[pn];
+            const fieldGoType = portFieldGoType(expr, comp.inputPorts, `port '${pn}' of node '${node.id}'`);
+            inits.push(emitPortInit(pn, expr, fieldGoType, resolveRef));
+        }
+        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);
+        if (meta.policy === "continue") {
+            lines.push(`${indent}if !${oc}.IsError {`);
+            lines.push(copy(indent + "\t"));
+            lines.push(`${indent}\tproduced_${s} = true`);
+            lines.push(`${indent}}`);
+        }
+        else {
+            const policy = meta.policy === "retry" ? "retry' policy (exhausted)" : "fail' policy";
+            lines.push(`${indent}if ${oc}.IsError {`);
+            lines.push(`${indent}\treturn ${zeroOut}, ${goErr("OP_FAILED", `"operation '${node.id}' failed under '${policy}: "+${oc}.Err`)}`);
+            lines.push(`${indent}}`);
+            lines.push(copy(indent));
+            lines.push(`${indent}produced_${s} = true`);
+        }
+        for (const c of closers)
+            lines.push(c);
+    }
+    // output: assemble a TYPED struct/value via the typed output lowering (struct literal + typed
+    // field access — ZERO NewObj/.Set). This is the reused boxed-typed output assembly, but the
+    // result stays a struct (the consumer keeps it native). An input-param output ref would need the
+    // Value-scope fallback (scopeNR) — the covered read corpus does not hit it.
+    //
+    // #86 part 1: for a bindField relationSingle child that can SKIP at runtime, a ref/refOpt into it
+    // must yield the UNPRODUCED rep (run_behavior's writeUnproduced: null for a single child) rather
+    // than the zero-value struct. So when any covered node canSkip, we use the produced-aware lowering
+    // which gates such a ref on the node's produced_<id> flag.
+    const skippable = new Set();
+    const skippableKind = new Map();
+    for (const k of order.keys()) {
+        const bodyNode = comp.body[order[k]];
+        const id = bodyNode.id;
+        if (metas[order[k]].canSkip) {
+            skippable.add(id);
+            // relationKind of the skippable node decides its unproduced rep (#93 shape 1): a connection
+            // yields the empty connection {items:[],cursor:null}; single/absent yields null (opt-nil).
+            const rk = "map" in bodyNode ? bodyNode.map.relationKind : bodyNode.relationKind;
+            skippableKind.set(id, rk);
+        }
+    }
+    const out = skippable.size > 0
+        ? emitProducedAwareValue(comp.output, outRef, typedNodes, plan, skippable, skippableKind)
+        : emitTypedValue(comp.output, outRef, typedNodes, plan);
+    lines.push(`\treturn ${out.expr}, nil`);
+    lines.push(`}`);
+    return { code: lines.join("\n"), outRef: out.ref ?? outRef };
+}
+// bc#90 / runtime-free: the old nvVE-based `emitMapStaticVE` map-element port lowering is REMOVED —
+// covered map element ports lower to a fully native Go value in emitPortInit (the map resolveRef reads
+// the $as element / prior-node / input typed fields directly), with a fail-closed on a dynamic port.
+/**
+ * emitMapArm — the struct-native exec of a covered map node. Three shapes:
+ *   - #86 pt2: BATCHED map...into (nestedBatchGet) — dispatch once, zip-attach `into` onto each over
+ *     element (the augmented element materializer).
+ *   - #93 shape 2: NON-batched map...into — dispatch the child handler ONCE PER ELEMENT (N physical
+ *     requests, matching run_behavior's per-element loop), materialize `into` per element.
+ *   - #93 shape 3: BATCHED map with NO `into` — dispatch once, collect each element DIRECTLY from the
+ *     aligned batch raw via the element's own named marshaller (the connection/plain-list collect).
+ * In every case: over is a typed field access (no serialize), element ports are a native struct
+ * (direct field assignment; $as refs read the over element's typed fields), and the result is a
+ * native []T with NO boxed Value on any plane. The map is under the parent's produced gate (inline).
+ */
+function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, flags) {
+    const m = node.map;
+    const batched = m.batched === true;
+    const hasInto = m.into !== undefined;
+    const hasGuard = m.when !== undefined;
+    const s = sanitize(node.id);
+    const structName = portsStructName(comp.name, node.id);
+    const batchStruct = `${structName}_batch`;
+    const arrRef = typedNodes.get(node.id);
+    const elemGo = renderTypeRef(arrRef);
+    const asName = m.as;
+    // over collection element type + the native over-slice expression (#108: prior-node arr OR input array
+    // with elemType). The $as element is a value of `overElemRef` (input-array element or prior-node elem).
+    const { elemRef: overElemRef, overExpr } = mapOverElemInfo(comp, node, typedNodes, plan);
+    const overElemGo = renderTypeRef(overElemRef);
+    const elemMat = mapElemMaterializerName(comp.name, node.id);
+    const priorHere = (head) => priorNodeAt(head, atPos);
+    const portNames = Object.keys(m.ports);
+    // #108 guard: compile the `when` expression to a native bool over an element-scoped resolveHead
+    // ($as → the over element value `elemVar`; prior node → its typed local; input port → in.<Field>).
+    // Returns the compiled {stmts, expr} or null (no guard). Mirrors run_behavior's per-element keep-gate
+    // ({cond:[when,true,false]}, strict-bool). A non-bool / uncovered guard expr fails closed at emit.
+    const mkGuard = (elemVar) => {
+        if (!hasGuard)
+            return null;
+        const resolveHead = (head) => {
+            if (head === asName)
+                return { expr: elemVar, ref: overElemRef };
+            if (priorHere(head))
+                return { expr: typedLocal(head), ref: typedNodes.get(head) };
+            return goInputHeadRef(head, comp, plan);
+        };
+        const be = makeGoExprBackend(zeroOut, resolveHead, plan);
+        return new NativeExprCompiler(be).compileBool(m.when);
+    };
+    // emit the per-element native ports struct build (shared; `il` is the indent inside the element
+    // loop, `elemVar` the over element loop variable). Returns the lines building `ep_<s>`.
+    const buildPorts = (il, elemVar) => {
+        const out = [];
+        const inits = [];
+        // resolveNativeRef for a map element port: a ref head is the element binding ($as → the over element
+        // typed struct field `elemVar.<Field>`), a PRIOR NODE (its typed struct field), or an INPUT PORT
+        // (`in.<Field>`). A REQUIRED scalar lowers to a native Go expr; opt / non-scalar → null (Value path).
+        const resolveRef = (head, restPath, opt) => {
+            if (opt)
+                return null;
+            let baseExpr;
+            let baseRef;
+            if (head === asName) {
+                baseExpr = elemVar;
+                baseRef = overElemRef;
+            }
+            else if (priorHere(head)) {
+                baseExpr = typedLocal(head);
+                baseRef = typedNodes.get(head);
+            }
+            else {
+                if (restPath.length !== 0)
+                    return null;
+                const scalar = inputScalarKind(comp.inputPorts?.[head]);
+                if (scalar === undefined)
+                    return null;
+                return { expr: `in.${goFieldName(head)}`, scalar };
+            }
+            let acc;
+            let expr;
+            try {
+                const r = goTypedInternals.typedFieldAccess(baseExpr, baseRef, restPath, plan);
+                expr = r.expr;
+                acc = r.ref;
+            }
+            catch {
+                return null;
+            }
+            if (acc.kind !== "scalar" || acc.scalar === "null")
+                return null;
+            return { expr, scalar: goScalar(acc.scalar) };
+        };
+        const asBinding = { name: asName, ref: overElemRef, plan };
+        for (const pn of portNames) {
+            const fieldGoType = portFieldGoType(m.ports[pn], comp.inputPorts, `map port '${pn}' of node '${node.id}'`, asBinding);
+            inits.push(emitPortInit(pn, m.ports[pn], fieldGoType, resolveRef));
+        }
+        out.push(`${il}ep_${s} := ${structName}{${inits.join(", ")}}`);
+        return out;
+    };
+    const lines = [];
+    const closers = [];
+    lines.push(`\t// ── map '${node.id}' (${m.component}, ${batched ? "batched" : "per-element"}, into:${JSON.stringify(m.into ?? null)}${m.relationKind ? ", relationKind:" + m.relationKind : ""}${m.parent ? ", parent:" + m.parent : ""}) ──`);
+    let indent = "\t";
+    // the map is gated on the parent's produced flag (inline, like a relation child).
+    if (m.parent !== undefined && priorNodeAt(m.parent, atPos)) {
+        lines.push(`${indent}if produced_${sanitize(m.parent)} {`);
+        closers.unshift(`${indent}}`);
+        indent += "\t";
+    }
+    // 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}))`);
+    const elemRowRef = mapElemRowRef(node, arrRef, plan);
+    // 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) => {
+        const g = mkGuard(elemVar);
+        if (g === null)
+            return [];
+        const out = [];
+        for (const st of g.stmts)
+            out.push(`${il}${st}`);
+        out.push(`${il}if !(${g.expr}) {`);
+        out.push(`${il}\tcontinue`);
+        out.push(`${il}}`);
+        return out;
+    };
+    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.
+        // With a guard, `items` (and, for into, `keptOver`) hold only kept elements — matching run_behavior's
+        // keptIdx-aligned batch. `into` is never combined with a guard (rejected). no-into collects each row.
+        lines.push(`${indent}items_${s} := make([]${structName}, 0, len(over_${s}))`);
+        if (hasInto)
+            lines.push(`${indent}keptOver_${s} := make([]${overElemGo}, 0, len(over_${s}))`);
+        lines.push(`${indent}for _, ${elemLocal(s)} := range over_${s} {`);
+        for (const l of emitGuard(indent + "\t", elemLocal(s)))
+            lines.push(l);
+        for (const l of buildPorts(indent + "\t", elemLocal(s)))
+            lines.push(l);
+        lines.push(`${indent}\titems_${s} = append(items_${s}, ep_${s})`);
+        if (hasInto)
+            lines.push(`${indent}\tkeptOver_${s} = append(keptOver_${s}, ${elemLocal(s)})`);
+        lines.push(`${indent}}`);
+        // 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}`);
+        if (hasInto) {
+            // #86 pt2: zip-attach the into field onto each kept over element (augmented element copier).
+            lines.push(`${indent}\tfor mk_${s} := range keptOver_${s} {`);
+            lines.push(`${indent}\t\tel_${s} := ${elemMat}(keptOver_${s}[mk_${s}], mo_${s}.Rows[mk_${s}])`);
+            lines.push(`${indent}\t\t${typedLocal(node.id)} = append(${typedLocal(node.id)}, el_${s})`);
+            lines.push(`${indent}\t}`);
+        }
+        else {
+            // #93 shape 3 / #108: collect each element DIRECTLY from the aligned per-element row (field copy).
+            lines.push(`${indent}\tfor mk_${s} := range mo_${s}.Rows {`);
+            lines.push(`${indent}\t\tvar el_${s} ${renderTypeRef(arrRef.elem)}`);
+            lines.push(emitRowCopy(`el_${s}`, `mo_${s}.Rows[mk_${s}]`, elemRowRef, plan, indent.length + 2));
+            lines.push(`${indent}\t\t${typedLocal(node.id)} = append(${typedLocal(node.id)}, el_${s})`);
+            lines.push(`${indent}\t}`);
+        }
+        lines.push(`${indent}}`);
+    }
+    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_.
+        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)))
+            lines.push(l);
+        for (const l of buildPorts(indent + "\t", elemLocal(s)))
+            lines.push(l);
+        // 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}`);
+        if (hasInto) {
+            lines.push(`${indent}\tel_${s} := ${elemMat}(${elemLocal(s)}, mo_${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(`${indent}\t${typedLocal(node.id)} = append(${typedLocal(node.id)}, el_${s})`);
+        lines.push(`${indent}}`);
+    }
+    lines.push(`${indent}produced_${s} = true`);
+    for (const c of closers)
+        lines.push(c);
+    void overElemGo;
+    return lines.join("\n");
+}
+/** the map element loop variable (the over element, a typed struct). */
+function elemLocal(s) {
+    return `oel_${s}`;
+}
+/** #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) {
+    const schema = comp.inputPorts?.[head];
+    if (schema === undefined)
+        return null;
+    const sc = inputScalarKind(schema);
+    if (sc !== undefined) {
+        const scalarRef = { kind: "scalar", scalar: sc === "int64" ? "int" : sc === "float64" ? "float" : sc };
+        return { expr: `in.${goFieldName(head)}`, ref: scalarRef };
+    }
+    const et = schema.elemType;
+    if ((schema.type === "array" || schema.type === "arr") && et !== undefined) {
+        return { expr: `in.${goFieldName(head)}`, ref: { kind: "arr", elem: deriveTypeRef(et, plan) } };
+    }
+    return null;
+}
+/**
+ * emitCondArm — the struct-native exec of a covered cond node (#108). Mirrors run_behavior's cond
+ * lower (behavior.ts:425-429): compile `if` to a native bool, materialize the TAKEN branch to the
+ * node's outType (only the taken branch evaluated — short-circuit), assign the node's typed cell and
+ * set produced. NO handler dispatch (cond is a pure Expression). The `if`/`then`/`else` expressions
+ * compile via the runtime-free NativeExprCompiler (byte-equal to `evaluate`); an uncovered op / opt /
+ * refOpt / type-mismatch fails closed at emit.
+ */
+function emitCondArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut) {
+    const c = node.cond;
+    const s = sanitize(node.id);
+    const nodeRef = typedNodes.get(node.id);
+    const priorHere = (head) => priorNodeAt(head, atPos);
+    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 resolveDecl = (name) => findDecl(plan, name).fields;
+    const cond = compiler.compileBool(c.if);
+    const thenC = compiler.compileTo(c.then, nodeRef, resolveDecl);
+    const elseC = compiler.compileTo(c.else, nodeRef, resolveDecl);
+    const lines = [];
+    lines.push(`\t// ── cond '${node.id}'${c.parent ? " (parent:" + c.parent + ")" : ""} — pure Expression (no handler) ──`);
+    let indent = "\t";
+    const closers = [];
+    if (c.parent !== undefined && priorNodeAt(c.parent, atPos)) {
+        lines.push(`${indent}if produced_${sanitize(c.parent)} {`);
+        closers.unshift(`${indent}}`);
+        indent += "\t";
+    }
+    // the `if` condition (its fallible temps hoisted before the branch — the condition is always evaluated).
+    for (const st of cond.stmts)
+        lines.push(`${indent}${st}`);
+    lines.push(`${indent}if ${cond.expr} {`);
+    // TAKEN = then: only this branch's stmts run (short-circuit ≡ evaluate).
+    for (const st of thenC.stmts)
+        lines.push(`${indent}\t${st}`);
+    lines.push(`${indent}\t${typedLocal(node.id)} = ${thenC.expr}`);
+    lines.push(`${indent}} else {`);
+    for (const st of elseC.stmts)
+        lines.push(`${indent}\t${st}`);
+    lines.push(`${indent}\t${typedLocal(node.id)} = ${elseC.expr}`);
+    lines.push(`${indent}}`);
+    lines.push(`${indent}produced_${s} = true`);
+    void nodeRef;
+    for (const cl of closers)
+        lines.push(cl);
+    return lines.join("\n");
+}
+/**
+ * emitProducedAwareValue — the #86 part 1 produced-aware output lowering (go). It mirrors the
+ * boxed-typed emitTypedValue, but a `ref`/`refOpt` whose HEAD is a skippable relationSingle child is
+ * gated on that node's `produced_<id>` flag: when the child is UNPRODUCED (bound parent field was
+ * null/absent), run_behavior's writeUnproduced makes the node null, so a refOpt into it yields null
+ * (the output opt field => nil). We emit that exactly: `if produced_<head> { <typed field access> }
+ * else { <unproduced-rep for the expected type> }`. Obj/arr/concat/literal recurse; a ref into a
+ * NON-skippable node delegates to the plain typed field access (identical to emitTypedValue).
+ */
+function emitProducedAwareValue(node, expected, typedNodes, plan, skippable, skippableKind) {
+    // ref / refOpt (classifyExpr encodes both as kind:"ref" with .opt).
+    const e = classifyExpr(node);
+    if (e.kind === "ref" && e.path.length >= 1 && typedNodes.has(e.path[0])) {
+        const head = e.path[0];
+        const baseRef = typedNodes.get(head);
+        if (skippable.has(head)) {
+            // produced-aware: gate the field access on produced_<head>. The unproduced branch yields the
+            // node's unproduced rep per run_behavior's writeUnproduced (unproducedValue(relationKind)):
+            //   - single / absent → null (opt-nil);
+            //   - connection (#93 shape 1) → the empty connection {items:[],cursor:null}. Because a WHOLE
+            //     connection node has no field path (e.path.length===1), the unproduced rep is the struct
+            //     zero of the connection struct (its serializer normalizes a nil items slice to [] and the
+            //     nil cursor to null) — matching unproducedValue("connection") byte-for-byte.
+            const { expr, ref } = goTypedInternals.typedFieldAccess(typedLocal(head), baseRef, e.path.slice(1), plan);
+            const producedFlag = `produced_${sanitize(head)}`;
+            const producedExpr = valueLeafTyped(expr, ref, e.opt, expected);
+            const outTy = expected ? renderTypeRef(expected) : renderTypeRef(ref);
+            const isConn = skippableKind.get(head) === "connection" && e.path.length === 1;
+            // For a connection whole-node ref, the unproduced rep is the connection struct zero (empty
+            // items + nil cursor), even if the output field is opt (refOpt): run_behavior always writes the
+            // empty connection, never null. For single/field-access, the expected-type zero (nil for opt).
+            const unproduced = isConn ? goConnectionUnproduced(ref, expected) : goZero(expected ?? ref);
+            return {
+                expr: `func() ${outTy} { if ${producedFlag} { return ${producedExpr} }; return ${unproduced} }()`,
+                ref: expected ?? ref,
+            };
+        }
+        // non-skippable node ref — identical to emitTypedValue's typed field access.
+        const { expr, ref } = goTypedInternals.typedFieldAccess(typedLocal(head), baseRef, e.path.slice(1), plan);
+        return { expr, ref };
+    }
+    // obj-assembly: recurse each field with the produced-aware lowering (the struct fields may each
+    // ref a skippable node). Only handle the covered named-struct obj output.
+    if (node !== null && typeof node === "object" && !Array.isArray(node)) {
+        const keys = Object.keys(node);
+        if (keys.length === 1 && keys[0] === "obj" && expected && expected.kind === "named") {
+            const decl = findDecl(plan, expected.name);
+            const fields = node.obj;
+            const inits = decl.fields.map((f) => {
+                const sub = emitProducedAwareValue(fields[f.name], f.type, typedNodes, plan, skippable, skippableKind);
+                return `${goFieldName(f.name)}: ${sub.expr}`;
+            });
+            return { expr: `${expected.name}{${inits.join(", ")}}`, ref: expected };
+        }
+    }
+    // everything else (literal / non-skippable ref / obj-of-non-named / arr / concat) — delegate to
+    // the plain typed lowering (no skippable head reachable there in the covered corpus).
+    return emitTypedValue(node, expected, typedNodes, plan);
+}
+/** Lower a typed field-access expr to the EXPECTED output type (used in the produced branch). When
+ * the expected type is `opt` and the accessed value is already a *T pointer (the field itself is
+ * opt), pass it through; when the accessed value is a bare leaf and expected is opt, take its addr. */
+function valueLeafTyped(expr, ref, opt, expected) {
+    void opt;
+    if (expected && expected.kind === "opt") {
+        if (ref.kind === "opt")
+            return expr; // *T already
+        // wrap a bare value in a fresh pointer (matches renderTypeRef(opt)=*T).
+        return `func() ${renderTypeRef(expected)} { __v := ${expr}; return &__v }()`;
+    }
+    return expr;
+}
+/**
+ * goConnectionUnproduced — the unproduced rep for a SKIPPED relationKind:connection node (#93 shape
+ * 1): the empty connection {items:[],cursor:null}. The connection outType is a named struct whose
+ * serializer normalizes a nil items slice to [] and a nil cursor to null, so the struct ZERO
+ * (`Tn{}`) serializes to exactly unproducedValue("connection"). When the output field is opt
+ * (refOpt into the connection), run_behavior still writes the empty connection (never null), so we
+ * wrap the struct zero in a fresh pointer rather than yielding nil.
+ */
+function goConnectionUnproduced(nodeRef, expected) {
+    const connRef = expected && expected.kind === "opt" ? expected.inner : (expected ?? nodeRef);
+    const zero = goZero(connRef);
+    if (expected && expected.kind === "opt") {
+        return `func() ${renderTypeRef(expected)} { __c := ${zero}; return &__c }()`;
+    }
+    return zero;
+}
+/** Go zero value for a TypeRef (used as the error return of the struct runner). */
+function goZero(ref) {
+    switch (ref.kind) {
+        case "named":
+            return `${ref.name}{}`;
+        case "scalar":
+            switch (ref.scalar) {
+                case "string":
+                    return `""`;
+                case "int":
+                    return "0";
+                case "float":
+                    return "0";
+                case "bool":
+                    return "false";
+                case "null":
+                    return "nil";
+            }
+            return "nil";
+        case "arr":
+            return "nil";
+        case "opt":
+            return "nil";
+    }
+}
+// bc#90 / runtime-free: the nv* helper set (nvVE/nvBindVE/nvFieldVE/nvCatVE/nvArrVE) is REMOVED —
+// those were dslcontracts.Value-based; the covered plane now lowers every port to a native Go value
+// (emitPortInit) so no VE helper is emitted, and the module imports ZERO bc runtime.
+// ── native expression compiler backend (#108) — cond `if` / map `when` / cond branches ──────────
+//
+// The runtime-free native expression compiler (native-expr.ts) mirrors runBehavior's cond/guard
+// Expression evaluation with BYTE-EQUAL semantics. The value-dependent runtime failures (INT_OVERFLOW
+// / NAN_OR_INF / MOD_ZERO / PRECISION_LOSS / INVALID_LITERAL for a huge len) are emitted as calls to a
+// FIXED set of RUNTIME-FREE helper funcs baked into the module (bcExpr* below) — the covered module
+// still imports ZERO bc runtime. A fallible helper returns (T, *BehaviorError); the runner early-returns
+// the failure (its zero output value is `zeroOut`).
+let goExprTempSeq = 0;
+/** module-level accumulator: set true when the native-expr compiler emits a fallible helper call
+ * (so emit() includes the helper library + imports `math`). Reset at the start of each emit(). */
+const goExprUsed = { helpers: false };
+/** GoNativeExprBackend — renders native-expr for Go. `zeroOut` is the runner's error-return zero
+ * value; `resolveHead` maps a ref head (input port / input-array $as elem / prior node) to a typed
+ * base expr. Sets goExprUsed.helpers when a fallible helper is emitted (so emit() bakes the helper lib). */
+function makeGoExprBackend(zeroOut, resolveHead, plan) {
+    const used = goExprUsed;
+    return {
+        lang: "go",
+        freshTemp: () => `ex_${goExprTempSeq++}`,
+        renderType: (ref) => renderTypeRef(ref),
+        scalarType: (s) => goScalar(s),
+        strLit: (s) => JSON.stringify(s),
+        boolLit: (b) => (b ? "true" : "false"),
+        intLit: (dec) => `int64(${dec})`,
+        floatLit: (n) => `float64(${goFloatLitExpr(n)})`,
+        fieldAccess: (baseExpr, baseRef, path) => goTypedInternals.typedFieldAccess(baseExpr, baseRef, path, plan),
+        resolveHead,
+        hoistFallible: (temp, _ty, call) => {
+            used.helpers = true;
+            // a unique err var per hoist (Go `:=` re-declares fine in the same block only for NEW LHS; use a
+            // fresh err name to avoid "no new variables on left side of :=" when several hoists share a block).
+            const errv = `err_${goExprTempSeq++}`;
+            return [`${temp}, ${errv} := ${call}`, `if ${errv} != nil {`, `\treturn ${zeroOut}, ${errv}`, `}`];
+        },
+        helperCall: (helper, args) => {
+            used.helpers = true;
+            return `bcExpr_${helper}(${args.join(", ")})`;
+        },
+        binOp: (op, a, b) => `(${a} ${op} ${b})`,
+        concat: (parts) => {
+            // native string + concat (all parts are native strings) — no import needed.
+            return `(${parts.join(" + ")})`;
+        },
+        notOp: (a) => `(!${a})`,
+        structLit: (name, inits) => `${name}{${inits.map((i) => `${goFieldName(i.field)}: ${i.expr}`).join(", ")}}`,
+        arrLit: (elemTy, items) => `[]${elemTy}{${items.join(", ")}}`,
+        ternary: (cond, t, e, ty) => `func() ${ty} { if ${cond} { return ${t} }; return ${e} }()`,
+        shortCircuitBool: (op, temp, left, rStmts, rExpr) => {
+            // and: temp=false; if left { <rStmts>; temp=rExpr }.  or: temp=true; if !left { <rStmts>; temp=rExpr }.
+            const gate = op === "and" ? left : `!(${left})`;
+            const seed = op === "and" ? "false" : "true";
+            return [
+                `var ${temp} bool = ${seed}`,
+                `if ${gate} {`,
+                ...rStmts.map((s) => `\t${s}`),
+                `\t${temp} = ${rExpr}`,
+                `}`,
+            ];
+        },
+        condGuard: (temp, ty, cond, tStmts, tExpr, eStmts, eExpr) => [
+            `var ${temp} ${ty}`,
+            `if ${cond} {`,
+            ...tStmts.map((s) => `\t${s}`),
+            `\t${temp} = ${tExpr}`,
+            `} else {`,
+            ...eStmts.map((s) => `\t${s}`),
+            `\t${temp} = ${eExpr}`,
+            `}`,
+        ],
+    };
+}
+/** Go float literal (finite; matches goFloatLit convention used elsewhere). */
+function goFloatLitExpr(n) {
+    if (Number.isInteger(n))
+        return `${n}.0`;
+    return String(n);
+}
+/**
+ * emitExprHelpers — the FIXED runtime-free native-expr helper library (Go). Emitted once per covered
+ * module that uses any cond/guard/arith. Each helper is BYTE-EQUAL to the reference core in
+ * expr-eval.ts (checkI64 / checkFinite / mod trunc / div widen / code-point compare / lenCore). All
+ * failures are the LOCAL *BehaviorError with the SAME code strings as run_behavior.
+ */
+function emitExprHelpers() {
+    return `// ── native-expr runtime-free helper library (#108) — byte-equal to expr-eval.ts core ──
+const bcI64Max int64 = 9223372036854775807
+const bcI64Min int64 = -9223372036854775808
+
+func bcExpr_addI64(a, b int64) (int64, *BehaviorError) {
+	r := a + b
+	// signed overflow detection (a+b): same-sign operands, result flips sign.
+	if (a > 0 && b > 0 && r < 0) || (a < 0 && b < 0 && r > 0) {
+		return 0, &BehaviorError{Code: "INT_OVERFLOW", Message: "i64 overflow"}
+	}
+	return r, nil
+}
+func bcExpr_subI64(a, b int64) (int64, *BehaviorError) {
+	r := a - b
+	if (a >= 0 && b < 0 && r < 0) || (a < 0 && b > 0 && r >= 0) {
+		return 0, &BehaviorError{Code: "INT_OVERFLOW", Message: "i64 overflow"}
+	}
+	return r, nil
+}
+func bcExpr_mulI64(a, b int64) (int64, *BehaviorError) {
+	if a == 0 || b == 0 {
+		return 0, nil
+	}
+	r := a * b
+	if r/b != a || (a == bcI64Min && b == -1) {
+		return 0, &BehaviorError{Code: "INT_OVERFLOW", Message: "i64 overflow"}
+	}
+	return r, nil
+}
+func bcExpr_negI64(a int64) (int64, *BehaviorError) {
+	if a == bcI64Min {
+		return 0, &BehaviorError{Code: "INT_OVERFLOW", Message: "i64 overflow"}
+	}
+	return -a, nil
+}
+func bcExpr_checkFinite(v float64) (float64, *BehaviorError) {
+	if v != v || v > 1.7976931348623157e308 || v < -1.7976931348623157e308 {
+		return 0, &BehaviorError{Code: "NAN_OR_INF", Message: "non-finite float"}
+	}
+	return v, nil
+}
+func bcExpr_addF(a, b float64) (float64, *BehaviorError) { return bcExpr_checkFinite(a + b) }
+func bcExpr_subF(a, b float64) (float64, *BehaviorError) { return bcExpr_checkFinite(a - b) }
+func bcExpr_mulF(a, b float64) (float64, *BehaviorError) { return bcExpr_checkFinite(a * b) }
+func bcExpr_negF(a float64) (float64, *BehaviorError)    { return bcExpr_checkFinite(-a) }
+func bcExpr_modF(a, b float64) (float64, *BehaviorError) { m := math.Mod(a, b); return bcExpr_checkFinite(m) }
+func bcExpr_modI64(a, b int64) (int64, *BehaviorError) {
+	if b == 0 {
+		return 0, &BehaviorError{Code: "MOD_ZERO", Message: "int mod by zero"}
+	}
+	// Go % is truncated (sign of dividend) — matches modCore.
+	r := a % b
+	// overflow only at MinInt64 % -1 → 0 in Go (no overflow); still checkI64-safe.
+	return r, nil
+}
+func bcExpr_widenI64F(a int64) (float64, *BehaviorError) {
+	// div widening exact range is ±2^53 (WIDEN_EXACT). Outside → PRECISION_LOSS.
+	if a > 9007199254740992 || a < -9007199254740992 {
+		return 0, &BehaviorError{Code: "PRECISION_LOSS", Message: "int exceeds exact float range (±2^53)"}
+	}
+	return float64(a), nil
+}
+func bcExpr_divF(a, b float64) (float64, *BehaviorError) { return bcExpr_checkFinite(a / b) }
+func bcExpr_lenArr[T any](a []T) (int64, *BehaviorError) {
+	return int64(len(a)), nil
+}
+// code-point (UTF-8 rune) order comparison — matches cmpCodePoints (NOT UTF-16 / byte compare, which
+// Go's native string < already is for valid UTF-8, but we compare rune-by-rune to match exactly).
+func bcExpr_cmpCP(a, b string) int {
+	ra := []rune(a)
+	rb := []rune(b)
+	n := len(ra)
+	if len(rb) < n {
+		n = len(rb)
+	}
+	for i := 0; i < n; i++ {
+		if ra[i] != rb[i] {
+			if ra[i] < rb[i] {
+				return -1
+			}
+			return 1
+		}
+	}
+	if len(ra) == len(rb) {
+		return 0
+	}
+	if len(ra) < len(rb) {
+		return -1
+	}
+	return 1
+}
+func bcExpr_strLt(a, b string) bool { return bcExpr_cmpCP(a, b) < 0 }
+func bcExpr_strLe(a, b string) bool { return bcExpr_cmpCP(a, b) <= 0 }
+func bcExpr_strGt(a, b string) bool { return bcExpr_cmpCP(a, b) > 0 }
+func bcExpr_strGe(a, b string) bool { return bcExpr_cmpCP(a, b) >= 0 }`;
+}
+// ── BindNativeRaw dispatch surface ──────────────────────────────────────────────────────
+/** The struct dispatch surface: ComponentNamesNativeRaw + the per-component struct runners
+ * (RunNativeRawStruct_<comp>) ARE the exposed API. The consumer calls the struct runner directly
+ * (it returns the typed model — NO Value serialization on the read hot path, matching how graphddb
+ * reads: a model, never a boxed Value). There is deliberately NO Value dispatch map — that would
+ * require a Value serializer (the boxing residue bc#77 eliminates). A canonical Value observation
+ * (equivalence pin) is produced by the SEPARATE test-only observe companion (goTypedNativeObserve),
+ * which lives OUTSIDE this module so the covered module stays literal whole-file zero. */
+function emitStructSurface(native) {
+    return `// ComponentNamesNativeRaw — covered reads exposed on the combined struct-native path (declaration
+// order). Each is driven via RunNativeRawStruct_<comp>(handlers, input) -> (T, error): a STRUCT
+// return; the consumer keeps the model native (no Value serialization on the read hot path — the
+// boxing residue bc#77 removes). See INTEGRATION.md §6.
+var ComponentNamesNativeRaw = []string{${native.map((c) => JSON.stringify(c.name)).join(", ")}}`;
+}
+/** Minimal module header for a FULLY-covered module (bc#90 / runtime-free). A fully-covered module
+ * imports ZERO bc runtime (only the std-lib packages it genuinely uses: `fmt` for a batched-map
+ * 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) {
+    const sv = ctx.specVersions;
+    const imports = [];
+    if (needFmt)
+        imports.push(`\t"fmt"`);
+    if (needMath)
+        imports.push(`\t"math"`);
+    if (needStrings)
+        imports.push(`\t"strings"`);
+    if (needSync)
+        imports.push(`\t"sync"`);
+    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
+// componentRef); it is emitted ONLY as the combined native ports IN + raw struct OUT + inline
+// sequential runner below. There is NO generic Bind/dispatch/plan scaffolding AND NO bc-runtime import —
+// a fully-covered module is FULLY NATIVE (zero bc-runtime reference; only the std-lib it uses).
+
+package behaviors
+${importBlock}
+// ExpectedSpecVersions are the spec versions baked at generation time (provenance only — the module
+// is runtime-free, so there is no runtime SpecVersions to skew-check against, bc#90 / change #5).
+var ExpectedSpecVersions = map[string]int64{"behavior": ${sv.behavior}, "expression": ${sv.expression}, "plan": ${sv.plan}}`;
+}
+// ── module assembly ──────────────────────────────────────────────────────────────────
+function emit(ctx) {
+    // Fail closed if a covered read SHAPE lacks the typed annotations (no silent re-box).
+    for (const c of ctx.ir.components)
+        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;
+    // 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 = [];
+    for (const c of native) {
+        inStructs.push(emitInStruct(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)
+            typedNodes.set(n.id, deriveTypeRef(n.outType, plan));
+        for (const n of c.body) {
+            if ("map" in n) {
+                // #86 pt2 / #108: a map node emits an element ports struct + a batch struct. The element ports
+                // may read the `$as` binding — resolved via the over-element type (prior node / input array).
+                structs.push(emitMapPortsStructs(c, n, typedNodes, plan));
+            }
+            else if ("cond" in n) {
+                // #108: a cond node has NO ports struct (it is a pure Expression — no handler dispatch).
+            }
+            else {
+                structs.push(emitPortsStruct(c, n));
+            }
+        }
+        // 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).
+        const mm = emitMapElemMaterializers(c, typedNodes, plan);
+        if (mm)
+            elemCopiers.push(mm);
+        const r = emitNativeRawRunner(c, plan, flags);
+        runnerCodes.push(r.code);
+    }
+    const structSurface = emitStructSurface(native);
+    const behaviorErrorType = emitBehaviorErrorType();
+    // bc#87: a covered component with a real-concurrency stage emits sync.WaitGroup + a semaphore.
+    const needSync = native.some((c) => concurrencyPlan(c) !== null);
+    // bc#90: the ONLY std-lib `fmt.Sprintf` site on the covered plane is the batched-map result-count
+    // mismatch error — so `fmt` is imported iff a covered component has a batched map node.
+    const needFmt = native.some((c) => c.body.some((n) => "map" in n && n.map.batched === true));
+    // The FULLY-covered module (no non-native components) gets a MINIMAL, RUNTIME-FREE header — NO
+    // bc-runtime import at all (bc#90).
+    // FAIL CLOSED (bc#86/#89): the --typed-native (native codegen) surface is native-only. If ANY
+    // component is not a covered native read, we do NOT silently box it through the straight-line
+    // emitter (the old concealment) — we throw a LOUD GeneratorFailure naming every uncovered component
+    // and its specific reject reason. A fully-covered module (nonNative.length === 0) is unchanged: the
+    // minimal, runtime-free header.
+    if (nonNative.length > 0) {
+        const rejects = nonNative
+            .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 ` +
+            `box uncovered shapes. Implement native coverage for this shape, fix the spec if the shape is ` +
+            `genuinely runtime-dynamic, or generate this component on the --ir dynamic interpreter surface.`);
+    }
+    // #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);
+    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
+// 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).`;
+    const sections = [
+        banner,
+        `// Local concrete failure type (runtime-free) — a covered runner returns *BehaviorError (satisfies\n// error) instead of a bc-runtime failure, so the fully-covered module imports ZERO bc runtime.\n${behaviorErrorType}`,
+        decls ? `// Typed struct declarations (outType-derived; hash-dedup — shared type plan).\n${decls}` : undefined,
+        `// Per-component CONCRETE input structs (fields = inputPorts; the consumer builds them natively —\n// no generic *Obj crosses the covered read boundary).\n${inStructs.join("\n\n")}`,
+        rowStructs.some((r) => r.trim().length > 0)
+            ? `// CONCRETE per-node handler-result row structs (typed fields = the node's outType; + error signal).\n${rowStructs.filter((r) => r.trim().length > 0).join("\n\n")}`
+            : undefined,
+        `// Per-component CONCRETE handler interfaces (one typed Node_* method per covered node).\n${handlerIfaces.join("\n\n")}`,
+        elemCopiers.length
+            ? `// Augmented map-element copiers (over element fields + the concrete into row — pure assignment).\n${elemCopiers.join("\n\n")}`
+            : undefined,
+        structs.some((r) => r.trim().length > 0)
+            ? `// Native ports structs (one per componentRef node; typed per the static port type).\n${structs.filter((r) => r.trim().length > 0).join("\n\n")}`
+            : undefined,
+        goExprUsed.helpers
+            ? `// #108 native-expr helper library (runtime-free; byte-equal to expr-eval.ts core) — used by\n// cond / map-guard checked arithmetic. NO bc-runtime reference (failures use the LOCAL *BehaviorError).\n${emitExprHelpers()}`
+            : undefined,
+        `// Combined read runners (STRUCT-returning — the fully de-plumbed path).\n${runnerCodes.join("\n\n")}`,
+        structSurface,
+    ].filter((s) => !!s);
+    return `${header}\n\n${sections.join("\n\n")}\n`;
+}
+/**
+ * goTypedNativeObserve — the TEST-ONLY observe companion (a SEPARATE file in the SAME package as the
+ * covered module). It carries the typed->Value serializers (ser_*) + an ObserveNativeRaw dispatch
+ * that drives the module-private struct runner and serializes its result to a canonical Value for
+ * the equivalence pin. This lives OUTSIDE the covered module so the module stays literal whole-file
+ * zero (the ser_* NewObj is test glue, never on the consumer's read hot path). Emitted only for the
+ * fully-covered case (the equivalence harness); production consumers never use it.
+ */
+export function goTypedNativeObserve(ir, runtimeImport) {
+    const components = ir.components;
+    const native = components.filter(isNativeRaw);
+    const plan = buildTypePlan(ir);
+    const serializers = emitSerializers(plan);
+    const marshallers = goTypedInternals.emitMarshallers(plan);
+    const mustHelpers = emitMustHelpers(plan);
+    // arr/opt node materialize helpers (mustArr_*/mustOpt_*) for the concrete-row decode of a node whose
+    // whole outType is a bare arr/opt (materializeExpr emits mustArr_/mustOpt_ for those).
+    const arrOptHelpers = goTypedInternals.emitArrOptNodeHelpers({ ir }, plan);
+    const arms = native
+        .map((c) => {
+        const outRef = c.outputType !== undefined ? deriveTypeRef(c.outputType, plan) : undefined;
+        const ser = outRef ? serializeTyped("tv", outRef, plan) : "tv";
+        // 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}`;
+    })
+        .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 = [];
+    const methodImpls = [];
+    const emittedDecode = new Set();
+    for (const c of native) {
+        const typedNodes = new Map();
+        for (const n of c.body)
+            typedNodes.set(n.id, deriveTypeRef(n.outType, plan));
+        for (const n of c.body) {
+            if ("cond" in n)
+                continue; // #108: cond has no handler method (pure Expression) — no scripted impl.
+            const ref = typedNodes.get(n.id);
+            if ("map" in n) {
+                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) {
+	src, ok := s.next(${JSON.stringify(m.component)})
+	if !ok {
+		return ${batchT}{}, false
+	}
+	if src.isErr {
+		return ${batchT}{IsError: true, Err: src.err}, true
+	}
+	arr, _ := src.ok.([]${PKG}.Value)
+	rows := make([]${elemT}, 0, len(arr))
+	for _, ev := range arr {
+		rows = append(rows, ${elemDecode}(ev))
+	}
+	return ${batchT}{Rows: rows}, true
+}`);
+                }
+                else {
+                    methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, n.id)}(_ ${portsT}, _ ${mapBoundT}) (${elemT}, bool) {
+	src, ok := s.next(${JSON.stringify(m.component)})
+	if !ok {
+		return ${elemT}{}, false
+	}
+	if src.isErr {
+		return ${elemT}{IsError: true, Err: src.err}, true
+	}
+	return ${elemDecode}(src.ok), true
+}`);
+                }
+                void retT;
+                continue;
+            }
+            const node = n;
+            const rowT = rawRowStructName(c.name, node.id);
+            const decode = emitDecodeRow(c.name, node.id, rowT, ref, plan, emittedDecode, decodeFns, "");
+            const nodeBoundT = boundGoType(node, c, typedNodes, plan);
+            methodImpls.push(`func (s *ScriptedNativeRaw) ${nodeMethodName(c.name, node.id)}(_ ${portsStructName(c.name, node.id)}, _ ${nodeBoundT}) (${rowT}, bool) {
+	src, ok := s.next(${JSON.stringify(node.component)})
+	if !ok {
+		return ${rowT}{}, false
+	}
+	if src.isErr {
+		return ${rowT}{IsError: true, Err: src.err}, true
+	}
+	return ${decode}(src.ok), true
+}`);
+        }
+    }
+    const adapter = `// scriptSrc — a scripted per-component outcome (an ok Value or an error), drained in order.
+type scriptSrc struct {
+	isErr bool
+	err   string
+	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.
+type ScriptedNativeRaw struct {
+	mu     sync.Mutex
+	queues map[string][]scriptSrc
+	seen   int
+}
+
+// NewScriptedNativeRaw builds the concrete test handler from the JSON handlers spec (the SAME shape
+// the reference scriptedHandlers reads): { "<component>": {ok|error} | [ {ok|error}, … ] }. Each
+// component's ok Value is DecodeValue'd once here (test glue); the per-node method decodes it into the
+// concrete row. Returns the handler + any decode error (surfaced by the runner as a fatal).
+func NewScriptedNativeRaw(spec *${PKG}.JObj) (*ScriptedNativeRaw, error) {
+	queues := map[string][]scriptSrc{}
+	if spec != nil {
+		for _, comp := range spec.Keys {
+			var entries []${PKG}.JNode
+			switch t := spec.Vals[comp].(type) {
+			case []${PKG}.JNode:
+				entries = t
+			default:
+				entries = []${PKG}.JNode{t}
+			}
+			for _, e := range entries {
+				eo, _ := e.(*${PKG}.JObj)
+				if okNode, has := eo.Get("ok"); has {
+					val, derr := ${PKG}.DecodeValue(okNode)
+					if derr != nil {
+						return nil, derr
+					}
+					queues[comp] = append(queues[comp], scriptSrc{ok: val})
+					continue
+				}
+				ev, _ := eo.Get("error")
+				es, _ := ev.(string)
+				queues[comp] = append(queues[comp], scriptSrc{isErr: true, err: es})
+			}
+		}
+	}
+	return &ScriptedNativeRaw{queues: queues}, nil
+}
+
+// next drains one scripted outcome for a component (last entry repeats — mirrors the reference
+// scriptedHandlers), returns ok=false when the component has no scripted queue (fail-closed). The
+// bc#87 parallel-stage runner calls Node_* from multiple goroutines, so the drain is mutex-guarded.
+func (s *ScriptedNativeRaw) next(component string) (scriptSrc, bool) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.seen++
+	q, ok := s.queues[component]
+	if !ok || len(q) == 0 {
+		return scriptSrc{}, false
+	}
+	if len(q) > 1 {
+		v := q[0]
+		s.queues[component] = q[1:]
+		return v, true
+	}
+	return q[0], true
+}`;
+    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.
+package behaviors
+
+import (
+	"sync"
+
+	${PKG} "${runtimeImport ?? "github.com/foo-ogawa/behavior-contracts/go"}"
+)
+
+// 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).
+${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}
+
+// scriptedNativeRaw method impls (one per covered node — the concrete Node_* seam, test glue).
+${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) {
+${arms}
+	return nil, ${PKG}.NewBehaviorFailure("UNKNOWN_ENTRY", "component '"+name+"' is not a covered read (fail-closed)")
+}
+`;
+}
+/** emitDecodeRow — emit (once, deduped) a decoder `decodeRow_<comp>_<node><suffix>(v Value) <rowT>`
+ * that materializes the scripted ok Value into the concrete row struct (typed fields = the outType /
+ * elem-row type). Named: reuse the Value->struct marshaller + copy fields; scalar/arr/opt: materialize
+ * into .Val. TEST glue only (the production consumer decodes its own wire payload). */
+function emitDecodeRow(compName, nodeId, rowT, ref, plan, emitted, out, suffix) {
+    const fn = `decodeRow_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}${suffix}`;
+    if (emitted.has(fn))
+        return fn;
+    emitted.add(fn);
+    const lines = [];
+    lines.push(`func ${fn}(v ${PKG}.Value) ${rowT} {`);
+    lines.push(`\tvar out ${rowT}`);
+    if (ref.kind === "named") {
+        const decl = findDecl(plan, ref.name);
+        lines.push(`\tt := ${goTypedInternals.materializeExpr("v", ref, plan)}`);
+        for (const f of decl.fields) {
+            lines.push(`\tout.${goFieldName(f.name)} = t.${goFieldName(f.name)}`);
+        }
+    }
+    else {
+        lines.push(`\tout.Val = ${goTypedInternals.materializeExpr("v", ref, plan)}`);
+    }
+    lines.push(`\treturn out`);
+    lines.push(`}`);
+    out.push(lines.join("\n"));
+    return fn;
+}
+/**
+ * goTypedNativeEmitter — language id `go-typed-native` (bc#77). Emits the generic straight-line
+ * body (for non-covered components / helpers) plus the COMBINED READ layer (native ports struct
+ * IN + raw struct result OUT + inline sequential exec) and the BindNativeRaw surface. Requires
+ * outType/outputType on every covered read (fail-closed otherwise).
+ */
+export const goTypedNativeEmitter = {
+    language: "go-typed-native",
+    fileExtension: ".go",
+    defaultRuntimeImport: "github.com/foo-ogawa/behavior-contracts/go/coderuntime",
+    filenameHint: "behaviors.typed.native.generated.go",
+    emit,
+};
+//# sourceMappingURL=emit-typed-native-go.js.map