behavior-contracts 0.5.0 → 0.6.0

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

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