behavior-contracts 0.3.0 → 0.5.0

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

@@ -0,0 +1,835 @@
+import { goStraightlineEmitter, goStraightlineInternals } from "./emit-straightline-go.js";
+import { buildComponentPlan, sequentialOrder, analyzeSequentialOps, classifyExpr, } from "./straightline.js";
+const PKG = "dslcontracts";
+const { sanitize, emitExpr } = goStraightlineInternals;
+/** Go struct field name for a wire port name (exported, deterministic). */
+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;
+}
+/** Native ports struct type name for a node (component + node id, module-unique). */
+function portsStructName(compName, nodeId) {
+    return `ports_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
+}
+/** Local var name for an evaluated port value. */
+function portLocal(nodeId, portName) {
+    return `pv_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}_${portName.replace(/[^A-Za-z0-9_]/g, "_")}`;
+}
+/**
+ * inferPortType — derive the static Go field type of a port from its wired expression and the
+ * entry component's inputPorts (the only declared types available; the callee is a catalog
+ * reference, not in the IR). Conservative: only a shape we can PROVE the type of is typed;
+ * everything else is a dynamic `Value` field (still no map). This is the documented dynamic
+ * port fallback.
+ */
+function inferPortType(node, inputPorts) {
+    // A static arr port is a `[]dslcontracts.Value` — carried in a boxed `Value` struct field
+    // (still no map, no ArrNative closure slice; built by direct []Value{...} assignment).
+    if (staticArrElems(node) !== null)
+        return "Value";
+    const e = classifyExpr(node);
+    return inferFromStatic(e, inputPorts);
+}
+function inferFromStatic(e, inputPorts) {
+    switch (e.kind) {
+        case "str":
+            return "string";
+        case "bool":
+            return "bool";
+        case "concat":
+            // concat always yields a string (or fails TYPE_MISMATCH at runtime via the primitive).
+            return "string";
+        case "ref": {
+            // A single-segment ref to a declared input param carries that param's type.
+            if (e.path.length === 1) {
+                const schema = inputPorts[e.path[0]];
+                if (schema) {
+                    switch (schema.type) {
+                        case "string":
+                            return "string";
+                        case "int":
+                            return "int64";
+                        case "float":
+                            return "float64";
+                        case "bool":
+                            return "bool";
+                    }
+                }
+            }
+            return "Value";
+        }
+        case "null":
+        case "dynamic":
+        default:
+            return "Value";
+    }
+}
+/**
+ * A port is "infallible-literal" when it is a string/bool/null literal — it cannot produce an
+ * expression Failure, so it needs NO error check (no slVE wrapper, no dead branch). Everything
+ * else (ref, concat, dynamic operator) keeps a direct error return.
+ */
+function isInfallibleLiteral(node) {
+    const e = classifyExpr(node);
+    return e.kind === "str" || e.kind === "bool" || e.kind === "null";
+}
+/** Go literal for an infallible literal expression. */
+function goLiteral(node) {
+    if (node === null)
+        return "nil";
+    if (typeof node === "boolean")
+        return node ? "true" : "false";
+    if (typeof node === "string")
+        return JSON.stringify(node);
+    return "nil";
+}
+/**
+ * A component is native-emittable when it is the clean read/write HOT PATH the owner cites:
+ *   - strictly sequential (no RunPlan / real concurrency),
+ *   - every body node is a plain componentRef (no map/cond),
+ *   - no bindField (skip-on-null-binding needs the generic skip-propagation machinery),
+ *   - default 'fail' policy on every node (continue/retry skip semantics stay on the generic path),
+ *   - no relationKind (unproduced/connection shaping stays on the generic path),
+ *   - every port expr and the output are STATICALLY resolvable (literal / ref / concat) — a
+ *     dynamic operator (coalesce/cond/arith/obj/arr/…) in a port OR the output keeps the whole
+ *     component on the generic path (its fail-closed semantics live in the primitive SSoT, and
+ *     skip/unproduced interplay with those operators is subtle — we do NOT half-cover it).
+ * Anything else falls through to the generic straight-line Bind (correct, just not de-plumbed).
+ * This is fail-closed conservative: the native path only claims components it can de-plumb with
+ * PROVABLE run_behavior equivalence (the conformance gate compiles + compares every one).
+ */
+function isNativeComponent(comp) {
+    if (sequentialOrder(comp) === null)
+        return false;
+    for (const n of comp.body) {
+        if (!("component" in n) || "map" in n || "cond" in n)
+            return false;
+        const cr = n;
+        if (cr.bindField !== undefined)
+            return false;
+        if (cr.relationKind !== undefined)
+            return false;
+        if (cr.policy !== undefined && cr.policy !== "fail")
+            return false;
+        for (const p of Object.keys(cr.ports))
+            if (!isStaticallyResolvable(cr.ports[p]))
+                return false;
+    }
+    return isStaticallyResolvable(comp.output);
+}
+/**
+ * isNativeMapComponent — a component whose body is a SINGLE `map` node is native-eligible when:
+ *   - the map's `over` is a ref (statically resolvable to an input param / prior node — here the
+ *     single-node case means an input param),
+ *   - every per-element port is statically resolvable (literal / ref-into-element / concat /
+ *     static arr) — refs into the element binding (`as`) resolve to the element native local,
+ *   - no `when` guard, no `into` zip-attach (those keep the generic path — element/kept
+ *     alignment with guard/into interplay stays single-sourced),
+ *   - default 'fail' policy, no relationKind,
+ *   - the output is statically resolvable (a ref to the map node result).
+ * The batched vs per-element dispatch, MAP_OVER_NOT_ARRAY / MAP_BATCH_RESULT_MISMATCH, and the
+ * kept/collected alignment are reproduced EXACTLY by emitNativeMapRunner — only the per-element
+ * ports CONTAINER + dispatch go native. Everything else stays on the generic path.
+ */
+function isNativeMapComponent(comp) {
+    if (sequentialOrder(comp) === null)
+        return false;
+    if (comp.body.length !== 1)
+        return false;
+    const n = comp.body[0];
+    if (!("map" in n))
+        return false;
+    const m = n.map;
+    if (m.when !== undefined)
+        return false;
+    if (m.into !== undefined)
+        return false;
+    if (m.relationKind !== undefined)
+        return false;
+    if (m.policy !== undefined && m.policy !== "fail")
+        return false;
+    // `over` must be a plain ref (to an input param — single-node component has no prior node).
+    if (classifyExpr(m.over).kind !== "ref")
+        return false;
+    for (const p of Object.keys(m.ports))
+        if (!isStaticallyResolvable(m.ports[p]))
+            return false;
+    return isStaticallyResolvable(comp.output);
+}
+/** A native component (sequential componentRef OR single map-write). */
+function isNative(comp) {
+    return isNativeComponent(comp) || isNativeMapComponent(comp);
+}
+/**
+ * staticArrElems — if `node` is a single-key `{arr:[...]}` shape, return its element nodes;
+ * else null. classifyExpr keeps `arr` as `dynamic` (its fail-closed construction lives in the
+ * primitive SSoT), so we recognize the STATIC arr shape here (every element itself static) and
+ * build it by direct `[]Value{...}` assignment — NOT the generic ArrNative(closure-slice) path.
+ */
+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;
+}
+/**
+ * A node is statically resolvable when it is a literal / ref / refOpt / concat (of the same),
+ * OR a static `arr` whose every element is itself statically resolvable (built by direct
+ * `[]dslcontracts.Value{...}` assignment, no ArrNative closure slice).
+ */
+function isStaticallyResolvable(node) {
+    const arr = staticArrElems(node);
+    if (arr !== null)
+        return arr.every(isStaticallyResolvable);
+    const e = classifyExpr(node);
+    switch (e.kind) {
+        case "str":
+        case "bool":
+        case "null":
+        case "ref":
+            return true;
+        case "concat":
+            return e.parts.every((p) => isStaticallyResolvable(reconstruct(p)));
+        case "dynamic":
+        default:
+            return false;
+    }
+}
+/** Emit the native ports struct + PortReader for one componentRef node. */
+function emitPortsStruct(comp, node) {
+    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}' (component ${node.component}); no ports.\ntype ${structName} struct{}\n\nfunc (p ${structName}) Port(string) (${PKG}.Value, bool) { return nil, false }`;
+    }
+    const fieldTypes = portNames.map((p) => inferPortType(node.ports[p], comp.inputPorts));
+    const fieldNames = portNames.map(goPortFieldName);
+    const nameW = Math.max(...fieldNames.map((n) => n.length));
+    const typeW = Math.max(...fieldTypes.map((t) => (t === "Value" ? `${PKG}.Value`.length : t.length)));
+    const fields = portNames
+        .map((p, i) => {
+        const gt = fieldTypes[i] === "Value" ? `${PKG}.Value` : fieldTypes[i];
+        return `\t${fieldNames[i].padEnd(nameW)} ${gt.padEnd(typeW)} // ${JSON.stringify(p)}`;
+    })
+        .join("\n");
+    // PortReader: box ONE field on demand (uniform read for consumers that do not type-switch).
+    const cases = portNames
+        .map((p, i) => `\tcase ${JSON.stringify(p)}:\n\t\treturn ${fieldTypes[i] === "Value" ? "p." + fieldNames[i] : `${PKG}.Value(p.${fieldNames[i]})`}, true`)
+        .join("\n");
+    return `// ${structName} — NATIVE ports for node '${node.id}' (component ${node.component}). Typed fields per the
+// static port type; built by direct field assignment (no map alloc, no per-port boxing).
+type ${structName} struct {
+${fields}
+}
+
+// Port implements dslcontracts.PortReader (boxes ONE field on demand; the hot-path consumer
+// type-switches to this concrete struct and reads the typed fields with zero boxing instead).
+func (p ${structName}) Port(name string) (${PKG}.Value, bool) {
+	switch name {
+${cases}
+	}
+	return nil, false
+}`;
+}
+/**
+ * emitNativeRunner — the native-ports straight-line exec for one native component. Ports are
+ * evaluated (fallible ones with a direct error return; literals inline), the native struct is
+ * built by direct assignment, and the handler is called via ExecNativeHandler. The result of
+ * each node is a RawValue (native-backed); ref reads between nodes read the accumulated native
+ * node results (bc#74 cross-node ref — resolved from the native result, not a dynamic scope).
+ */
+function emitNativeRunner(comp) {
+    const order = sequentialOrder(comp);
+    const metas = analyzeSequentialOps(buildComponentPlan(comp, goStraightlineInternals.dialect, "scope").opsLiteral, order);
+    const fn = sanitize(comp.name);
+    // Node results live in native locals (a RawValue per node). #74: a later node's port ref to
+    // an earlier node's field reads THIS local directly — the native analogue of the straight-
+    // line node-result scope, with NO dynamic *Obj scope object built at all (so the residual map
+    // alloc is gone too). A ref head resolves statically to nr_<id> (prior node) or an input.Get.
+    const nodeResult = (id) => `nr_${id.replace(/[^A-Za-z0-9_]/g, "_")}`;
+    const idToPos = new Map();
+    order.forEach((opIdx, k) => idToPos.set(comp.body[opIdx].id, k));
+    // A ref head is a prior node if it names a body node executed before position `atPos`.
+    const priorNodeAt = (head, atPos) => {
+        const p = idToPos.get(head);
+        return p !== undefined && p < atPos;
+    };
+    const lines = [];
+    lines.push(`// run_native_${fn} — NATIVE-PORTS straight-line exec (bc 0.5.0): each componentRef builds a native`);
+    lines.push(`// ports struct by direct field assignment (no map container, no slVE wrapper) and dispatches via`);
+    lines.push(`// ExecNativeHandler. Node results are native locals; cross-node refs read them directly (#74) —`);
+    lines.push(`// no dynamic scope *Obj is ever built, so a single-op point read allocates only the escaping struct.`);
+    lines.push(`func run_native_${fn}(handlers ${PKG}.NativeComponentExec, input *${PKG}.Obj) (${PKG}.Value, error) {`);
+    // NOTE: no `input = NewObj()` nil-normalization — nvBindVE is nil-safe, so a native module
+    // allocates ZERO generic *Obj. (A pure-native module has NO NewObj/Set anywhere — grep gate.)
+    for (const k of order.keys()) {
+        const i = order[k];
+        const node = comp.body[i];
+        const meta = metas[i];
+        const structName = portsStructName(comp.name, node.id);
+        const portNames = Object.keys(node.ports);
+        lines.push(`\t// ── op '${node.id}' (${node.component}) ──`);
+        const inits = [];
+        for (const pn of portNames) {
+            const expr = node.ports[pn];
+            const fieldName = goPortFieldName(pn);
+            const ftype = inferPortType(expr, comp.inputPorts);
+            if (isInfallibleLiteral(expr)) {
+                inits.push(`${fieldName}: ${goLiteral(expr)}`);
+                continue;
+            }
+            const local = portLocal(node.id, pn);
+            const resolved = emitStaticRefValue(expr, k, priorNodeAt, nodeResult, lines, local);
+            if (resolved) {
+                // resolved is a Go expr producing (Value); errors already handled inline.
+                if (ftype === "Value") {
+                    inits.push(`${fieldName}: ${resolved}`);
+                }
+                else {
+                    lines.push(`\t${local}T, ${local}Ok := (${resolved}).(${ftype})`);
+                    lines.push(`\tif !${local}Ok {`, `\t\treturn nil, ${PKG}.NewExprFailure("TYPE_MISMATCH", "port ${pn}: expected ${ftype}, got "+${PKG}.TypeName(${resolved}))`, `\t}`);
+                    inits.push(`${fieldName}: ${local}T`);
+                }
+                continue;
+            }
+            // Genuinely dynamic (multi-arg operator etc.): fall back to the primitive SSoT with an
+            // ephemeral scope built ONLY for this expression (rare; keeps semantics single-sourced).
+            lines.push(`\t${local}Scope := ${PKG}.NewObj()`);
+            lines.push(`\tfor _, sk := range input.Keys {`, `\t\t${local}Scope.Set(sk, input.Vals[sk])`, `\t}`);
+            for (let pj = 0; pj < k; pj++) {
+                const priorId = comp.body[order[pj]].id;
+                lines.push(`\t${local}Scope.Set(${JSON.stringify(priorId)}, ${nodeResult(priorId)})`);
+            }
+            lines.push(`\t${local}, ${local}Err := ${emitExpr(expr, `${local}Scope`)}`);
+            lines.push(`\tif ${local}Err != nil {`, `\t\treturn nil, ${local}Err`, `\t}`);
+            if (ftype === "Value") {
+                inits.push(`${fieldName}: ${local}`);
+            }
+            else {
+                lines.push(`\t${local}T, ${local}Ok := ${local}.(${ftype})`);
+                lines.push(`\tif !${local}Ok {`, `\t\treturn nil, ${PKG}.NewExprFailure("TYPE_MISMATCH", "port ${pn}: expected ${ftype}, got "+${PKG}.TypeName(${local}))`, `\t}`);
+                inits.push(`${fieldName}: ${local}T`);
+            }
+        }
+        lines.push(`\tports_${sanitize(node.id)} := ${structName}{${inits.join(", ")}}`);
+        const oc = `o_${sanitize(node.id)}`;
+        lines.push(`\t${oc}, ${oc}Resolved := ${PKG}.ExecNativeHandler(handlers, ${JSON.stringify(node.id)}, ${JSON.stringify(node.component)}, ports_${sanitize(node.id)}, nil)`);
+        lines.push(`\tif !${oc}Resolved {`, `\t\treturn nil, ${PKG}.NewBehaviorFailure("UNKNOWN_COMPONENT", "component '${node.component}' has no handler (fail-closed)")`, `\t}`);
+        if (meta.policy === "continue") {
+            lines.push(`\tvar ${nodeResult(node.id)} ${PKG}.Value = nil`);
+            lines.push(`\tif !${oc}.IsError {`, `\t\t${nodeResult(node.id)} = ${oc}.Ok`, `\t}`);
+        }
+        else {
+            lines.push(`\tif ${oc}.IsError {`);
+            const policy = meta.policy === "retry" ? "retry' policy (exhausted)" : "fail' policy";
+            lines.push(`\t\treturn nil, ${PKG}.NewPlanFailure("OP_FAILED", "operation '${node.id}' failed under '${policy}: "+${oc}.Err)`);
+            lines.push(`\t}`);
+            lines.push(`\t${nodeResult(node.id)} := ${oc}.Ok`, `\t_ = ${nodeResult(node.id)}`);
+        }
+    }
+    // output: statically resolve the ref/concat to node-result locals / input; dynamic falls back.
+    const outResolved = emitStaticRefValue(comp.output, order.length, priorNodeAt, nodeResult, lines, "out");
+    if (outResolved) {
+        lines.push(`\treturn ${outResolved}, nil`);
+    }
+    else {
+        lines.push(`\toutScope := ${PKG}.NewObj()`);
+        lines.push(`\tfor _, sk := range input.Keys {`, `\t\toutScope.Set(sk, input.Vals[sk])`, `\t}`);
+        for (const opIdx of order) {
+            const id = comp.body[opIdx].id;
+            lines.push(`\toutScope.Set(${JSON.stringify(id)}, ${nodeResult(id)})`);
+        }
+        lines.push(`\toutV, outErr := ${emitExpr(comp.output, "outScope")}`);
+        lines.push(`\tif outErr != nil {`, `\t\treturn nil, outErr`, `\t}`);
+        lines.push(`\treturn outV, nil`);
+    }
+    lines.push(`}`);
+    return lines.join("\n");
+}
+/**
+ * emitMapStaticVE — the slVE-equivalent for a map element port: a ref whose head is the element
+ * binding (`as`) reads the element native local via nvOkVE(<elVar>); any other ref head reads an
+ * input param via nvBindVE(input, head). literal/concat/nested compose the same as emitStaticVE.
+ * Returns null only for a genuinely dynamic operator (guarded out by isNativeMapComponent).
+ */
+function emitMapStaticVE(node, asName, elVar) {
+    const e = classifyExpr(node);
+    switch (e.kind) {
+        case "str":
+            return `nvValVE(${JSON.stringify(e.value)})`;
+        case "bool":
+            return `nvValVE(${e.value ? "true" : "false"})`;
+        case "null":
+            return `nvValVE(nil)`;
+        case "ref": {
+            const head = e.path[0];
+            const headVE = head === asName ? `nvOkVE(${elVar})` : `nvBindVE(input, ${JSON.stringify(head)})`;
+            if (e.path.length === 1)
+                return headVE;
+            const segs = e.path.slice(1).map((p) => JSON.stringify(p)).join(", ");
+            return `nvFieldVE(${e.opt ? '"refOpt"' : '"ref"'}, ${headVE}, []string{${segs}})`;
+        }
+        case "concat": {
+            const parts = [];
+            for (const p of e.parts) {
+                const sub = emitMapStaticVE(reconstruct(p), asName, elVar);
+                if (sub === null)
+                    return null;
+                parts.push(sub);
+            }
+            return `nvCatVE(${parts.join(", ")})`;
+        }
+        default:
+            return null;
+    }
+}
+/** Resolve a map element port to a Go Value expr (emitting error-return lines). Handles static
+ * arr by direct []Value{...} (recursing element-wise), else via emitMapStaticVE + unwrap. */
+function emitMapPortValue(node, asName, elVar, lines, ind, tmp) {
+    const arr = staticArrElems(node);
+    if (arr !== null) {
+        const elems = arr.map((el, j) => emitMapPortValue(el, asName, elVar, lines, ind, `${tmp}_a${j}`));
+        return `[]${PKG}.Value{${elems.join(", ")}}`;
+    }
+    const e = classifyExpr(node);
+    if (e.kind === "str" || e.kind === "bool" || e.kind === "null")
+        return goLiteral(node);
+    const ve = emitMapStaticVE(node, asName, elVar);
+    // ve is non-null (guarded); unwrap {Val,Err} with a direct error return.
+    const rv = `${tmp}_v`;
+    lines.push(`${ind}${rv} := ${ve}`);
+    lines.push(`${ind}if ${rv}.Err != nil {`, `${ind}\treturn nil, ${rv}.Err`, `${ind}}`);
+    return `${rv}.Val`;
+}
+/**
+ * emitNativeMapRunner — the NATIVE-PORTS exec for a single-map-node write component. Reproduces
+ * emitSeqMap's control flow EXACTLY (over→[]Value assertion, MAP_OVER_NOT_ARRAY, per-element
+ * loop, batched vs per-element dispatch, kept/collected alignment, MAP_BATCH_RESULT_MISMATCH) —
+ * but each element's ports are built as a NATIVE ports STRUCT (direct field assignment, no
+ * NewObj/Set) and dispatched via ExecNativeHandler. The batched dispatch passes a native items
+ * batch struct whose "items" port carries the []Value of per-element ports structs.
+ */
+function emitNativeMapRunner(comp) {
+    const fn = sanitize(comp.name);
+    const m = comp.body[0].map;
+    const id = comp.body[0].id;
+    const s = sanitize(id);
+    const structName = portsStructName(comp.name, id);
+    const asName = m.as;
+    const batched = m.batched === true;
+    const elVar = `el_${s}`;
+    const overVar = `over_${s}`;
+    const keptVar = `kept_${s}`;
+    const collected = `collected_${s}`;
+    const items = `items_${s}`;
+    // over head: a ref to an input param (single-node component → no prior node).
+    const overE = classifyExpr(m.over);
+    const overHead = overE.kind === "ref" ? overE.path[0] : "";
+    const lines = [];
+    lines.push(`// run_native_${fn} — NATIVE-PORTS single-map-write exec (bc 0.5.0): reproduces the generic`);
+    lines.push(`// map control flow byte-for-byte, but each element's ports are a native struct (direct field`);
+    lines.push(`// assignment, no NewObj/Set) dispatched via ExecNativeHandler (${batched ? "batched" : "per-element"}).`);
+    lines.push(`func run_native_${fn}(handlers ${PKG}.NativeComponentExec, input *${PKG}.Obj) (${PKG}.Value, error) {`);
+    // over evaluation + array assertion (matches emitSeqMap).
+    lines.push(`\t${overVar}VE := nvBindVE(input, ${JSON.stringify(overHead)})`);
+    lines.push(`\tif ${overVar}VE.Err != nil {`, `\t\treturn nil, ${overVar}VE.Err`, `\t}`);
+    lines.push(`\t${overVar}, ${overVar}IsArr := ${overVar}VE.Val.([]${PKG}.Value)`);
+    lines.push(`\tif !${overVar}IsArr {`, `\t\treturn nil, ${PKG}.NewBehaviorFailure("MAP_OVER_NOT_ARRAY", "map '${id}': 'over' did not evaluate to an array")`, `\t}`);
+    lines.push(`\t${keptVar} := make([]int, 0, len(${overVar}))`);
+    const portNames = Object.keys(m.ports);
+    const fieldTypes = portNames.map((p) => inferPortType(m.ports[p], comp.inputPorts));
+    const buildPorts = (ind, portsVar) => {
+        const inits = [];
+        for (let pi = 0; pi < portNames.length; pi++) {
+            const pn = portNames[pi];
+            const fieldName = goPortFieldName(pn);
+            const ftype = fieldTypes[pi];
+            // Infallible literal: assign the Go literal DIRECTLY to the typed field (no type assertion,
+            // no error branch) — matches emitNativeRunner's isInfallibleLiteral fast path.
+            if (isInfallibleLiteral(m.ports[pn])) {
+                inits.push(`${fieldName}: ${goLiteral(m.ports[pn])}`);
+                continue;
+            }
+            const tmp = `pv_${s}_${pn.replace(/[^A-Za-z0-9_]/g, "_")}`;
+            const val = emitMapPortValue(m.ports[pn], asName, elVar, lines, ind, tmp);
+            if (ftype === "Value") {
+                inits.push(`${fieldName}: ${val}`);
+            }
+            else {
+                lines.push(`${ind}${tmp}T, ${tmp}Ok := (${val}).(${ftype})`);
+                lines.push(`${ind}if !${tmp}Ok {`, `${ind}\treturn nil, ${PKG}.NewExprFailure("TYPE_MISMATCH", "port ${pn}: expected ${ftype}, got "+${PKG}.TypeName(${val}))`, `${ind}}`);
+                inits.push(`${fieldName}: ${tmp}T`);
+            }
+        }
+        lines.push(`${ind}${portsVar} := ${structName}{${inits.join(", ")}}`);
+    };
+    if (batched) {
+        lines.push(`\t${items} := make([]${PKG}.Value, 0, len(${overVar}))`);
+        lines.push(`\tfor ${elVar}Idx, ${elVar} := range ${overVar} {`);
+        buildPorts(`\t\t`, `ports_${s}`);
+        lines.push(`\t\t${items} = append(${items}, ports_${s})`, `\t\t${keptVar} = append(${keptVar}, ${elVar}Idx)`, `\t}`);
+        lines.push(`\tvar ${collected} []${PKG}.Value`);
+        lines.push(`\tif len(${items}) == 0 {`, `\t\t${collected} = []${PKG}.Value{}`, `\t} else {`);
+        // batched native ports: a struct exposing the "items" []Value (per-element native ports structs).
+        const batchStruct = `${structName}_batch`;
+        lines.push(`\t\tbp_${s} := ${batchStruct}{Items: ${items}}`);
+        const oc = `mo_${s}`;
+        lines.push(`\t\t${oc}, ${oc}Resolved := ${PKG}.ExecNativeHandler(handlers, ${JSON.stringify(id)}, ${JSON.stringify(m.component)}, bp_${s}, nil)`);
+        lines.push(`\t\tif !${oc}Resolved {`, `\t\t\treturn nil, ${PKG}.NewBehaviorFailure("UNKNOWN_COMPONENT", "component '${m.component}' has no handler (fail-closed)")`, `\t\t}`);
+        lines.push(`\t\tif ${oc}.IsError {`);
+        lines.push(`\t\t\treturn nil, ${PKG}.NewPlanFailure("OP_FAILED", "operation '${id}' failed under 'fail' policy: "+${oc}.Err)`);
+        lines.push(`\t\t}`);
+        lines.push(`\t\tr_batch_${s}, isArr_${s} := ${oc}.Ok.([]${PKG}.Value)`);
+        lines.push(`\t\tif !isArr_${s} || len(r_batch_${s}) != len(${items}) {`, `\t\t\treturn nil, ${PKG}.NewBehaviorFailure("MAP_BATCH_RESULT_MISMATCH", fmt.Sprintf("map '${id}': batched handler must return a list aligned to items (want %d)", len(${items})))`, `\t\t}`);
+        lines.push(`\t\t${collected} = r_batch_${s}`);
+        lines.push(`\t}`);
+    }
+    else {
+        lines.push(`\t${collected} := make([]${PKG}.Value, 0, len(${overVar}))`);
+        lines.push(`\tfor ${elVar}Idx, ${elVar} := range ${overVar} {`);
+        buildPorts(`\t\t`, `ports_${s}`);
+        const oc = `mo_${s}`;
+        lines.push(`\t\t${oc}, ${oc}Resolved := ${PKG}.ExecNativeHandler(handlers, ${JSON.stringify(id)}, ${JSON.stringify(m.component)}, ports_${s}, ${elVar})`);
+        lines.push(`\t\tif !${oc}Resolved {`, `\t\t\treturn nil, ${PKG}.NewBehaviorFailure("UNKNOWN_COMPONENT", "component '${m.component}' has no handler (fail-closed)")`, `\t\t}`);
+        lines.push(`\t\tif ${oc}.IsError {`);
+        lines.push(`\t\t\treturn nil, ${PKG}.NewPlanFailure("OP_FAILED", "operation '${id}' failed under 'fail' policy: "+${oc}.Err)`);
+        lines.push(`\t\t}`);
+        lines.push(`\t\t${collected} = append(${collected}, ${oc}.Ok)`, `\t\t${keptVar} = append(${keptVar}, ${elVar}Idx)`, `\t}`);
+    }
+    // node result = collected (no `into`). output resolves ref/arr/concat over this node result.
+    lines.push(`\tnr_${s} := ${PKG}.Value(${collected})`);
+    lines.push(`\t_ = ${keptVar}`);
+    lines.push(`\t_ = nr_${s}`);
+    // output: a ref to the map node result (or a static arr/concat wrapping it). emitStaticRefValue
+    // resolves the map node's id to nr_<s> and handles the static-arr output wrapper directly.
+    const priorNodeAt = (head) => head === id;
+    const nodeResult = () => `nr_${s}`;
+    const outResolved = emitStaticRefValue(comp.output, 1, (h, _p) => priorNodeAt(h), nodeResult, lines, "out");
+    if (outResolved) {
+        lines.push(`\treturn ${outResolved}, nil`);
+    }
+    else {
+        lines.push(`\treturn nil, ${PKG}.NewBehaviorFailure("UNSUPPORTED_OUTPUT_NATIVE", "map component '${comp.name}': output not statically resolvable")`);
+    }
+    lines.push(`}`);
+    return lines.join("\n");
+}
+/** Emit the per-node native ports struct(s) for a single-map-write component: the element ports
+ * struct + a batched "items" struct (when batched) exposing the []Value items via PortReader. */
+function emitMapPortsStructs(comp) {
+    const m = comp.body[0].map;
+    const id = comp.body[0].id;
+    const structName = portsStructName(comp.name, id);
+    const elemStruct = emitPortsStruct(comp, { id, component: m.component, ports: m.ports });
+    if (m.batched !== true)
+        return elemStruct;
+    const batchStruct = `${structName}_batch`;
+    const portNames = Object.keys(m.ports);
+    // Port("items") reconstruction: a consumer on the hot path DOWNCASTS to []<${structName}> and
+    // reads typed element fields with zero boxing (no map alloc — the whole de-plumb). This uniform
+    // PortReader path is a FALLBACK for a consumer that reads by name; it materializes the generic
+    // {items:[{...}]} view ONLY on demand (never touched by the de-plumbed run_native_ runner, which
+    // passes the native []${structName} straight through — the runner stays NewObj/Set-free).
+    const reconstruct = `\t\t\to := ${PKG}.NewObj()\n\t\t\tpr, _ := e.(${PKG}.PortReader)\n\t\t\t_ = pr\n${portNames
+        .map((pn) => `\t\t\tif pr != nil {\n\t\t\t\tif v, has := pr.Port(${JSON.stringify(pn)}); has {\n\t\t\t\t\to.Set(${JSON.stringify(pn)}, v)\n\t\t\t\t}\n\t\t\t}`)
+        .join("\n")}\n\t\t\tout[i] = o`;
+    return `${elemStruct}
+
+// ${batchStruct} — NATIVE batched ports for map '${id}': Items holds the typed per-element native
+// ports structs (a []Value of concrete ${structName}, built by direct assignment; no key-value
+// container in the RUNNER). A hot-path consumer downcasts each element to ${structName}; the
+// uniform Port("items") accessor below reconstructs the generic {items:[{...}]} view on demand.
+type ${batchStruct} struct {
+	Items []${PKG}.Value
+}
+
+func (p ${batchStruct}) Port(name string) (${PKG}.Value, bool) {
+	if name == "items" {
+		out := make([]${PKG}.Value, len(p.Items))
+		for i, e := range p.Items {
+${reconstruct}
+		}
+		return out, true
+	}
+	return nil, false
+}`;
+}
+/**
+ * emitStaticRefValue — statically resolve a ref/refOpt/concat/literal expression to a Go
+ * expression that reads node-result locals (nr_<id>) or input params DIRECTLY, with no dynamic
+ * scope object. Returns the Go expression string (already emitting any needed field-walk +
+ * error-return lines), or null if the expression is a genuinely dynamic operator that must go
+ * through the primitive SSoT (the caller falls back to an ephemeral scope for those).
+ *
+ * This is the bc#74 native cross-node resolution: a ref head that names a prior node reads that
+ * node's NATIVE result value; a single-segment head is returned directly; a multi-segment path
+ * is walked with slFieldVE-equivalent semantics emitted inline via slRef over a 1-key ephemeral
+ * carrier ONLY when the head is a node result (kept as a direct value walk).
+ */
+function emitStaticRefValue(node, atPos, priorNodeAt, nodeResult, lines, tmpBase) {
+    const arr = staticArrElems(node);
+    if (arr !== null) {
+        // Static arr → direct []dslcontracts.Value{...} (NOT ArrNative closures). Each element is
+        // resolved via this same function (a literal inlines; a ref/concat emits its error-return
+        // lines and yields a Go Value expr). The whole arr is infallible once elements resolve.
+        const elems = arr.map((el, j) => emitStaticRefValue(el, atPos, priorNodeAt, nodeResult, lines, `${tmpBase}_a${j}`));
+        return `[]${PKG}.Value{${elems.join(", ")}}`;
+    }
+    const e = classifyExpr(node);
+    if (e.kind === "str" || e.kind === "bool" || e.kind === "null") {
+        return goLiteral(node);
+    }
+    // ref / concat reuse the native layer's own SSoT helpers (nvOkVE / nvBindVE / nvFieldVE /
+    // nvCatVE — emitted unconditionally in this layer, mirroring the straight-line slVE semantics
+    // so NULL_REF/MISSING_PROP/TYPE_MISMATCH/UNKNOWN_BINDING stay byte-identical to expr.go). They
+    // are self-contained (do NOT depend on the generic body's usage-flagged helpers, which may be
+    // absent for a component whose generic path never used them). We produce an nvVE and unwrap
+    // {Val,Err} with a direct error return (the wrapper is folded away at the port).
+    const ve = emitStaticVE(node, atPos, priorNodeAt, nodeResult);
+    if (ve === null)
+        return null;
+    const rv = `${tmpBase}_v`;
+    lines.push(`\t${rv} := ${ve}`);
+    lines.push(`\tif ${rv}.Err != nil {`, `\t\treturn nil, ${rv}.Err`, `\t}`);
+    return `${rv}.Val`;
+}
+/**
+ * emitStaticVE — build the slVE expression for a static ref/concat/literal, resolving ref heads
+ * to prior node-result locals (slOkVE(nr_<id>)) or input binds (slBindVE(input, head)). Returns
+ * null for a genuinely dynamic operator (caller falls back to the primitive SSoT).
+ */
+function emitStaticVE(node, atPos, priorNodeAt, nodeResult) {
+    const e = classifyExpr(node);
+    switch (e.kind) {
+        case "str":
+            return `nvValVE(${JSON.stringify(e.value)})`;
+        case "bool":
+            return `nvValVE(${e.value ? "true" : "false"})`;
+        case "null":
+            return `nvValVE(nil)`;
+        case "ref": {
+            const head = e.path[0];
+            const headVE = priorNodeAt(head, atPos)
+                ? `nvOkVE(${nodeResult(head)})`
+                : `nvBindVE(input, ${JSON.stringify(head)})`;
+            if (e.path.length === 1)
+                return headVE;
+            const segs = e.path.slice(1).map((p) => JSON.stringify(p)).join(", ");
+            return `nvFieldVE(${e.opt ? '"refOpt"' : '"ref"'}, ${headVE}, []string{${segs}})`;
+        }
+        case "concat": {
+            const parts = [];
+            for (const p of e.parts) {
+                const sub = emitStaticVE(reconstruct(p), atPos, priorNodeAt, nodeResult);
+                if (sub === null)
+                    return null;
+                parts.push(sub);
+            }
+            return `nvCatVE(${parts.join(", ")})`;
+        }
+        default:
+            return null;
+    }
+}
+/** Self-contained native-layer VE helpers (mirror the straight-line slVE SSoT; expr.go codes). */
+function emitNativeHelpers(needsCat) {
+    const base = `// nvVE packs a single (Value, error) so a statically-wired native port expr composes as one
+// expression, then is folded away (the {Val,Err} never persists past the port). Mirrors slVE.
+type nvVE struct {
+	Val ${PKG}.Value
+	Err error
+}
+func nvValVE(v ${PKG}.Value) nvVE { return nvVE{Val: v} }
+func nvOkVE(v ${PKG}.Value) nvVE  { return nvVE{Val: v} }
+// nvBindVE reads an input-param head directly (UNKNOWN_BINDING matches expr.go). A nil scope
+// (no input passed) has no bindings — fail closed with UNKNOWN_BINDING (no *Obj allocated).
+func nvBindVE(scope *${PKG}.Obj, head string) nvVE {
+	if scope == nil {
+		return nvVE{Err: ${PKG}.NewExprFailure("UNKNOWN_BINDING", "unknown binding: "+head)}
+	}
+	v, ok := scope.Get(head)
+	if !ok {
+		return nvVE{Err: ${PKG}.NewExprFailure("UNKNOWN_BINDING", "unknown binding: "+head)}
+	}
+	return nvVE{Val: v}
+}
+// nvFieldVE walks a static field path over a resolved head (expr.go ref/refOpt semantics).
+func nvFieldVE(op string, head nvVE, path []string) nvVE {
+	if head.Err != nil {
+		return head
+	}
+	cur := head.Val
+	for _, seg := range path {
+		if cur == nil {
+			if op == "refOpt" {
+				return nvVE{Val: nil}
+			}
+			return nvVE{Err: ${PKG}.NewExprFailure("NULL_REF", "null intermediate at ."+seg+" (use ?.)")}
+		}
+		o, ok := cur.(*${PKG}.Obj)
+		if !ok {
+			return nvVE{Err: ${PKG}.NewExprFailure("TYPE_MISMATCH", "cannot access ."+seg+" on "+${PKG}.TypeName(cur))}
+		}
+		next, present := o.Get(seg)
+		if !present {
+			return nvVE{Err: ${PKG}.NewExprFailure("MISSING_PROP", "missing property ."+seg)}
+		}
+		cur = next
+	}
+	return nvVE{Val: cur}
+}`;
+    if (!needsCat)
+        return base;
+    return `${base}
+// nvCatVE concatenates already-evaluated string parts (expr.go concat: strings only order + code).
+func nvCatVE(parts ...nvVE) nvVE {
+	var b strings.Builder
+	for _, p := range parts {
+		if p.Err != nil {
+			return p
+		}
+		s, ok := p.Val.(string)
+		if !ok {
+			return nvVE{Err: ${PKG}.NewExprFailure("TYPE_MISMATCH", "concat: strings only (got "+${PKG}.TypeName(p.Val)+"; no implicit toString)")}
+		}
+		b.WriteString(s)
+	}
+	return nvVE{Val: b.String()}
+}`;
+}
+/** Whether the native layer needs "strings" (a concat appears in any native component). */
+function nativeNeedsStrings(comp) {
+    const walk = (x) => {
+        if (x === null || typeof x !== "object")
+            return false;
+        if (Array.isArray(x))
+            return x.some(walk);
+        const keys = Object.keys(x);
+        if (keys.length === 1 && keys[0] === "concat")
+            return true;
+        return keys.some((k) => walk(x[k]));
+    };
+    return comp.body.some((n) => walk(n)) || walk(comp.output);
+}
+/** Reconstruct an Expression IR node from a classified StaticExpr (for recursive concat parts). */
+function reconstruct(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(reconstruct) };
+        case "dynamic":
+            return e.node;
+    }
+}
+/** BindNative — dispatch surface for native components (mirrors Bind, native handler seam). */
+function emitBindNative(ctx) {
+    const native = ctx.ir.components.filter(isNative);
+    const arms = native
+        .map((c) => `\tm[${JSON.stringify(c.name)}] = func(input *${PKG}.Obj) (${PKG}.Value, error) {\n\t\treturn run_native_${sanitize(c.name)}(handlers, input)\n\t}`)
+        .join("\n");
+    return `// BindNative is the NATIVE-PORTS dispatch surface (bc 0.5.0): it binds a NativeComponentExec
+// (native ports struct + native-backed result) to the de-plumbed runners. Only native-covered
+// components (strictly-sequential componentRef) are exposed; a consumer keeps the rest on the
+// generic Bind. This is ADDITIVE — the generic Bind path is unchanged.
+func BindNative(handlers ${PKG}.NativeComponentExec) map[string]func(input *${PKG}.Obj) (${PKG}.Value, error) {
+	m := map[string]func(input *${PKG}.Obj) (${PKG}.Value, error){}
+${arms}
+	return m
+}
+
+// ComponentNamesNative — components exposed on the native-ports path (in declaration order).
+var ComponentNamesNative = []string{${native.map((c) => JSON.stringify(c.name)).join(", ")}}`;
+}
+/**
+ * emit — a native-eligible component gets ONLY the native run_native_ / BindNative path; the
+ * generic key-value run_ / Bind is emitted ONLY for components that are NOT native-eligible
+ * (map/cond/concurrency), so a fully-native module contains ZERO NewObj/Set/generic ExecHandler
+ * (owner purity requirement + grep gate). We drive the generic emitter with a FILTERED context
+ * (non-native components only) so it emits the generic body — imports, spec-version init, base
+ * helpers, run_ fns, Bind, dispatch, ComponentNames — for exactly those components. The native
+ * surface (structs, run_native_ fns, BindNative, ComponentNamesNative) covers the native ones.
+ */
+function emit(ctx) {
+    const native = ctx.ir.components.filter(isNative);
+    const nonNative = ctx.ir.components.filter((c) => !isNative(c));
+    // Generic body for the NON-NATIVE components only (filtered context). When every component is
+    // native, this body has zero components: header + spec-version init + slVal base helper +
+    // empty Bind/dispatch/ComponentNames — and crucially NO NewObj/Set/ExecHandler (those live in
+    // run_*, which only exist for the non-native components here).
+    const filteredCtx = {
+        ...ctx,
+        ir: { ...ctx.ir, components: nonNative },
+        componentNames: nonNative.map((c) => c.name),
+    };
+    let straightlineCode = goStraightlineEmitter.emit(filteredCtx);
+    if (native.length === 0) {
+        // Nothing native-emittable (all map/cond/concurrency): generic path only. BindNative binds
+        // nothing. The generic body is the FULL module (nonNative === all components).
+        return `${straightlineCode.replace(/\n+$/, "\n")}\n${emitBindNative(ctx)}\n`;
+    }
+    const structs = [];
+    for (const c of native) {
+        if (isNativeMapComponent(c))
+            structs.push(emitMapPortsStructs(c));
+        else
+            for (const n of c.body)
+                structs.push(emitPortsStruct(c, n));
+    }
+    const runners = native.map((c) => (isNativeMapComponent(c) ? emitNativeMapRunner(c) : emitNativeRunner(c))).join("\n\n");
+    const bindNative = emitBindNative(ctx);
+    const needsCat = native.some(nativeNeedsStrings);
+    const helpers = emitNativeHelpers(needsCat);
+    // A batched native map runner uses fmt.Sprintf (MAP_BATCH_RESULT_MISMATCH). Ensure "fmt" is
+    // imported even if no NON-NATIVE component needed it (idempotent: skip if present).
+    const needsFmt = native.some((c) => isNativeMapComponent(c) && c.body[0].map.batched === true);
+    if (needsFmt && !/\n\t"fmt"\n/.test(straightlineCode)) {
+        // inject after the opening import "(" — the generic header always emits an import block.
+        straightlineCode = straightlineCode.replace(/\nimport \(\n/, '\nimport (\n\t"fmt"\n');
+    }
+    // nvCatVE uses strings.Builder. The filtered generic body imports "strings" iff a NON-NATIVE
+    // component uses concat; if concat appears only in native components (or the module is fully
+    // native), inject the "strings" import so nvCatVE resolves. (Idempotent: skip if present.)
+    if (needsCat && !/\n\t"strings"\n/.test(straightlineCode)) {
+        straightlineCode = straightlineCode.replace(/\n\t"fmt"\n/, '\n\t"fmt"\n\t"strings"\n');
+    }
+    const banner = `// ── NATIVE-PORTS layer (bc 0.5.0 — de-plumb the port container) ────────────────────
+// A native-eligible component is emitted ONLY here (run_native_ + BindNative) — its generic
+// key-value run_ / Bind is NOT emitted (a fully-native module has zero generic port container).
+// Each componentRef builds a native ports struct by direct field assignment and dispatches via
+// the native handler seam (NativeComponentExec -> ExecOutcome). Components that are NOT native-
+// eligible (map/cond/concurrency) keep the generic key-value run_ / Bind above (they can't be
+// de-plumbed yet). Fail-closed operator semantics still route through the A0 primitives.`;
+    const sections = [
+        banner,
+        `// Self-contained native-layer VE helpers (expr.go ref/concat semantics; independent of the\n// generic body's usage-flagged helpers).\n${helpers}`,
+        `// Native ports structs (one per componentRef node; typed per the static port type).\n${structs.join("\n\n")}`,
+        `// Native-ports straight-line runners: the de-plumbed exec path (called by BindNative).\n${runners}`,
+        bindNative,
+    ];
+    return `${straightlineCode.replace(/\n+$/, "\n")}\n${sections.join("\n\n")}\n`;
+}
+/**
+ * goStraightlineNativeEmitter — language id `go-straightline-native` (bc 0.5.0). Emits the
+ * generic straight-line body (fallback + helpers) plus the NATIVE-PORTS layer (per-node ports
+ * struct built by direct assignment + BindNative through the native handler seam). Additive:
+ * the generic Bind / literal / ir endpoints are unchanged.
+ */
+export const goStraightlineNativeEmitter = {
+    language: "go-straightline-native",
+    fileExtension: ".go",
+    defaultRuntimeImport: "github.com/foo-ogawa/behavior-contracts/go/coderuntime",
+    filenameHint: "behaviors.straightline.native.generated.go",
+    emit,
+};
+//# sourceMappingURL=emit-straightline-native-go.js.map