behavior-contracts 0.5.0 → 0.7.0

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

@@ -1,8 +1,9 @@
 import { GeneratorFailure } from "./core.js";
-import { goStraightlineInternals } from "./emit-straightline-go.js";
-import { goTypedInternals } from "./emit-straightline-typed-go.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 }`
@@ -47,7 +48,7 @@ function portsStructName(compName, nodeId) {
     // type to implement the per-component Handler_<comp> interface's concrete Node_* method signatures.
     return `PortsNR_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
 }
-function inferPortType(node, inputPorts) {
+function inferPortType(node, inputPorts, asBinding) {
     if (staticArrElems(node) !== null)
         return "Value";
     const e = classifyExpr(node);
@@ -58,6 +59,18 @@ function inferPortType(node, inputPorts) {
         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) {
@@ -77,6 +90,10 @@ function inferPortType(node, inputPorts) {
             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) {
@@ -102,13 +119,17 @@ function staticStringArrElems(node) {
  * Value-typed input) FAILS CLOSED — the covered read plane admits NO boxed escape (there is no
  * `dslcontracts.Value` fallback on the native module). `where` names the emission site for the error.
  */
-function portFieldGoType(node, inputPorts, where = "port") {
+function portFieldGoType(node, inputPorts, where = "port", asBinding, plan) {
     if (staticStringArrElems(node) !== null)
         return "[]string";
+    // #110: a componentRef port bound to a runtime array input port (with a resolvable elemType) → []ElemT.
+    const arrElem = portArrayElemRef(node, inputPorts, plan);
+    if (arrElem !== null)
+        return `[]${renderTypeRef(arrElem)}`;
     const num = numLiteralGoExpr(node);
     if (num !== null)
         return Number.isInteger(node) ? "int64" : "float64";
-    const ft = inferPortType(node, inputPorts);
+    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.`);
     }
@@ -123,6 +144,36 @@ function staticArrElems(node) {
     const arg = node.arr;
     return Array.isArray(arg) ? arg : null;
 }
