behavior-contracts 0.3.0 → 0.5.0

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

@@ -0,0 +1,624 @@
+import { rustStraightlineEmitter, rustStraightlineInternals } from "./emit-straightline-rust.js";
+import { sequentialOrder, analyzeSequentialOps, classifyExpr } from "./straightline.js";
+const { P, sanitize, rustStrLit } = rustStraightlineInternals;
+/** Rust struct field name for a wire port (snake-ish, deterministic, valid ident). */
+function rustFieldName(wire) {
+    const safe = wire.replace(/[^A-Za-z0-9_]/g, "_").toLowerCase();
+    return /^[a-z_]/.test(safe) ? `f_${safe}` : `f_${safe}`;
+}
+/** Rust struct type name for a node (PascalCase-ish, module-unique). */
+function portsStructName(compName, nodeId) {
+    return `Ports${pascal(compName)}${pascal(nodeId)}`;
+}
+function pascal(s) {
+    return s.replace(/[^A-Za-z0-9]+/g, " ").split(" ").filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("") || "X";
+}
+function inferPortType(node, inputPorts) {
+    // A static arr port is a Vec<Value> carried in a boxed Value struct field (Value::Arr) — still
+    // no vec!/generic key-value container; built by a direct array-to-Vec assignment.
+    if (staticArrElems(node) !== null)
+        return "Value";
+    const e = classifyExpr(node);
+    switch (e.kind) {
+        case "str":
+        case "concat":
+            return "String";
+        case "bool":
+            return "bool";
+        case "ref": {
+            if (e.path.length === 1) {
+                const s = inputPorts[e.path[0]];
+                if (s) {
+                    if (s.type === "string")
+                        return "String";
+                    if (s.type === "int")
+                        return "i64";
+                    if (s.type === "float")
+                        return "f64";
+                    if (s.type === "bool")
+                        return "bool";
+                }
+            }
+            return "Value";
+        }
+        default:
+            return "Value";
+    }
+}
+/**
+ * staticArrElems — if `node` is a single-key `{arr:[...]}` shape, return its element nodes; else
+ * null. classifyExpr keeps `arr` as dynamic (its construction lives in the primitive SSoT), so we
+ * recognize the STATIC arr shape here and build it as a Vec<Value> WITHOUT the `vec!` macro (the
+ * purity gate bans `vec![`) — via `[...].into()` on a fixed-size array of Values.
+ */
+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;
+}
+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)));
+        default:
+            return false;
+    }
+}
+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;
+    }
+}
+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
+ * over is a ref, every per-element port is statically resolvable, no when/into, default 'fail'
+ * policy, no relationKind, and the output is statically resolvable. Mirrors the Go predicate;
+ * emitNativeMapRunner reproduces emitRSeqMap's control flow with native element ports structs.
+ */
+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;
+    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);
+}
+/** The `Value` clone expr for a port field when read via PortReader (box one field on demand). */
+function portToValue(field, ty) {
+    switch (ty) {
+        case "String":
+            return `Value::Str(self.${field}.clone())`;
+        case "i64":
+            return `Value::Int(self.${field})`;
+        case "f64":
+            return `Value::Float(self.${field})`;
+        case "bool":
+            return `Value::Bool(self.${field})`;
+        case "Value":
+            return `self.${field}.clone()`;
+    }
+}
+function emitPortsStruct(comp, node) {
+    const name = portsStructName(comp.name, node.id);
+    const portNames = Object.keys(node.ports);
+    if (portNames.length === 0) {
+        return `// ${name} — native ports for node '${node.id}' (component ${node.component}); no ports.
+struct ${name};
+impl behavior_contracts::PortReader for ${name} {
+    fn port(&self, _name: &str) -> Option<Value> { None }
+    fn as_any(&self) -> &dyn std::any::Any { self }
+}`;
+    }
+    const types = portNames.map((p) => inferPortType(node.ports[p], comp.inputPorts));
+    const fields = portNames
+        .map((p, i) => `    ${rustFieldName(p)}: ${types[i] === "Value" ? "Value" : types[i]}, // ${JSON.stringify(p)}`)
+        .join("\n");
+    const arms = portNames
+        .map((p, i) => `            ${rustStrLit(p)} => Some(${portToValue(rustFieldName(p), types[i])}),`)
+        .join("\n");
+    return `// ${name} — NATIVE ports for node '${node.id}' (component ${node.component}). Typed fields per the
+// static port type; constructed directly (no Vec, no heap key strings, no per-port Value boxing).
+struct ${name} {
+${fields}
+}
+impl behavior_contracts::PortReader for ${name} {
+    fn port(&self, name: &str) -> Option<Value> {
+        match name {
+${arms}
+            _ => None,
+        }
+    }
+    fn as_any(&self) -> &dyn std::any::Any { self }
+}`;
+}
+/** Emit an `R`-typed expr (Result<Value,ExprFailure>) for a static ref/concat/literal, reading
+ * prior node results from their locals (nr_<id>) or input params from `input`. */
+function emitStaticR(node, atPos, priorNodeAt, nodeResult) {
+    const arr = staticArrElems(node);
+    if (arr !== null) {
+        // Static arr → Ok(Value::Arr([e0?, e1?, …].into())). Uses a fixed-size array + `.into()` to a
+        // Vec — NO `vec!` macro (purity gate). Each element unwraps via `?` (ExprFailure propagates).
+        if (arr.length === 0)
+            return `Ok::<Value, behavior_contracts::ExprFailure>(Value::Arr(Vec::new()))`;
+        const elems = arr.map((el) => `(${emitStaticR(el, atPos, priorNodeAt, nodeResult)})?`).join(", ");
+        return `Ok::<Value, behavior_contracts::ExprFailure>(Value::Arr([${elems}].into()))`;
+    }
+    const e = classifyExpr(node);
+    switch (e.kind) {
+        case "str":
+            return `${P}::str_native(${rustStrLit(e.value)})`;
+        case "bool":
+            return `${P}::bool_native(${e.value ? "true" : "false"})`;
+        case "null":
+            return `${P}::null_native()`;
+        case "ref": {
+            const head = e.path[0];
+            const fn = e.opt ? "ref_opt_native" : "ref_native";
+            if (priorNodeAt(head, atPos)) {
+                // Read the prior node's NATIVE result local via a 1-key borrowed scope (no persistent Vec).
+                const path = e.path.map(rustStrLit).join(", ");
+                return `${P}::${fn}(&[${path}], &[(${rustStrLit(head)}.to_string(), ${nodeResult(head)}.clone())])`;
+            }
+            const path = e.path.map(rustStrLit).join(", ");
+            return `${P}::${fn}(&[${path}], input)`;
+        }
+        case "concat": {
+            const parts = e.parts.map((p) => `(${emitStaticR(reconstruct(p), atPos, priorNodeAt, nodeResult)})?`).join(", ");
+            return `${P}::concat_native(&[${parts}])`;
+        }
+        default:
+            throw new Error("rust native: non-static expr reached emitStaticR (guarded by isNativeComponent)");
+    }
+}
+function emitNativeRunner(comp) {
+    const order = sequentialOrder(comp);
+    const metas = analyzeSequentialOps(
+    // reuse the shared plan model for policy analysis (opsLiteral shape)
+    (function () {
+        // minimal opsLiteral mirror: id + parent + policy (native components have no bindField/map/cond)
+        const idToIndex = new Map();
+        comp.body.forEach((n, i) => idToIndex.set(n.id, i));
+        return comp.body.map((n) => {
+            const cr = n;
+            const pid = cr.parent;
+            return {
+                id: n.id,
+                parent: pid !== undefined ? idToIndex.get(pid) ?? null : null,
+                policy: cr.policy,
+            };
+        });
+    })(), order);
+    const fn = sanitize(comp.name);
+    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));
+    const priorNodeAt = (head, atPos) => {
+        const p = idToPos.get(head);
+        return p !== undefined && p < atPos;
+    };
+    // Does any port expr OR the output read an INPUT param (a ref whose head is not a prior node)?
+    // If not, the `input` parameter is unused — bind it as `_input` to stay clippy-clean.
+    const readsInput = (() => {
+        const walk = (node, atPos) => {
+            const e = classifyExpr(node);
+            if (e.kind === "ref")
+                return !priorNodeAt(e.path[0], atPos);
+            if (e.kind === "concat")
+                return e.parts.some((p) => walk(reconstruct(p), atPos));
+            return false;
+        };
+        for (const k of order.keys()) {
+            const cr = comp.body[order[k]];
+            if (Object.values(cr.ports).some((pn) => walk(pn, k)))
+                return true;
+        }
+        return walk(comp.output, order.length);
+    })();
+    const inputParam = readsInput ? "input" : "_input";
+    const lines = [];
+    lines.push(`// run_native_${fn} — NATIVE-PORTS straight-line exec (bc 0.5.0): each componentRef constructs a`);
+    lines.push(`// native ports struct directly (no vec!/to_string key/Value boxing) and dispatches via`);
+    lines.push(`// exec_native (NativeComponentExec). Node results are native locals; cross-node refs read them (#74).`);
+    lines.push(`fn run_native_${fn}<H: behavior_contracts::NativeComponentExec>(`);
+    lines.push(`    handlers: &mut H,`);
+    lines.push(`    ${inputParam}: &[(String, Value)],`);
+    lines.push(`) -> Result<Value, BehaviorError> {`);
+    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(`    // ── op '${node.id}' (${node.component}) ──`);
+        const inits = [];
+        for (const pn of portNames) {
+            const expr = node.ports[pn];
+            const field = rustFieldName(pn);
+            const ty = inferPortType(expr, comp.inputPorts);
+            const rExpr = emitStaticR(expr, k, priorNodeAt, nodeResult);
+            const local = `pv_${sanitize(node.id)}_${pn.replace(/[^A-Za-z0-9_]/g, "_")}`;
+            lines.push(`    let ${local}: Value = (${rExpr}).map_err(BehaviorError::from)?;`);
+            if (ty === "Value") {
+                inits.push(`${field}: ${local}`);
+            }
+            else {
+                // typed field: pattern-extract the concrete scalar (fail-closed TYPE_MISMATCH otherwise).
+                const pat = ty === "String" ? "Value::Str(s)" : ty === "i64" ? "Value::Int(s)" : ty === "f64" ? "Value::Float(s)" : "Value::Bool(s)";
+                const label = ty === "String" ? "string" : ty === "i64" ? "int" : ty === "f64" ? "float" : "bool";
+                lines.push(`    let ${local}_t = match ${local} { ${pat} => s, ref other => return Err(behavior_contracts::raw_type_mismatch(${rustStrLit(label)}, other.type_name())) };`);
+                inits.push(`${field}: ${local}_t`);
+            }
+        }
+        lines.push(`    let ports_${sanitize(node.id)} = ${structName} { ${inits.join(", ")} };`);
+        lines.push(`    let outcome_${sanitize(node.id)} = match handlers.exec_native_ctx(${rustStrLit(node.id)}, ${rustStrLit(node.component)}, &ports_${sanitize(node.id)}, None) {`);
+        lines.push(`        Some(o) => o,`);
+        lines.push(`        None => return Err(unknown_component(${rustStrLit(node.component)})),`);
+        lines.push(`    };`);
+        if (meta.policy === "continue") {
+            lines.push(`    let ${nodeResult(node.id)}: Value = match outcome_${sanitize(node.id)} { behavior_contracts::ExecOutcome::Ok(v) => v, behavior_contracts::ExecOutcome::Error(_) => Value::Null };`);
+        }
+        else {
+            const label = meta.policy === "retry" ? "retry' policy (exhausted)" : "fail' policy";
+            lines.push(`    let ${nodeResult(node.id)}: Value = match outcome_${sanitize(node.id)} {`);
+            lines.push(`        behavior_contracts::ExecOutcome::Ok(v) => v,`);
+            lines.push(`        behavior_contracts::ExecOutcome::Error(e) => return Err(BehaviorError::new("OP_FAILED", format!("operation '{}' failed under '${label}: {}", ${rustStrLit(node.id)}, e))),`);
+            lines.push(`    };`);
+        }
+    }
+    const outR = emitStaticR(comp.output, order.length, priorNodeAt, nodeResult);
+    lines.push(`    (${outR}).map_err(BehaviorError::from)`);
+    lines.push(`}`);
+    return lines.join("\n");
+}
+/** emitMapStaticR — R-typed expr for a map element port: a ref whose head is the element binding
+ * (`as`) resolves to the element local via a 1-key borrowed scope; other refs read `input`. */
+function emitMapStaticR(node, asName, elLocal) {
+    const arr = staticArrElems(node);
+    if (arr !== null) {
+        if (arr.length === 0)
+            return `Ok::<Value, behavior_contracts::ExprFailure>(Value::Arr(Vec::new()))`;
+        const elems = arr.map((el) => `(${emitMapStaticR(el, asName, elLocal)})?`).join(", ");
+        return `Ok::<Value, behavior_contracts::ExprFailure>(Value::Arr([${elems}].into()))`;
+    }
+    const e = classifyExpr(node);
+    switch (e.kind) {
+        case "str":
+            return `${P}::str_native(${rustStrLit(e.value)})`;
+        case "bool":
+            return `${P}::bool_native(${e.value ? "true" : "false"})`;
+        case "null":
+            return `${P}::null_native()`;
+        case "ref": {
+            const head = e.path[0];
+            const fn = e.opt ? "ref_opt_native" : "ref_native";
+            const path = e.path.map(rustStrLit).join(", ");
+            if (head === asName) {
+                return `${P}::${fn}(&[${path}], &[(${rustStrLit(head)}.to_string(), ${elLocal}.clone())])`;
+            }
+            return `${P}::${fn}(&[${path}], input)`;
+        }
+        case "concat": {
+            const parts = e.parts.map((p) => `(${emitMapStaticR(reconstruct(p), asName, elLocal)})?`).join(", ");
+            return `${P}::concat_native(&[${parts}])`;
+        }
+        default:
+            throw new Error("rust native: non-static map port expr reached emitMapStaticR");
+    }
+}
+/**
+ * emitNativeMapRunner — NATIVE-PORTS exec for a single-map-write component (rust). Reproduces
+ * emitRSeqMap's control flow (over→Value::Arr match, MAP_OVER_NOT_ARRAY, per-element loop,
+ * batched vs per-element dispatch, kept/collected, MAP_BATCH_RESULT_MISMATCH) but each element's
+ * ports are a native struct (direct construction, no vec!/key-string/Value boxing) dispatched via
+ * exec_native_ctx. The batched dispatch passes a native batch struct holding the Vec<ElemStruct>
+ * (a Vec<StructName>, NOT the banned Vec<(String,Value)>); a consumer downcasts via as_any().
+ */
+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 comp_ = rustStrLit(m.component);
+    const nodeId = rustStrLit(id);
+    const overE = classifyExpr(m.over);
+    const overHead = overE.kind === "ref" ? overE.path[0] : "";
+    const portNames = Object.keys(m.ports);
+    const fieldTypes = portNames.map((p) => inferPortType(m.ports[p], comp.inputPorts));
+    const lines = [];
+    lines.push(`// run_native_${fn} — NATIVE-PORTS single-map-write exec (bc 0.5.0): reproduces the generic map`);
+    lines.push(`// control flow, but each element's ports are a native struct (direct construction, no vec!)`);
+    lines.push(`// dispatched via exec_native_ctx (${batched ? "batched" : "per-element"}).`);
+    lines.push(`fn run_native_${fn}<H: behavior_contracts::NativeComponentExec>(`);
+    lines.push(`    handlers: &mut H,`);
+    lines.push(`    input: &[(String, Value)],`);
+    lines.push(`) -> Result<Value, BehaviorError> {`);
+    // over evaluation + array match (matches emitRSeqMap).
+    lines.push(`    let over_${s}: Vec<Value> = match (${P}::ref_native(&[${rustStrLit(overHead)}], input)).map_err(BehaviorError::from)? {`);
+    lines.push(`        Value::Arr(a) => a,`);
+    lines.push(`        _ => return Err(BehaviorError::new("MAP_OVER_NOT_ARRAY", "map '${id}': 'over' did not evaluate to an array".to_string())),`);
+    lines.push(`    };`);
+    lines.push(`    let mut kept_${s}: Vec<usize> = Vec::new();`);
+    const buildElem = (ind) => {
+        const out = [];
+        const inits = [];
+        for (let pi = 0; pi < portNames.length; pi++) {
+            const pn = portNames[pi];
+            const field = rustFieldName(pn);
+            const ty = fieldTypes[pi];
+            const rExpr = emitMapStaticR(m.ports[pn], asName, `el_${s}`);
+            const local = `pv_${s}_${pn.replace(/[^A-Za-z0-9_]/g, "_")}`;
+            out.push(`${ind}let ${local}: Value = (${rExpr}).map_err(BehaviorError::from)?;`);
+            if (ty === "Value") {
+                inits.push(`${field}: ${local}`);
+            }
+            else {
+                const pat = ty === "String" ? "Value::Str(s)" : ty === "i64" ? "Value::Int(s)" : ty === "f64" ? "Value::Float(s)" : "Value::Bool(s)";
+                const label = ty === "String" ? "string" : ty === "i64" ? "int" : ty === "f64" ? "float" : "bool";
+                out.push(`${ind}let ${local}_t = match ${local} { ${pat} => s, ref other => return Err(behavior_contracts::raw_type_mismatch(${rustStrLit(label)}, other.type_name())) };`);
+                inits.push(`${field}: ${local}_t`);
+            }
+        }
+        out.push(`${ind}let ports_${s} = ${structName} { ${inits.join(", ")} };`);
+        return out;
+    };
+    if (batched) {
+        const batchStruct = `${structName}Batch`;
+        lines.push(`    let mut items_${s}: Vec<${structName}> = Vec::new();`);
+        lines.push(`    for (el_${s}_idx, el_${s}) in over_${s}.iter().enumerate() {`);
+        lines.push(...buildElem(`        `));
+        lines.push(`        items_${s}.push(ports_${s});`, `        kept_${s}.push(el_${s}_idx);`, `    }`);
+        lines.push(`    let mut collected_${s}: Vec<Value> = Vec::new();`);
+        lines.push(`    if !items_${s}.is_empty() {`);
+        lines.push(`        let want_${s} = items_${s}.len();`);
+        lines.push(`        let bp_${s} = ${batchStruct} { items: items_${s} };`);
+        lines.push(`        match handlers.exec_native_ctx(${nodeId}, ${comp_}, &bp_${s}, None) {`);
+        lines.push(`            None => return Err(unknown_component(${comp_})),`);
+        lines.push(`            Some(behavior_contracts::ExecOutcome::Error(e)) => return Err(BehaviorError::new("OP_FAILED", format!("operation '{}' failed under 'fail' policy: {}", ${nodeId}, e))),`);
+        lines.push(`            Some(behavior_contracts::ExecOutcome::Ok(v)) => match v {`);
+        lines.push(`                Value::Arr(r) if r.len() == want_${s} => { collected_${s} = r; }`);
+        lines.push(`                _ => return Err(BehaviorError::new("MAP_BATCH_RESULT_MISMATCH", format!("map '${id}': batched handler must return a list aligned to items (want {want_${s}})"))),`);
+        lines.push(`            },`);
+        lines.push(`        }`);
+        lines.push(`    }`);
+    }
+    else {
+        lines.push(`    let mut collected_${s}: Vec<Value> = Vec::new();`);
+        lines.push(`    for (el_${s}_idx, el_${s}) in over_${s}.iter().enumerate() {`);
+        lines.push(...buildElem(`        `));
+        lines.push(`        match handlers.exec_native_ctx(${nodeId}, ${comp_}, &ports_${s}, Some(el_${s})) {`);
+        lines.push(`            None => return Err(unknown_component(${comp_})),`);
+        lines.push(`            Some(behavior_contracts::ExecOutcome::Error(e)) => return Err(BehaviorError::new("OP_FAILED", format!("operation '{}' failed under 'fail' policy: {}", ${nodeId}, e))),`);
+        lines.push(`            Some(behavior_contracts::ExecOutcome::Ok(v)) => { collected_${s}.push(v); kept_${s}.push(el_${s}_idx); }`);
+        lines.push(`        }`);
+        lines.push(`    }`);
+    }
+    lines.push(`    let _ = &kept_${s};`);
+    lines.push(`    let nr_${s}: Value = Value::Arr(collected_${s});`);
+    // output: a ref to the map node result (or a static arr wrapper). Resolve via a 1-key scope.
+    const priorNodeAt = (head) => head === id;
+    const nodeResult = () => `nr_${s}`;
+    const outR = emitStaticRMapOut(comp.output, id, `nr_${s}`, priorNodeAt, nodeResult);
+    lines.push(`    (${outR}).map_err(BehaviorError::from)`);
+    lines.push(`}`);
+    return lines.join("\n");
+}
+/** Resolve the map-write output (a ref to the node result / static arr wrapping it) to an R expr,
+ * reading the map node id from its native local via a 1-key borrowed scope. */
+function emitStaticRMapOut(node, id, local, priorNodeAt, _nodeResult) {
+    const arr = staticArrElems(node);
+    if (arr !== null) {
+        if (arr.length === 0)
+            return `Ok::<Value, behavior_contracts::ExprFailure>(Value::Arr(Vec::new()))`;
+        const elems = arr.map((el) => `(${emitStaticRMapOut(el, id, local, priorNodeAt, _nodeResult)})?`).join(", ");
+        return `Ok::<Value, behavior_contracts::ExprFailure>(Value::Arr([${elems}].into()))`;
+    }
+    const e = classifyExpr(node);
+    switch (e.kind) {
+        case "str":
+            return `${P}::str_native(${rustStrLit(e.value)})`;
+        case "bool":
+            return `${P}::bool_native(${e.value ? "true" : "false"})`;
+        case "null":
+            return `${P}::null_native()`;
+        case "ref": {
+            const head = e.path[0];
+            const fn = e.opt ? "ref_opt_native" : "ref_native";
+            const path = e.path.map(rustStrLit).join(", ");
+            if (head === id) {
+                return `${P}::${fn}(&[${path}], &[(${rustStrLit(head)}.to_string(), ${local}.clone())])`;
+            }
+            return `${P}::${fn}(&[${path}], input)`;
+        }
+        case "concat": {
+            const parts = e.parts.map((p) => `(${emitStaticRMapOut(reconstruct(p), id, local, priorNodeAt, _nodeResult)})?`).join(", ");
+            return `${P}::concat_native(&[${parts}])`;
+        }
+        default:
+            throw new Error("rust native: non-static map output reached emitStaticRMapOut");
+    }
+}
+/** Emit the element ports struct + PortReader, plus a batch ports struct (when batched). */
+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`;
+    return `${elemStruct}
+
+// ${batchStruct} — NATIVE batched ports for map '${id}': holds the Vec of per-element native ports
+// structs (a Vec<${structName}>, NOT the banned generic Vec<(String,Value)> container). A consumer's
+// batched handler downcasts via as_any() to read the typed element ports; port() returns None (the
+// element structs are not individually Value-boxable — the de-box is the whole point).
+struct ${batchStruct} {
+    items: Vec<${structName}>,
+}
+impl behavior_contracts::PortReader for ${batchStruct} {
+    fn port(&self, _name: &str) -> Option<Value> { None }
+    fn as_any(&self) -> &dyn std::any::Any { self }
+}`;
+}
+function emitBindNative(ctx) {
+    const native = ctx.ir.components.filter(isNative);
+    const arms = native.map((c) => `        ${rustStrLit(c.name)} => run_native_${sanitize(c.name)}(&mut self.handlers, input),`).join("\n");
+    const names = native.map((c) => rustStrLit(c.name)).join(", ");
+    return `// bind_native — the NATIVE-PORTS dispatch surface (bc 0.5.0): binds a NativeComponentExec
+// (native ports struct + boxed Value result) to the de-plumbed runners. Only native-covered
+// components are exposed; a consumer keeps the rest on the generic bind. Additive.
+pub fn bind_native<H: behavior_contracts::NativeComponentExec>(handlers: H) -> BoundNative<H> {
+    BoundNative { handlers }
+}
+
+pub struct BoundNative<H: behavior_contracts::NativeComponentExec> {
+    handlers: H,
+}
+
+impl<H: behavior_contracts::NativeComponentExec> BoundNative<H> {
+    pub fn call(&mut self, name: &str, input: &[(String, Value)]) -> Result<Value, BehaviorError> {
+        match name {
+${arms}
+            other => Err(BehaviorError::new("UNKNOWN_ENTRY", format!("component '{other}' not found in this module (fail-closed)"))),
+        }
+    }
+}
+
+// COMPONENT_NAMES_NATIVE — components exposed on the native-ports path (declaration order).
+pub const COMPONENT_NAMES_NATIVE: &[&str] = &[${names}];`;
+}
+/**
+ * emit — a native-eligible component gets ONLY the native run_native_ / bind_native path; the
+ * generic key-value run_ / bind is emitted ONLY for components that are NOT native-eligible
+ * (map/cond/concurrency). A fully-native module therefore contains ZERO generic port container
+ * (no `vec![(... .to_string(), Value ...)]`, no generic exec_ctx on the port plane) — the owner
+ * purity requirement + grep gate. We drive the generic rust emitter with a FILTERED context
+ * (non-native components only).
+ */
+function emit(ctx) {
+    const native = ctx.ir.components.filter(isNative);
+    const nonNative = ctx.ir.components.filter((c) => !isNative(c));
+    const filteredCtx = {
+        ...ctx,
+        ir: { ...ctx.ir, components: nonNative },
+        componentNames: nonNative.map((c) => c.name),
+    };
+    let straightlineCode = rustStraightlineEmitter.emit(filteredCtx);
+    // A native module still carries the generic body FOR THE NON-NATIVE components (bind/Bound/
+    // run_ fns); when the module has native components, the generic `bind` is dead only if every
+    // component is native (then the generic body is component-empty). Allow dead_code at module
+    // level so the carried generic surface + the native surface coexist clippy-clean regardless of
+    // which the consumer drives (mirrors the raw-abi emitter).
+    // When a native module carries the generic scaffold ONLY for non-native components (or, in a
+    // fully-native module, an EMPTY generic bind/Bound/dispatch with no component arms), that dead
+    // scaffold trips dead_code / unused_imports / unused_variables / match_single_binding. Allow
+    // them at module level: the scaffold is legitimately dead there, and — crucially — it holds NO
+    // generic key-value port container (no vec!/to_string-key/boxed-Value), which is what the owner
+    // purity gate forbids. The native surface below is the live, de-plumbed path.
+    straightlineCode = straightlineCode.replace("#![allow(non_snake_case)]", "#![allow(non_snake_case)]\n#![allow(dead_code, unused_imports, unused_variables, clippy::match_single_binding)]");
+    if (native.length === 0) {
+        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 banner = `// ── NATIVE-PORTS layer (bc 0.5.0 — de-plumb the port container) ────────────────────
+// A native-eligible component is emitted ONLY here (run_native_ + bind_native) — its generic
+// key-value run_ / bind is NOT emitted (a fully-native module has zero generic port container:
+// no vec! of (heap-key, boxed Value)). Each componentRef constructs a native ports struct by
+// direct construction and dispatches via the native handler seam (NativeComponentExec).
+// Components that are NOT native-eligible (map/cond/concurrency) keep the generic key-value
+// run_ / bind above. Fail-closed operator semantics still route through the primitives.`;
+    const sections = [
+        banner,
+        `// Native ports structs (one per componentRef node; typed per the static port type).\n${structs.join("\n\n")}`,
+        `// Native-ports straight-line runners (called by bind_native).\n${runners}`,
+        emitBindNative(ctx),
+    ];
+    return `${straightlineCode.replace(/\n+$/, "\n")}\n${sections.join("\n\n")}\n`;
+}
+/**
+ * rustStraightlineNativeEmitter — language id `rust-straightline-native` (bc 0.5.0). Emits the
+ * generic straight-line body plus the NATIVE-PORTS layer (per-node ports struct + bind_native
+ * through NativeComponentExec). Additive: the generic bind / literal / ir endpoints are unchanged.
+ */
+export const rustStraightlineNativeEmitter = {
+    language: "rust-straightline-native",
+    fileExtension: ".rs",
+    defaultRuntimeImport: "behavior_contracts",
+    filenameHint: "behaviors_straightline_native_generated.rs",
+    emit,
+};
+//# sourceMappingURL=emit-straightline-native-rust.js.map