behavior-contracts 0.5.0 → 0.7.0

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

@@ -1,835 +0,0 @@
-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