+/**
+ * portArrayElemRef (#110) — resolve a componentRef input port that binds a RUNTIME ARRAY (an IN-list /
+ * array-bound WHERE head) to its native element TypeRef, or null when the port is not a covered array.
+ * The covered shape is a SINGLE-SEGMENT, non-opt `ref` into an INPUT ARRAY port that carries a resolvable
+ * `elemType` (scp-ir-architecture.md §5.2 / PortSchema.elemType — BC does NOT infer, consumer-interface
+ * C3). The port then lowers to a native `[]ElemT` field fed straight from `in.<Field>` — ZERO boxed Value
+ * on the read hot path. This REUSES the bc#108 `elemType` element lowering (deriveTypeRef over the input
+ * port's elemType), extended from the `map…over` element-source path to a plain componentRef port.
+ *
+ * A static string array is a DIFFERENT covered shape ([]string, staticStringArrElems) — handled ahead of
+ * this. An array port with NO resolvable elemType, an opt/multi-segment ref, or a non-array input schema
+ * resolves to null here → the caller keeps its existing fail-closed behaviour (never a silent box).
+ * Requires a TypePlan (an obj elemType maps to a named decl); without one it stays null (fail-closed).
+ */
+function portArrayElemRef(node, inputPorts, plan) {
+    if (plan === undefined)
+        return null;
+    if (staticStringArrElems(node) !== null)
+        return null; // the static-string-array port ([]string) — not this shape.
+    const e = classifyExpr(node);
+    if (e.kind !== "ref" || e.opt || e.path.length !== 1)
+        return null;
+    const schema = inputPorts?.[e.path[0]];
+    if (schema === undefined || (schema.type !== "array" && schema.type !== "arr"))
+        return null;
+    const et = schema.elemType;
+    if (et === undefined)
+        return null;
+    return deriveTypeRef(et, plan);
+}
 /**
  * isNativeRawComponent — a component covered by the combined read emitter. Strictly sequential
  * (no real concurrency), body is ALL componentRef (no map/cond), default 'fail'/'continue'
@@ -236,27 +287,35 @@ function isNativeRaw(comp) {
  * 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) {
+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: NON-batched map...into (per-element dispatch). #93
-    // shape 3: batched map with NO into (connection-collect / plain list). A `when` guard + into is
-    // still uncovered (heterogeneous elements — not one []T). A `when` guard WITHOUT into would be
-    // covered in principle but the covered corpus does not exercise it; keep it out to stay conservative.
-    if (m.when !== undefined)
+    // #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` must be a ref to a PRIOR BODY NODE's typed arr field (the de-box resolves the over element
-    // type from the parent node's typed struct — mapOverElemType). A map over an INPUT-param array is
-    // not covered here (its element type comes from inputPorts, not a typed node struct) — it falls
-    // through to the boxed typed / straight-line path.
+    // `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" || !bodyIds.has(overE.path[0]))
+    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]))
@@ -295,13 +354,21 @@ function coverageRejectReason(comp) {
     }
     const bodyIds = new Set(comp.body.map((b) => b.id));
     for (const n of comp.body) {
-        if ("cond" in n)
-            return `node '${n.id}' is a cond branch (not yet native-covered)`;
+        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 non-batched map...into / #93 shape 3 batched map NO
-            // into ARE covered (over a prior body node's typed arr); other map shapes fall through.
-            if (!coveredMapNode(n, bodyIds))
-                return `node '${n.id}' is a non-covered map shape (guarded/over-input)`;
+            // #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))
@@ -342,13 +409,13 @@ function assertTypedCoverage(comp) {
     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) {
+function emitPortsStruct(comp, node, asBinding, plan) {
     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));
+    const fieldTypes = portNames.map((p) => portFieldGoType(node.ports[p], comp.inputPorts, `port '${p}' of node '${node.id}'`, asBinding, plan));
     const fieldNames = portNames.map(goPortFieldName);
     const fields = portNames
         .map((p, i) => `\t${fieldNames[i]} ${fieldTypes[i]} // ${JSON.stringify(p)}`)
@@ -391,6 +458,14 @@ function rawElemStructName(compName, nodeId) {
 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, "_")}`;
@@ -404,6 +479,9 @@ function nodeMethodName(compName, nodeId) {
 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:
@@ -498,6 +576,8 @@ function emitHandlerInterface(comp, typedNodes, plan) {
     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) {
@@ -524,10 +604,15 @@ function mapElemMaterializerName(compName, nodeId) {
  * 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) {
+function emitMapPortsStructs(comp, node, typedNodes, plan) {
     const m = node.map;
     const structName = portsStructName(comp.name, node.id);
-    const elemStruct = emitPortsStruct(comp, { id: node.id, component: m.component, ports: m.ports });
+    // #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, plan);
     const batchStruct = `${structName}_batch`;
     return `${elemStruct}
 
@@ -596,19 +681,35 @@ function emitMapElemMaterializers(comp, typedNodes, plan) {
     }
     return parts.join("\n\n");
 }
-/** The Go type of the over-element (the parent collection element) for a covered map node. `over`
- * is a static ref to a prior node's arr<named> field (or an input array). We resolve it via the
- * parent node's typed struct field type. */
-function mapOverElemType(comp, node, typedNodes, plan) {
+/**
+ * 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 { ref } = goTypedInternals.typedFieldAccess(typedLocal(e.path[0]), baseRef, e.path.slice(1), plan);
+        const { expr, ref } = goTypedInternals.typedFieldAccess(typedLocal(e.path[0]), baseRef, e.path.slice(1), plan);
         if (ref.kind === "arr")
-            return renderTypeRef(ref.elem);
+            return { elemRef: ref.elem, overExpr: expr };
     }
-    throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go combined map (#86 pt2): map '${node.id}' 'over' must be a ref to a prior node's typed arr field (got ${JSON.stringify(m.over)}).`);
+    // 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)
@@ -663,8 +764,8 @@ function reconstructG(e) {
 function inStructName(compName) {
     return `In_${sanitize(compName)}`;
 }
-/** Go type for an input port's declared type (scalar → concrete; anything else → Value). */
-function inputPortGoType(schema) {
+/** 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";
@@ -674,6 +775,15 @@ function inputPortGoType(schema) {
             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`;
     }
@@ -695,14 +805,14 @@ function inputScalarKind(schema) {
 }
 /** 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) {
+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]));
+    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
@@ -722,7 +832,7 @@ ${fields}
  * 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) {
+function emitInDecoder(comp, plan) {
     const name = inStructName(comp.name);
     const ports = Object.keys(comp.inputPorts ?? {});
     const lines = [];
@@ -739,8 +849,28 @@ function emitInDecoder(comp) {
     lines.push(`\t}`);
     for (const p of ports) {
         const field = goFieldName(p);
-        const scalar = inputScalarKind(comp.inputPorts[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`);
         }
@@ -812,8 +942,18 @@ function emitNativeScalar(node, want, resolveRef) {
  * plane — a boxed escape would re-introduce the bc-runtime coupling this module removes). Returns the
  * struct field initializer (`Field: <expr>`). `resolveRef` resolves a ref head for the scalar path.
  */
-function emitPortInit(pn, expr, fieldGoType, resolveRef) {
+function emitPortInit(pn, expr, fieldGoType, resolveRef, inputPorts, plan) {
     const fieldName = goPortFieldName(pn);
+    // #110: a componentRef port bound to a runtime array input port (with elemType) → the native []ElemT,
+    // read straight from the concrete input struct (`in.<Field>`) — ZERO boxed Value on the read hot path.
+    // The over-elem/element-source case (map…over) already resolves via mapOverElemInfo; this is the plain
+    // componentRef port (an IN-list / array-bound WHERE head).
+    if (inputPorts !== undefined && portArrayElemRef(expr, inputPorts, plan) !== null) {
+        const e = classifyExpr(expr);
+        if (e.kind === "ref" && e.path.length === 1) {
+            return `${fieldName}: in.${goFieldName(e.path[0])}`;
+        }
+    }
     // change #2: a static string array (projection) → a native `[]string{...}` literal.
     const strArr = staticStringArrElems(expr);
     if (strArr !== null) {
@@ -899,8 +1039,8 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
         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));
+            const fieldGoType = portFieldGoType(expr, comp.inputPorts, `port '${pn}' of node '${node.id}'`, undefined, plan);
+            inits.push(emitPortInit(pn, expr, fieldGoType, resolveRef, comp.inputPorts, plan));
         }
         lines.push(`${ind}ps_${s} = ${structName}{${inits.join(", ")}}`);
         lines.push(`${ind}run_${s} = true`);
@@ -985,7 +1125,7 @@ function emitNativeRawRunner(comp, plan, flags) {
     const outStructType = outRef ? renderTypeRef(outRef) : `${PKG}.Value`;
     const zeroOut = outRef ? goZero(outRef) : "nil";
     const lines = [];
-    lines.push(`// run_native_raw_struct_${fn} — the STRUCT-RETURNING combined read (bc#77/#87): the fully`);
+    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`);
@@ -1001,7 +1141,7 @@ function emitNativeRawRunner(comp, plan, flags) {
     // 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 run_native_raw_struct_${fn}[H ${handlerIfaceName(comp.name)}](handlers H, in ${inStructName(comp.name)}) (${outStructType}, error) {`);
+    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
@@ -1057,6 +1197,13 @@ function emitNativeRawRunner(comp, plan, flags) {
             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);
@@ -1101,8 +1248,8 @@ function emitNativeRawRunner(comp, plan, flags) {
         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));
+            const fieldGoType = portFieldGoType(expr, comp.inputPorts, `port '${pn}' of node '${node.id}'`, undefined, plan);
+            inits.push(emitPortInit(pn, expr, fieldGoType, resolveRef, comp.inputPorts, plan));
         }
         lines.push(`${indent}ports_${s} := ${structName}{${inits.join(", ")}}`);
         const oc = `row_${s}`;
@@ -1174,22 +1321,37 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, f
     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;
-    const overElemGo = mapOverElemType(comp, node, typedNodes, plan);
-    // over element type ref (for $as field access): resolve the parent field's arr element type.
-    const overE = classifyExpr(m.over);
-    const overParent = overE.kind === "ref" ? overE.path[0] : "";
-    const overBaseRef = typedNodes.get(overParent);
-    const { expr: overExpr, ref: overRef } = goTypedInternals.typedFieldAccess(typedLocal(overParent), overBaseRef, overE.kind === "ref" ? overE.path.slice(1) : [], plan);
-    const overElemRef = overRef.elem;
+    // 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) => {
@@ -1233,9 +1395,10 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, f
                 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}'`);
-            inits.push(emitPortInit(pn, m.ports[pn], fieldGoType, resolveRef));
+            const fieldGoType = portFieldGoType(m.ports[pn], comp.inputPorts, `map port '${pn}' of node '${node.id}'`, asBinding, plan);
+            inits.push(emitPortInit(pn, m.ports[pn], fieldGoType, resolveRef, comp.inputPorts, plan));
         }
         out.push(`${il}ep_${s} := ${structName}{${inits.join(", ")}}`);
         return out;
@@ -1254,41 +1417,69 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, f
     lines.push(`${indent}over_${s} := ${overExpr}`);
     lines.push(`${indent}${typedLocal(node.id)} = make(${elemGo}, 0, len(over_${s}))`);
     const elemRowRef = mapElemRowRef(node, arrRef, plan);
+    // 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): build all ports, dispatch ONCE. The concrete
-        // Node_* returns RawRow_<comp>_<node>{IsError, Err, Rows []RawElem_} aligned to the over items.
+        // 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 over => empty result (handler not called), matching run_behavior.
+        // empty items => empty result (handler not called), matching run_behavior.
         lines.push(`${indent}if len(items_${s}) > 0 {`);
         lines.push(`${indent}\tbp_${s} := ${batchStruct}{Items: items_${s}}`);
         lines.push(`${indent}\tmo_${s}, mo_${s}Resolved := handlers.${nodeMethodName(comp.name, node.id)}(bp_${s}, nil)`);
         lines.push(`${indent}\tif !mo_${s}Resolved {`, `${indent}\t\treturn ${zeroOut}, ${goErr("UNKNOWN_COMPONENT", `"component '${m.component}' has no handler (fail-closed)"`)}`, `${indent}\t}`);
         lines.push(`${indent}\tif mo_${s}.IsError {`, `${indent}\t\treturn ${zeroOut}, ${goErr("OP_FAILED", `"operation '${node.id}' failed under 'fail' policy: "+mo_${s}.Err`)}`, `${indent}\t}`);
         lines.push(`${indent}\tif len(mo_${s}.Rows) != len(items_${s}) {`, `${indent}\t\treturn ${zeroOut}, ${goErr("MAP_BATCH_RESULT_MISMATCH", `fmt.Sprintf("map '${node.id}': batched handler must return a list aligned to items (want %d)", len(items_${s}))`)}`, `${indent}\t}`);
-        lines.push(`${indent}\tfor mk_${s} := range over_${s} {`);
         if (hasInto) {
-            // #86 pt2: zip-attach the into field onto each over element (augmented element copier).
-            lines.push(`${indent}\t\tel_${s} := ${elemMat}(over_${s}[mk_${s}], mo_${s}.Rows[mk_${s}])`);
+            // #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: collect each element DIRECTLY from the concrete per-element row (field copy).
+            // #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}\t\t${typedLocal(node.id)} = append(${typedLocal(node.id)}, el_${s})`);
-        lines.push(`${indent}\t}`);
         lines.push(`${indent}}`);
     }
     else {
-        // #93 shape 2: NON-batched map...into — dispatch the child handler ONCE PER ELEMENT (N physical
-        // requests, matching run_behavior's per-element loop). The concrete Node_* returns ONE RawElem_.
+        // #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
@@ -1317,6 +1508,76 @@ function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, zeroOut, f
 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
@@ -1433,9 +1694,190 @@ function goZero(ref) {
 // 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
- * (run_native_raw_struct_<comp>) ARE the exposed API. The consumer calls the struct runner directly
+ * (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
@@ -1443,7 +1885,7 @@ function goZero(ref) {
  * 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 run_native_raw_struct_<comp>(handlers, input) -> (T, error): a STRUCT
+// 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(", ")}}`;
@@ -1453,11 +1895,13 @@ var ComponentNamesNativeRaw = []string{${native.map((c) => JSON.stringify(c.name
  * mismatch Sprintf, `strings` for a concat builder, `sync` for a parallel stage). ExpectedSpecVersions
  * stays as a local `var` for provenance, but the old `dslcontracts.SpecVersions` skew `init()` is GONE
  * (change #5 — there is no runtime to skew against once the module is runtime-free). */
-function emitMinimalHeader(ctx, needStrings, needSync, needFmt) {
+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)
@@ -1484,6 +1928,9 @@ function emit(ctx) {
     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 = [];
@@ -1493,18 +1940,23 @@ function emit(ctx) {
     const elemCopiers = [];
     const runnerCodes = [];
     for (const c of native) {
-        inStructs.push(emitInStruct(c));
+        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: a map node emits an element ports struct + a batch struct (Items []Value of the
-                // per-element native ports structs; no key-value object in the accessor).
-                structs.push(emitMapPortsStructs(c, 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));
+                structs.push(emitPortsStruct(c, n, undefined, plan));
             }
-            typedNodes.set(n.id, deriveTypeRef(n.outType, plan));
         }
         // CONCRETE per-node row structs + the per-component handler interface (the fully-concrete seam).
         rowStructs.push(emitRawRowStructs(c, typedNodes, plan));
@@ -1539,7 +1991,10 @@ function emit(ctx) {
             `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.`);
     }
-    const header = emitMinimalHeader(ctx, false, needSync, needFmt);
+    // #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
@@ -1551,7 +2006,7 @@ function emit(ctx) {
 // *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 run_native_raw_struct_<comp> (the consumer
+// (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 = [
@@ -1559,12 +2014,19 @@ function emit(ctx) {
         `// 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")}`,
-        `// CONCRETE per-node handler-result row structs (typed fields = the node's outType; + error signal).\n${rowStructs.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,
-        `// Native ports structs (one per componentRef node; typed per the static port type).\n${structs.join("\n\n")}`,
+        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);
@@ -1595,12 +2057,12 @@ export function goTypedNativeObserve(ir, runtimeImport) {
         // decode the generic *Obj input into the CONCRETE In_<comp> struct (test glue — ONE decode at the
         // top, OUTSIDE the covered hot path; a REQUIRED declared input is present so an absent key is a
         // fail-closed decode error surfaced here, never on the native runner path).
-        return `\tif name == ${JSON.stringify(c.name)} {\n\t\tin, ierr := decode_${inStructName(c.name)}(input)\n\t\tif ierr != nil {\n\t\t\treturn nil, ierr\n\t\t}\n\t\ttv, err := run_native_raw_struct_${sanitize(c.name)}(handlers, in)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\treturn ${ser}, nil\n\t}`;
+        return `\tif name == ${JSON.stringify(c.name)} {\n\t\tin, ierr := decode_${inStructName(c.name)}(input)\n\t\tif ierr != nil {\n\t\t\treturn nil, ierr\n\t\t}\n\t\ttv, err := ${runnerName(c.name)}(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)).join("\n\n");
+    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`;
@@ -1621,6 +2083,8 @@ ${native.map((c) => `\t${handlerIfaceName(c.name)}`).join("\n")}
         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;
@@ -1788,7 +2252,7 @@ ${constraintDecl}
 ${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 run_native_raw_struct_* call is
+// 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) {