behavior-contracts 0.4.0 → 0.5.0

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

@@ -0,0 +1,1673 @@
+import { GeneratorFailure } from "./core.js";
+import { rustStraightlineInternals } from "./emit-straightline-rust.js";
+import { rustTypedInternals } from "./emit-straightline-typed-rust.js";
+import { buildTypePlan, deriveTypeRef, findDecl } from "./typed.js";
+import { concurrencyPlan, execPlan, analyzeSequentialOps, classifyExpr } from "./straightline.js";
+const { sanitize, rustStrLit } = rustStraightlineInternals;
+const { rustFieldName, renderTypeRef, typedCell, typedFieldAccess, serializeTyped, emitTypeDecls, emitDefaults, emitSerializers, emitTypedValue, emitMarshallers, emitMarshalHelpers, materializeExpr, } = rustTypedInternals;
+/** rustErr — build the LOCAL concrete error value for a behavior/plan failure on the covered read
+ * plane (runtime-free). The covered module declares a local `BehaviorError` (see emitBehaviorErrorType);
+ * the runner returns `Result<_, BehaviorError>` over THAT local type. This REPLACES the old
+ * `behavior_contracts::BehaviorError::new(...)` (the last error-plane runtime coupling) — the SAME codes
+ * are preserved verbatim so the observed failure is byte-equal to run_behavior. */
+function rustErr(code, msgExpr) {
+    return `BehaviorError::new(${JSON.stringify(code)}, ${msgExpr})`;
+}
+/** emitBehaviorErrorType — the LOCAL concrete error type baked into the covered module so a runner can
+ * fail closed with ZERO bc-runtime import. Codes match run_behavior verbatim (byte-equal). `code()` /
+ * `failure_code()` expose the stable code without a bc-runtime type. */
+function emitBehaviorErrorType() {
+    return `// BehaviorError — the LOCAL concrete failure type for the covered read plane (runtime-free): a
+// covered runner returns \`Result<T, BehaviorError>\` over THIS local type instead of a bc-runtime
+// failure, so the fully-covered module imports ZERO bc runtime. Codes match run_behavior verbatim
+// (byte-equal). The observe companion (test glue, a super:: submodule) bridges this local error to the
+// bc-runtime BehaviorError at the observe boundary — the covered module itself stays runtime-free.
+#[derive(Debug, Clone)]
+pub struct BehaviorError {
+    pub code: String,
+    pub message: String,
+}
+
+impl BehaviorError {
+    pub fn new(code: impl Into<String>, message: impl Into<String>) -> Self {
+        BehaviorError { code: code.into(), message: message.into() }
+    }
+    /// The stable failure code (byte-equal to run_behavior) WITHOUT a bc-runtime type.
+    pub fn code(&self) -> &str {
+        &self.code
+    }
+}
+
+impl std::fmt::Display for BehaviorError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}: {}", self.code, self.message)
+    }
+}
+impl std::error::Error for BehaviorError {}`;
+}
+function portFieldName(wire) {
+    const safe = wire.replace(/[^A-Za-z0-9_]/g, "_").toLowerCase();
+    return `f_${safe}`;
+}
+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 portsStructName(compName, nodeId) {
+    return `PortsNR${pascal(compName)}${pascal(nodeId)}`;
+}
+/** RawRowNR<Comp><Node> — the concrete per-node handler-result row struct name. */
+function rawRowStructName(compName, nodeId) {
+    return `RawRowNR${pascal(compName)}${pascal(nodeId)}`;
+}
+/** RawElemNR<Comp><Node> — the concrete per-ELEMENT row struct name for a covered map node. */
+function rawElemStructName(compName, nodeId) {
+    return `RawElemNR${pascal(compName)}${pascal(nodeId)}`;
+}
+/** HandlerNR<Comp> — the per-component concrete handler trait name (one node_* method per node). */
+function handlerTraitName(compName) {
+    return `HandlerNR${pascal(compName)}`;
+}
+/** node_<id> — the concrete per-node handler method name. */
+function nodeMethodName(nodeId) {
+    return `node_${nodeId.replace(/[^A-Za-z0-9_]/g, "_").toLowerCase()}`;
+}
+/** InNR<Comp> — the concrete per-component input struct name (fields = inputPorts). */
+function inStructName(compName) {
+    return `InNR${pascal(compName)}`;
+}
+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 inferPortType(node, inputPorts) {
+    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";
+    }
+}
+/** A static string-array port (every element a static string literal) — the graphddb `projection`
+ * shape. Returns the list of literal strings, or null when the node is not that shape. */
+function staticStringArrElems(node) {
+    const arr = staticArrElems(node);
+    if (arr === null)
+        return null;
+    const out = [];
+    for (const el of arr) {
+        const e = classifyExpr(el);
+        if (e.kind !== "str")
+            return null;
+        out.push(e.value);
+    }
+    return out;
+}
+/**
+ * portFieldRustType — the NATIVE Rust type for a covered port field (bc#90 / runtime-free). The covered
+ * ports struct carries NO `Value` field: every port lowers to a concrete Rust type.
+ *   - a static string-array (projection) → `Vec<&'static str>` (change #2);
+ *   - a bare int/float number literal (e.g. Query `limit: 20`) → `i64` / `f64`;
+ *   - a string/bool/scalar-input port → the scalar Rust type (inferPortType).
+ * A port that would otherwise infer to the boxed `Value` (a dynamic operator, a non-static array, a
+ * Value-typed input) FAILS CLOSED — the covered read plane admits NO boxed escape (there is no `Value`
+ * fallback on the native module). `where` names the emission site for the error.
+ */
+function portFieldRustType(node, inputPorts, where = "port") {
+    if (staticStringArrElems(node) !== null)
+        return "Vec<&'static str>";
+    const num = numLiteralRustExpr(node);
+    if (num !== null)
+        return typeof node === "number" && Number.isInteger(node) ? "i64" : "f64";
+    const ft = inferPortType(node, inputPorts);
+    if (ft === "Value") {
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust combined read (bc#90 / runtime-free): ${where} '${JSON.stringify(node)}' does not lower to a native Rust type (would need a boxed Value). The covered read plane is runtime-free and admits NO boxed escape — the covered corpus ports are string / bool / static-string-array (projection) / bare-number (limit) only. Regenerate on the boxed straight-line path if this port is genuinely dynamic.`);
+    }
+    return ft;
+}
+/**
+ * emitPortsStruct — the CONCRETE native ports struct for a componentRef node. Typed fields per the
+ * static port type, constructed directly. NO `impl PortReaderT` / by-name `port()` — the covered runner
+ * passes `&PortsNR…` to the concrete `node_*` method by direct generic instantiation, and the handler
+ * reads `ports.f_<field>` DIRECTLY. The struct derives Clone (a bc#87 parallel stage clones it into the
+ * per-worker dispatch). Every field is a NATIVE Rust type (bc#90 / runtime-free) — NO boxed `Value`.
+ */
+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}' (${node.component}); no ports.\n#[derive(Clone)]\npub struct ${name};`;
+    }
+    const types = portNames.map((p) => portFieldRustType(node.ports[p], comp.inputPorts, `port '${p}' of node '${node.id}'`));
+    const fields = portNames
+        .map((p, i) => `    pub ${portFieldName(p)}: ${types[i]}, // ${JSON.stringify(p)}`)
+        .join("\n");
+    return `// ${name} — CONCRETE native ports for node '${node.id}' (${node.component}). Typed fields per the
+// static port type; constructed directly (no Vec, no heap key strings, no per-port Value boxing). The
+// handler reads the typed fields directly off this concrete struct — no by-name accessor.
+#[derive(Clone)]
+pub struct ${name} {
+${fields}
+}`;
+}
+/**
+ * emitMapPortsStructs — element ports struct + batch struct for a covered map node (CONCRETE). The batch
+ * struct carries the Vec of per-element CONCRETE ports structs (the handler reads them off the concrete
+ * struct — no by-name accessor, no key-value object).
+ */
+function emitMapPortsStructs(comp, node) {
+    const m = node.map;
+    const name = portsStructName(comp.name, node.id);
+    const batch = `${name}Batch`;
+    const elemStruct = emitPortsStruct(comp, { id: node.id, component: m.component, ports: m.ports });
+    return `${elemStruct}
+
+// ${batch} — CONCRETE batched ports for map '${node.id}': the Vec of per-element CONCRETE ports structs
+// (a Vec<${name}>, NOT a generic key-value container). The consumer's batched handler reads the typed
+// element ports off the concrete struct directly.
+#[derive(Clone)]
+pub struct ${batch} {
+    pub items: Vec<${name}>,
+}`;
+}
+// ── CONCRETE per-node row structs + row→outType copiers (mirror the Go concrete contract) ──────────
+//
+// Each covered node has a CONCRETE row struct `RawRowNR<Comp><Node>` whose fields are the node's projected
+// outType fields (typed, flattened) plus a per-node error signal (is_error/err). A named-struct outType
+// flattens to one Rust field per outType field; a scalar/arr/opt node carries a single `val: <typed>`
+// payload. The per-component `HandlerNR<Comp>` trait has one method per node returning that concrete
+// struct; the runner reads `row.<field>` DIRECTLY (no `RawValue`, no `match`, no `Value::`) and copies
+// each field into the node's outType struct local.
+/** emitRawRowStructs — emit the concrete `RawRowNR<Comp><Node>` struct per covered node (+ per-element
+ * `RawElemNR<Comp><Node>` for a covered map). Every row carries the per-node error signal (is_error/err). */
+function emitRawRowStructs(comp, typedNodes, plan) {
+    const parts = [];
+    for (const n of comp.body) {
+        const ref = typedNodes.get(n.id);
+        if ("map" in n) {
+            const arrRef = ref;
+            const elemRowRef = mapElemRowRef(n, arrRef, plan);
+            parts.push(emitOneRowStruct(rawElemStructName(comp.name, n.id), elemRowRef, plan));
+            parts.push(`// ${rawRowStructName(comp.name, n.id)} — the BATCH row for map '${n.id}': the aligned per-element rows.\n` +
+                `#[derive(Default)]\npub struct ${rawRowStructName(comp.name, n.id)} {\n    pub is_error: bool,\n    pub err: String,\n    pub rows: Vec<${rawElemStructName(comp.name, n.id)}>,\n}`);
+            continue;
+        }
+        parts.push(emitOneRowStruct(rawRowStructName(comp.name, n.id), ref, plan));
+    }
+    return parts.join("\n\n");
+}
+/** Emit one concrete row struct: flatten a named outType to typed fields, else a single `val` payload;
+ * always carry is_error/err. Derives Default so a handler can build an error row cheaply (`..Default`). */
+function emitOneRowStruct(name, ref, plan) {
+    const lines = [];
+    lines.push(`// ${name} — CONCRETE handler-result row (typed fields = the node's outType; + error signal).`);
+    lines.push(`#[derive(Default)]`);
+    lines.push(`pub struct ${name} {`);
+    lines.push(`    pub is_error: bool,`);
+    lines.push(`    pub err: String,`);
+    if (ref.kind === "named") {
+        const decl = findDecl(plan, ref.name);
+        for (const f of decl.fields) {
+            lines.push(`    pub ${rustFieldName(f.name)}: ${renderTypeRef(f.type)}, // ${JSON.stringify(f.name)}`);
+        }
+    }
+    else {
+        lines.push(`    pub val: ${renderTypeRef(ref)},`);
+    }
+    lines.push(`}`);
+    return lines.join("\n");
+}
+/** emitRowCopy — the statement copying a concrete row's typed fields into the node's outType local
+ * `target` (a value of Rust type renderTypeRef(ref)). Named: struct literal from the row's moved fields;
+ * scalar/arr/opt: `.val`. `rowExpr` is the concrete row VALUE (moved). No dynamic read — pure move/copy. */
+function emitRowMove(target, rowExpr, ref, plan) {
+    if (ref.kind === "named") {
+        const decl = findDecl(plan, ref.name);
+        const inits = decl.fields.map((f) => `${rustFieldName(f.name)}: ${rowExpr}.${rustFieldName(f.name)}`).join(", ");
+        return `${target} = ${ref.name} { ${inits} };`;
+    }
+    return `${target} = ${rowExpr}.val;`;
+}
+/**
+ * boundRustType (change #3 — typed `bound`) — the CONCRETE Rust type of a covered node's `bound` handler
+ * param (bc#90 / runtime-free). `bound` is the parent-produced key (the bindField value); it replaces the
+ * old boxed `Value`. We represent PRODUCED-vs-UNPRODUCED with an OWNED `Option<K>`: `Some(v)` = the parent
+ * value was produced/present (an empty string is a VALID produced value — `Some("")`); `None` =
+ * UNPRODUCED/skip (exactly the old `!= Null` guard ≡ run_behavior). `K` is the bindField's concrete Rust
+ * type (a string key here). A node WITHOUT a bindField never receives a bound value — its param is an
+ * `Option<String>` placeholder always passed `None` (a typed None, so the ABI stays uniform and carries
+ * NO Value).
+ */
+function boundRustType(node, typedNodes, plan) {
+    if (node.bindField === undefined || node.parent === undefined)
+        return "Option<String>";
+    const parentRef = typedNodes.get(node.parent);
+    if (parentRef === undefined)
+        return "Option<String>";
+    let bfRef;
+    try {
+        bfRef = typedFieldAccess(`${typedCell(node.parent)}.borrow()`, parentRef, [node.bindField], plan).ref;
+    }
+    catch {
+        return "Option<String>";
+    }
+    // opt bindField: the field is already `Option<T>` — the bound is that same Option. A required scalar
+    // bindField: the bound is `Option<T>` (always Some — the "produced" pointer is never None).
+    if (bfRef.kind === "opt")
+        return `Option<${renderTypeRef(bfRef.inner)}>`;
+    return `Option<${renderTypeRef(bfRef)}>`;
+}
+/**
+ * emitHandlerTrait — the per-component `HandlerNR<Comp>` trait: one concrete-typed `node_*` method per
+ * covered node. A componentRef node method takes the node's native ports struct + the typed produced-aware
+ * `bound` (change #3 — NO boxed Value) and returns Option<RawRowNR…> (None = unknown component,
+ * fail-closed). A covered map node's method takes the batch ports struct (batched) or the element ports
+ * struct (per-element). This is the fully-concrete, runtime-free replacement for the NativeRawComponentExec
+ * seam.
+ */
+function emitHandlerTrait(comp, typedNodes, plan, isAsync = false) {
+    // bc#97: async I/O model (uniform) — every terminal handler method is an `async fn` so a consumer's
+    // async node_* returns a future that the (async) runner awaits at the call site. Default = plain `fn`
+    // (byte-identical to the pre-#97 sync output). `async fn` needs NO external runtime to compile — the
+    // future is `async fn` sugar over std, so the covered module stays runtime-free either way.
+    const fnKw = isAsync ? "async fn" : "fn";
+    const lines = [];
+    lines.push(`// ${handlerTraitName(comp.name)} — the CONCRETE per-component handler seam: one typed method`);
+    lines.push(`// per covered node (native ports struct IN, concrete row struct OUT). No generic boxed-ports`);
+    lines.push(`// / boxed-value / dynamic accessor crosses the covered boundary — the consumer implements each`);
+    lines.push(`// node_* with a decode of its own wire payload into the concrete row (see INTEGRATION.md §6).`);
+    lines.push(`pub trait ${handlerTraitName(comp.name)} {`);
+    for (const n of comp.body) {
+        const method = nodeMethodName(n.id);
+        const bt = boundRustType(n, typedNodes, plan);
+        if ("map" in n) {
+            const m = n.map;
+            const batched = m.batched === true;
+            const portsT = batched ? `${portsStructName(comp.name, n.id)}Batch` : portsStructName(comp.name, n.id);
+            const retT = batched ? rawRowStructName(comp.name, n.id) : rawElemStructName(comp.name, n.id);
+            lines.push(`    ${fnKw} ${method}(&self, ports: &${portsT}, bound: ${bt}) -> Option<${retT}>;`);
+            continue;
+        }
+        lines.push(`    ${fnKw} ${method}(&self, ports: &${portsStructName(comp.name, n.id)}, bound: ${bt}) -> Option<${rawRowStructName(comp.name, n.id)}>;`);
+    }
+    lines.push(`}`);
+    return lines.join("\n");
+}
+/** mapElemMaterializerName — the augmented-element copier for a covered map...into node. */
+function mapElemMaterializerName(nodeId) {
+    return `materialize_map_elem_${typedCell(nodeId)}`;
+}
+/** mapElemRowRef — the handler's per-element RETURN shape for a covered map node: the `into` field's
+ * type (into) or the element outType directly (no-into). This is the type of RawElemNR<Comp><Node>. */
+function mapElemRowRef(node, arrRef, plan) {
+    const m = node.map;
+    if (m.into === undefined)
+        return arrRef.elem;
+    if (arrRef.elem.kind !== "named") {
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust combined map (#86 pt2): node '${node.id}' element outType must be a named struct — regenerate as boxed typed/straight-line.`);
+    }
+    const decl = findDecl(plan, arrRef.elem.name);
+    const intoField = decl.fields.find((f) => f.name === m.into);
+    if (!intoField) {
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust combined map (#86 pt2): element struct '${arrRef.elem.name}' has no '${m.into}' (into) field.`);
+    }
+    return intoField.type;
+}
+/**
+ * emitMapElemMaterializers — for each covered map...into node, emit the AUGMENTED-element copier: copy
+ * the over element's typed fields + move the `into` field from the concrete per-element handler row
+ * (RawElemNR). Pure struct field assignment — NO dynamic value read (the handler already produced the
+ * typed into row).
+ */
+function emitMapElemMaterializers(comp, typedNodes, plan) {
+    const parts = [];
+    for (const n of comp.body) {
+        if (!("map" in n))
+            continue;
+        const m = n.map;
+        // #93 shape 3: a NO-into map materializes each element directly from the per-element row.
+        if (m.into === undefined)
+            continue;
+        const arrRef = typedNodes.get(n.id);
+        if (arrRef.kind !== "arr" || arrRef.elem.kind !== "named") {
+            throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust combined map (#86 pt2): node '${n.id}' element outType must be a named struct — regenerate as boxed typed/straight-line.`);
+        }
+        const elemRef = arrRef.elem;
+        const decl = findDecl(plan, elemRef.name);
+        const intoKey = m.into;
+        const intoField = decl.fields.find((f) => f.name === intoKey);
+        const overFields = decl.fields.filter((f) => f.name !== intoKey);
+        const overElemTy = mapOverElemType(comp, n, typedNodes, plan);
+        const fn = mapElemMaterializerName(n.id);
+        const elemRowGo = rawElemStructName(comp.name, n.id);
+        const intoRowRef = mapElemRowRef(n, arrRef, plan);
+        const inits = [];
+        for (const f of overFields)
+            inits.push(`        ${rustFieldName(f.name)}: over.${rustFieldName(f.name)}.clone(),`);
+        // move the into field off the concrete element row (named → struct literal; scalar/arr/opt → .val).
+        const intoValue = intoRowRef.kind === "named"
+            ? `${intoRowRef.name} { ${findDecl(plan, intoRowRef.name).fields.map((f) => `${rustFieldName(f.name)}: into.${rustFieldName(f.name)}`).join(", ")} }`
+            : `into.val`;
+        parts.push(`#[allow(dead_code)]
+fn ${fn}(over: &${overElemTy}, into: ${elemRowGo}) -> ${elemRef.name} {
+    ${elemRef.name} {
+${inits.join("\n")}
+        ${rustFieldName(intoKey)}: ${intoValue},
+    }
+}`);
+        void intoField;
+    }
+    return parts.join("\n\n");
+}
+/** The Rust type of the over-element for a covered map node (parent collection element type). */
+function mapOverElemType(comp, node, typedNodes, plan) {
+    const m = node.map;
+    const e = classifyExpr(m.over);
+    if (e.kind === "ref" && e.path.length >= 1 && typedNodes.has(e.path[0])) {
+        const baseRef = typedNodes.get(e.path[0]);
+        const { ref } = typedFieldAccess(`${typedCell(e.path[0])}.borrow()`, baseRef, e.path.slice(1), plan);
+        if (ref.kind === "arr")
+            return renderTypeRef(ref.elem);
+    }
+    throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust combined map (#86 pt2): map '${node.id}' 'over' must be a ref to a prior node's typed arr field.`);
+}
+// ── eligibility ─────────────────────────────────────────────────────────────────────
+function reconstructR(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(reconstructR) };
+        case "dynamic":
+            return e.node;
+    }
+}
+/**
+ * numLiteralRustExpr — a BARE numeric port literal (JSON number, e.g. the `limit: 20` Query port).
+ * `classifyExpr` leaves a bare number `dynamic` (its checked int/float range rules are the evaluate
+ * SSoT), so it never reaches the static str/bool/null branch — but a number literal IS statically
+ * resolvable to a native `Value`: the SAME range check the runtime applies (integral literal in the
+ * safe 2^53-1 window → Value::Int; a fractional/exponent literal → the checked Value::Float) is
+ * performed HERE at generation time. Returns the Rust expression for the literal's Value, or null
+ * when the node is not a bare number OR an integral literal is out of the safe window (keeping the
+ * runtime INVALID_LITERAL semantics — the port is not covered natively, the component falls through).
+ * Mirrors behavior_contracts eval of a bare number literal exactly.
+ */
+const NUM_SAFE_INT_R = 9007199254740991; // 2^53 - 1 (expr safeInt)
+function numLiteralRustExpr(node) {
+    if (typeof node !== "number" || !Number.isFinite(node))
+        return null;
+    if (Number.isInteger(node)) {
+        if (node < -NUM_SAFE_INT_R || node > NUM_SAFE_INT_R)
+            return null; // out of safe window → not covered
+        return `Value::Int(${node}i64)`;
+    }
+    // fractional / exponent literal → checked f64 (finite, guaranteed above).
+    return `Value::Float(${node}f64)`;
+}
+/** A port node is static (literal / ref / concat of those / static arr / bare number literal) —
+ * resolvable to a native Value with no Obj / no evaluate interpreter. */
+function portIsStatic(node) {
+    const arr = staticArrElems(node);
+    if (arr !== null)
+        return arr.every(portIsStatic);
+    if (numLiteralRustExpr(node) !== null)
+        return true; // bare number literal (e.g. Query `limit`)
+    const e = classifyExpr(node);
+    switch (e.kind) {
+        case "str":
+        case "bool":
+        case "null":
+        case "ref":
+            return true;
+        case "concat":
+            return e.parts.every((p) => portIsStatic(reconstructR(p)));
+        default:
+            return false;
+    }
+}
+/** The output must lower to a typed struct/value with no scope read: a ref to a BODY NODE, an
+ * obj/arr of such, or a concat. A ref to an input param / non-concat operator is not lowerable. */
+function outputIsNativeLowerable(comp) {
+    const bodyIds = new Set(comp.body.map((n) => n.id));
+    const walk = (node) => {
+        const arr = staticArrElems(node);
+        if (arr !== null)
+            return arr.every(walk);
+        if (node !== null && typeof node === "object" && !Array.isArray(node)) {
+            const keys = Object.keys(node);
+            if (keys.length === 1 && keys[0] === "obj") {
+                const obj = node.obj;
+                return Object.keys(obj).every((k) => walk(obj[k]));
+            }
+            if (keys.length === 1 && keys[0] === "arr")
+                return true;
+        }
+        const e = classifyExpr(node);
+        if (e.kind === "str" || e.kind === "bool" || e.kind === "null")
+            return true;
+        if (e.kind === "ref")
+            return bodyIds.has(e.path[0]);
+        if (e.kind === "concat")
+            return e.parts.every((p) => walk(reconstructR(p)));
+        return false;
+    };
+    return walk(comp.output);
+}
+/**
+ * coveredMapNode — the #86 part 2 covered map shape (nestedBatchGet), rust twin of the go predicate.
+ */
+function coveredMapNode(n, bodyIds) {
+    if (n === null || typeof n !== "object" || !("map" in n))
+        return false;
+    const m = n.map;
+    if (m.when !== undefined)
+        return false;
+    if (m.policy !== undefined && m.policy !== "fail")
+        return false;
+    if (m.relationKind !== undefined && m.relationKind !== "single" && m.relationKind !== "connection")
+        return false;
+    const overE = classifyExpr(m.over);
+    if (overE.kind !== "ref" || !bodyIds.has(overE.path[0]))
+        return false;
+    const ports = m.ports;
+    for (const p of Object.keys(ports))
+        if (!portIsStatic(ports[p]))
+            return false;
+    return true;
+}
+/** A covered read SHAPE with static ports + native-lowerable output (+ covered map...into), OR a
+ * real-concurrency staged plan (bc#87) whose parallel-stage members are plain componentRef point reads. */
+function isSequentialComponentRefRead(comp) {
+    return coverageRejectReason(comp) === null;
+}
+/**
+ * coverageRejectReason — the DIAGNOSTIC twin of isSequentialComponentRefRead (bc#86/#89), rust twin of
+ * the go predicate. Returns null when the component IS a covered native read; otherwise a SPECIFIC
+ * human-readable reason naming the exact disqualifier and the offending node id. The predicate logic is
+ * IDENTICAL to isSequentialComponentRefRead (defined as `coverageRejectReason(c) === null`) so the two
+ * can never disagree. This is the message the fail-closed dispatch surfaces per non-native component.
+ */
+function coverageRejectReason(comp) {
+    const ep = execPlan(comp);
+    if (ep === null)
+        return "component is not a straight-line/staged sequential exec plan (no static exec plan)";
+    for (const [i] of ep.parallelStageOf) {
+        const n = comp.body[i];
+        if (!("component" in n))
+            return `node '${n.id}' is a non-componentRef member of a parallel stage (not native-covered)`;
+        if (n.bindField !== undefined)
+            return `node '${n.id}' is a bindField relation child inside a parallel stage (not native-covered)`;
+    }
+    const bodyIds = new Set(comp.body.map((b) => b.id));
+    for (const n of comp.body) {
+        if ("cond" in n)
+            return `node '${n.id}' is a cond branch (not yet native-covered)`;
+        if ("map" in n) {
+            if (!coveredMapNode(n, bodyIds))
+                return `node '${n.id}' is a non-covered map shape (guarded/over-input)`;
+            continue;
+        }
+        if (!("component" in n))
+            return `node '${n.id}' is not a componentRef, map, or cond node (not native-covered)`;
+        const cr = n;
+        if (cr.policy !== undefined && cr.policy !== "fail")
+            return `node '${n.id}' componentRef policy '${cr.policy}' (produced-aware output not yet native-covered)`;
+        if (cr.bindField !== undefined && cr.relationKind !== "single" && cr.relationKind !== "connection")
+            return `node '${n.id}' relationKind '${cr.relationKind ?? "point"}' not native-covered (bindField only supports single|connection)`;
+        if (cr.relationKind !== undefined && cr.relationKind !== "single" && cr.relationKind !== "connection")
+            return `relationKind '${cr.relationKind}' not native-covered (node '${n.id}')`;
+        for (const p of Object.keys(cr.ports))
+            if (portIsStatic(cr.ports[p]) === false)
+                return `node '${n.id}' port '${p}' is not statically resolvable`;
+    }
+    if (!outputIsNativeLowerable(comp))
+        return "output is not natively lowerable";
+    return null;
+}
+function isFullyTyped(comp) {
+    if (comp.outputType === undefined)
+        return false;
+    for (const n of comp.body)
+        if (n.outType === undefined)
+            return false;
+    return true;
+}
+function isNativeRaw(comp) {
+    return isSequentialComponentRefRead(comp) && isFullyTyped(comp);
+}
+function assertTypedCoverage(comp) {
+    if (!isSequentialComponentRefRead(comp))
+        return;
+    if (isFullyTyped(comp))
+        return;
+    throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust combined read (bc#77): component '${comp.name}' is a sequential componentRef read but lacks outType/outputType on every node — the combined emitter de-boxes the RESULT into the node's outType struct, so a covered read MUST be fully typed (bc#45). Add outType annotations, or regenerate on rust-straightline-native (boxed result).`);
+}
+// ── typed input struct (InNR<Comp>) + NATIVE scalar port lowering ────────────────────────────
+/** Rust type for an input port's declared type (scalar → concrete; anything else → Value). */
+function inputPortRustType(schema) {
+    switch (schema?.type) {
+        case "string":
+            return "String";
+        case "int":
+            return "i64";
+        case "float":
+            return "f64";
+        case "bool":
+            return "bool";
+        default:
+            return "Value";
+    }
+}
+/** The scalar kind an input port declares, or undefined if it is not a native scalar. */
+function inputScalarKind(schema) {
+    switch (schema?.type) {
+        case "string":
+            return "String";
+        case "int":
+            return "i64";
+        case "float":
+            return "f64";
+        case "bool":
+            return "bool";
+        default:
+            return undefined;
+    }
+}
+/** emitInStruct — the concrete input struct declaration for a covered component (fields = inputPorts).
+ * Empty inputPorts => empty struct. Derives Default so a consumer/test can build it field-by-field. */
+function emitInStruct(comp) {
+    const name = inStructName(comp.name);
+    const ports = Object.keys(comp.inputPorts ?? {});
+    if (ports.length === 0) {
+        return `// ${name} — the CONCRETE input for '${comp.name}' (no input ports).\n#[derive(Default)]\npub struct ${name};`;
+    }
+    const fields = ports
+        .map((p) => `    pub ${rustFieldName(p)}: ${inputPortRustType(comp.inputPorts[p])}, // ${JSON.stringify(p)}`)
+        .join("\n");
+    return `// ${name} — the CONCRETE input for '${comp.name}' (fields = inputPorts; typed, consumer-built —
+// NO generic Value slice, NO per-field boxing crosses the covered read boundary).
+#[derive(Default)]
+pub struct ${name} {
+${fields}
+}`;
+}
+/**
+ * emitNativeScalar — lower a static port expr to a NATIVE Rust expression of the concrete `want` scalar
+ * type, or null if it cannot be statically proven that type. A string literal is native for
+ * `want==="string"`, a bool literal for `want==="bool"`. A ref resolves via `resolveRef`. A concat lowers
+ * ONLY into `string` and only when EVERY part is a native string, emitting a single `format!("{}{}…", …)`.
+ */
+function emitNativeScalar(node, want, resolveRef) {
+    if (staticArrElems(node) !== null)
+        return null;
+    const e = classifyExpr(node);
+    switch (e.kind) {
+        case "str":
+            return want === "String" ? `${rustStrLit(e.value)}.to_string()` : null;
+        case "bool":
+            return want === "bool" ? (e.value ? "true" : "false") : null;
+        case "null":
+            return null;
+        case "ref": {
+            const sc = resolveRef(e.path[0], e.path.slice(1), e.opt);
+            if (sc === null || sc.scalar !== want)
+                return null;
+            return sc.expr;
+        }
+        case "concat": {
+            if (want !== "String")
+                return null;
+            // a single-part concat is just the owned String of that part.
+            if (e.parts.length === 1)
+                return emitNativeScalar(reconstructR(e.parts[0]), "String", resolveRef);
+            // multi-part: fold into ONE format! (statically strings only — the concat's strings-only
+            // TYPE_MISMATCH can never fire, so dropping the check is sound). To stay clippy-clean
+            // (to_string_in_format_args), a string-literal part is baked into the format STRING itself
+            // (escaped) rather than passed as a `{}` arg; a ref part becomes a `{}` arg (Display on String).
+            let fmt = "";
+            const args = [];
+            for (const p of e.parts) {
+                const sub = classifyExpr(reconstructR(p));
+                if (sub.kind === "str") {
+                    fmt += sub.value.replace(/[{}]/g, (c) => c + c); // escape { } for the format string
+                    continue;
+                }
+                const arg = emitNativeScalar(reconstructR(p), "String", resolveRef);
+                if (arg === null)
+                    return null;
+                fmt += "{}";
+                args.push(arg);
+            }
+            if (args.length === 0)
+                return `${rustStrLit(fmt)}.to_string()`;
+            return `format!(${rustStrLit(fmt)}, ${args.join(", ")})`;
+        }
+        default:
+            return null;
+    }
+}
+// bc#90 / runtime-free: the old `emitStaticR` / `inputLeafR` / `valueLeafR` port lowering (which built
+// `Value` leaves via the primitives::* helpers and struct-field serializers) is REMOVED — every covered
+// port now lowers to a FULLY NATIVE Rust value in emitPortInit (string / bool / static-string-array /
+// number literal), and a genuinely-dynamic port fails closed. There is no boxed-Value fallback on the
+// covered read plane.
+/**
+ * emitPortInit — emit the port field build for one port as a FULLY NATIVE Rust expression (bc#90 /
+ * runtime-free). Every covered port lowers to a concrete Rust value assigned straight into the ports
+ * struct field — NO `Value`, NO fallback path, NO `match`:
+ *   - a static string array (projection) → `vec!["a", "b", ...]` (change #2);
+ *   - a bare int/float number literal (e.g. Query `limit: 20`) → `20i64` / `<n>f64`;
+ *   - a string/bool/scalar-input port → the native scalar expression (emitNativeScalar).
+ * A port that CANNOT lower natively FAILS CLOSED (there is no boxed Value fallback on the covered plane —
+ * a boxed escape would re-introduce the bc-runtime coupling this module removes). `fieldRustType` is the
+ * ports-struct field type (from portFieldRustType); `resolveRef` resolves a ref head for the scalar path.
+ */
+function emitPortInit(pn, expr, fieldRustType, resolveRef) {
+    const field = portFieldName(pn);
+    // change #2: a static string array (projection) → a native `vec![...]` of &'static str.
+    const strArr = staticStringArrElems(expr);
+    if (strArr !== null) {
+        if (fieldRustType !== "Vec<&'static str>") {
+            throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust combined read (bc#90): port '${pn}' is a static string array but its field type is '${fieldRustType}' (expected Vec<&'static str>).`);
+        }
+        return `${field}: vec![${strArr.map((s) => rustStrLit(s)).join(", ")}]`;
+    }
+    // a bare number literal (e.g. Query `limit: 20`): the SSoT range check ran in numLiteralRustExpr —
+    // emit the concrete native i64/f64 (unwrap the Value::Int/Float box: it was only there for the old
+    // boxed path; the range check is what matters, and it already passed).
+    const num = numLiteralRustExpr(expr);
+    if (num !== null) {
+        if (fieldRustType === "i64")
+            return `${field}: ${expr}i64`;
+        if (fieldRustType === "f64")
+            return `${field}: ${expr}f64`;
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust combined read (bc#90): port '${pn}' is a number literal but its field type is '${fieldRustType}'.`);
+    }
+    // string / bool / scalar-input / concat → native scalar expression (no Value, no `match`).
+    const native = emitNativeScalar(expr, fieldRustType, resolveRef);
+    if (native !== null) {
+        return `${field}: ${native}`;
+    }
+    // FAIL CLOSED: the covered read plane is runtime-free — no boxed Value fallback (that would re-couple
+    // the covered module to bc-runtime). If a genuinely-dynamic port reaches here, the component is not
+    // native-eligible and must regenerate on the boxed straight-line path.
+    throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust combined read (bc#90 / runtime-free): port '${pn}' (${JSON.stringify(expr)}) does not lower to a native Rust value of type '${fieldRustType}'. The covered read plane admits NO boxed Value escape — regenerate on the boxed straight-line path if this port is genuinely dynamic.`);
+}
+// ── the combined runner (STRUCT-returning; INLINE sequential; native ports in; concrete row out) ──
+/** resolveRefAt for the top-level runner: a ref head is a PRIOR NODE (its typed scalar field) or an
+ * INPUT PORT (in_.<field>). A REQUIRED scalar resolves to an OWNED native Rust expression; opt / non-
+ * scalar / refOpt → null (fall back to the Value path). */
+function runnerResolveRef(priorNodeAt, atPos, typedNodes, plan, inputPorts) {
+    return (head, restPath, opt) => {
+        if (opt)
+            return null;
+        if (priorNodeAt(head, atPos)) {
+            const baseRef = typedNodes.get(head);
+            let acc;
+            let expr;
+            try {
+                const r = typedFieldAccess(`${typedCell(head)}.borrow()`, baseRef, restPath, plan);
+                expr = r.expr;
+                acc = r.ref;
+            }
+            catch {
+                return null;
+            }
+            if (acc.kind !== "scalar" || acc.scalar === "null")
+                return null;
+            // OWNED: a string field is cloned; int/float/bool are Copy (deref off the Ref).
+            const owned = acc.scalar === "string" ? `(${expr}).clone()` : `*(${expr})`;
+            return { expr: owned, scalar: rustScalar(acc.scalar) };
+        }
+        if (restPath.length !== 0)
+            return null;
+        const scalar = inputScalarKind(inputPorts?.[head]);
+        if (scalar === undefined)
+            return null;
+        const field = `in_.${rustFieldName(head)}`;
+        const owned = scalar === "String" ? `${field}.clone()` : field;
+        return { expr: owned, scalar };
+    };
+}
+function rustScalar(s) {
+    return s === "string" ? "String" : s === "int" ? "i64" : s === "float" ? "f64" : "bool";
+}
+function emitNativeRawRunner(comp, plan, isAsync = false) {
+    const ep = execPlan(comp);
+    const order = ep.order;
+    const hasConcurrency = ep.parallelStageOf.size > 0;
+    const fn = sanitize(comp.name);
+    // bc#97 (uniform-rust-async slice): the async runner awaits each async handler at its call site. A
+    // real-concurrency stage (bc#87) dispatches handlers from scoped std threads — that mechanism cannot
+    // host `.await` (a std thread is not an async task), and mixing it with an async terminal handler is
+    // a per-node-propagation problem outside THIS slice. Fail closed LOUDLY rather than emit code that
+    // won't compile.
+    if (isAsync && hasConcurrency) {
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust typed-native async (bc#97): component '${comp.name}' has a bc#87 real-concurrency stage, which dispatches handlers on scoped std threads and cannot await async handlers. Async + concurrent-stage is a per-node-propagation follow-up (out of this uniform-async slice) — generate this component with io-model=sync, or split the concurrency stage.`);
+    }
+    const typedNodes = new Map();
+    for (const n of comp.body)
+        typedNodes.set(n.id, deriveTypeRef(n.outType, plan));
+    const idToIndex = new Map();
+    comp.body.forEach((n, i) => idToIndex.set(n.id, i));
+    const opsLiteral = 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, bindField: cr.bindField };
+    });
+    const metas = analyzeSequentialOps(opsLiteral, order);
+    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;
+    };
+    const outRef = comp.outputType !== undefined ? deriveTypeRef(comp.outputType, plan) : undefined;
+    const outTy = outRef ? renderTypeRef(outRef) : "Value";
+    // Does any port read an input param? If not, `in_` is unused — bind it as `_in_` to stay clippy-clean.
+    const readsInput = (() => {
+        const walk = (node, atPos) => {
+            const arr = staticArrElems(node);
+            if (arr !== null)
+                return arr.some((el) => walk(el, 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(reconstructR(p), atPos));
+            return false;
+        };
+        return [...order.keys()].some((k) => {
+            const nd = comp.body[order[k]];
+            if ("map" in nd) {
+                const m = nd.map;
+                const asName = m.as;
+                const walkMap = (node) => {
+                    const arr = staticArrElems(node);
+                    if (arr !== null)
+                        return arr.some(walkMap);
+                    const e = classifyExpr(node);
+                    if (e.kind === "ref")
+                        return e.path[0] !== asName && !priorNodeAt(e.path[0], k);
+                    if (e.kind === "concat")
+                        return e.parts.some((p) => walkMap(reconstructR(p)));
+                    return false;
+                };
+                return Object.values(m.ports).some((pn) => walkMap(pn));
+            }
+            const cr = nd;
+            return Object.values(cr.ports).some((pn) => walk(pn, k));
+        });
+    })();
+    const inParam = readsInput ? "in_" : "_in_";
+    const lines = [];
+    lines.push(`// run_native_raw_struct_${fn} — the STRUCT-RETURNING combined read (bc#77/#87/#94): the fully`);
+    lines.push(`// de-plumbed CONCRETE path. Generic over the per-component CONCRETE ${handlerTraitName(comp.name)} trait,`);
+    lines.push(`// whose node_* methods take the node's native ports struct and return the concrete per-node row`);
+    lines.push(`// struct (typed fields = the outType). The runner builds each ports struct by direct native`);
+    lines.push(`// construction (a simple string port lowers to a native Rust expr), dispatches the concrete`);
+    lines.push(`// node_* method, and reads row.<field> DIRECTLY into the node's outType struct cell — no boxed`);
+    lines.push(`// handler result, no generic enum crossing, no dispatch on a dynamic value on the covered plane. Node`);
+    lines.push(`// results are typed struct cells; a relation child reads the parent's REAL struct result via`);
+    lines.push(`// direct field access (child-present decision from the real parent value — relationSingle /`);
+    lines.push(`// connection converge). A real-concurrency stage (bc#87) is static parallel orchestration —`);
+    lines.push(`// scoped worker threads (bounded by the static plan.concurrency) call the concrete node_*`);
+    lines.push(`// method; preflight + interpret are committed in ascending index order so the value / op`);
+    lines.push(`// multiset / failure precedence byte-match run_behavior. The output is a typed struct/value`);
+    lines.push(`// assembled by struct literal + field access — the consumer keeps it native.`);
+    const bound = hasConcurrency ? `<H: ${handlerTraitName(comp.name)} + Sync>` : `<H: ${handlerTraitName(comp.name)}>`;
+    // bc#97: async propagation (uniform) — if the terminal handlers are async, every handler call awaits,
+    // so the runner is itself `async fn` and returns a future the (already-async) consumer awaits. Sync
+    // default emits `pub fn` exactly as before (byte-identical).
+    const fnKw = isAsync ? "pub async fn" : "pub fn";
+    lines.push(`${fnKw} run_native_raw_struct_${fn}${bound}(`);
+    lines.push(`    handlers: &H,`);
+    lines.push(`    ${inParam}: ${inStructName(comp.name)},`);
+    lines.push(`) -> Result<${outTy}, BehaviorError> {`);
+    for (const k of order.keys()) {
+        const id = comp.body[order[k]].id;
+        lines.push(`    let ${typedCell(id)}: RefCell<${renderTypeRef(typedNodes.get(id))}> = RefCell::new(Default::default());`);
+        lines.push(`    let produced_${sanitize(id)} = std::cell::Cell::new(false);`);
+        lines.push(`    let _ = &produced_${sanitize(id)};`);
+    }
+    for (let k = 0; k < order.length; k++) {
+        const i = order[k];
+        const stage = ep.parallelStageOf.get(i);
+        if (stage !== undefined && stage[0] === i) {
+            lines.push(emitParallelStageArm(comp, stage, k, ep.concurrency, metas, typedNodes, plan, priorNodeAt));
+            k += stage.length - 1;
+            continue;
+        }
+        if ("map" in comp.body[i]) {
+            lines.push(emitMapArm(comp, comp.body[i], k, typedNodes, plan, priorNodeAt, isAsync));
+            continue;
+        }
+        const node = comp.body[i];
+        const meta = metas[i];
+        const s = sanitize(node.id);
+        const structName = portsStructName(comp.name, node.id);
+        const portNames = Object.keys(node.ports);
+        const ref = typedNodes.get(node.id);
+        lines.push(`    // ── op '${node.id}' (${node.component}${node.relationKind ? ", relationKind:" + node.relationKind : ""}${node.parent ? ", parent:" + node.parent : ""}) ──`);
+        let indent = "    ";
+        const closers = [];
+        if (node.parent !== undefined && priorNodeAt(node.parent, k)) {
+            lines.push(`${indent}if produced_${sanitize(node.parent)}.get() {`);
+            closers.unshift(`${indent}}`);
+            indent += "    ";
+            if (node.bindField !== undefined) {
+                // bind (change #3 — typed produced-aware bound): read the parent struct field DIRECTLY (typed
+                // access — no serialize). `bound_<s>` is a typed `Option<K>` — None => UNPRODUCED/skip, Some =>
+                // produced (an empty string is a VALID produced value, `Some("")`). This is the EXACT `!= Null`
+                // skip-gate ≡ run_behavior's preflightOp, now runtime-free (NO Value).
+                const parentRef = typedNodes.get(node.parent);
+                const { expr: bfExpr, ref: bfRef } = typedFieldAccess(`${typedCell(node.parent)}.borrow()`, parentRef, [node.bindField], plan);
+                if (bfRef.kind === "opt") {
+                    // an opt bindField is ALREADY an Option<T>: None => skip, Some => produced. Clone it directly.
+                    lines.push(`${indent}let bound_${s}: ${boundRustType(node, typedNodes, plan)} = ${bfExpr}.clone();`);
+                }
+                else {
+                    // a required scalar bindField is always PRESENT (never skips on null): wrap in Some so the
+                    // produced Option is never None, preserving the "produced" semantics of the old guard.
+                    const owned = bfRef.kind === "scalar" && bfRef.scalar === "string" ? `(${bfExpr}).clone()` : `*(${bfExpr})`;
+                    lines.push(`${indent}let bound_${s}: ${boundRustType(node, typedNodes, plan)} = Some(${owned});`);
+                }
+                lines.push(`${indent}if bound_${s}.is_some() {`);
+                closers.unshift(`${indent}}`);
+                indent += "    ";
+            }
+        }
+        const resolveRef = runnerResolveRef(priorNodeAt, k, typedNodes, plan, comp.inputPorts);
+        const inits = [];
+        for (const pn of portNames) {
+            const expr = node.ports[pn];
+            const ty = portFieldRustType(expr, comp.inputPorts, `port '${pn}' of node '${node.id}'`);
+            inits.push(emitPortInit(pn, expr, ty, resolveRef));
+        }
+        const boundArg = node.bindField !== undefined ? `bound_${s}` : "None";
+        const awaitSfx = isAsync ? ".await" : "";
+        lines.push(`${indent}let ports_${s} = ${structName} { ${inits.join(", ")} };`);
+        lines.push(`${indent}let row_${s} = match handlers.${nodeMethodName(node.id)}(&ports_${s}, ${boundArg})${awaitSfx} {`);
+        lines.push(`${indent}    Some(r) => r,`);
+        lines.push(`${indent}    None => return Err(unknown_component(${rustStrLit(node.component)})),`);
+        lines.push(`${indent}};`);
+        if (meta.policy === "continue") {
+            lines.push(`${indent}if !row_${s}.is_error {`);
+            lines.push(`${indent}    ${emitRowMove(`*${typedCell(node.id)}.borrow_mut()`, `row_${s}`, ref, plan)}`);
+            lines.push(`${indent}    produced_${s}.set(true);`);
+            lines.push(`${indent}}`);
+        }
+        else {
+            const label = meta.policy === "retry" ? "retry' policy (exhausted)" : "fail' policy";
+            lines.push(`${indent}if row_${s}.is_error {`);
+            lines.push(`${indent}    return Err(BehaviorError::new("OP_FAILED", format!("operation '{}' failed under '${label}: {}", ${rustStrLit(node.id)}, row_${s}.err)));`);
+            lines.push(`${indent}}`);
+            lines.push(`${indent}${emitRowMove(`*${typedCell(node.id)}.borrow_mut()`, `row_${s}`, ref, plan)}`);
+            lines.push(`${indent}produced_${s}.set(true);`);
+        }
+        for (const c of closers)
+            lines.push(c);
+    }
+    // output: assemble a TYPED struct/value (struct literal + typed field access — ZERO Value::Obj).
+    const skippable = new Set();
+    const skippableKind = new Map();
+    for (const k of order.keys()) {
+        if (metas[order[k]].canSkip) {
+            const bodyNode = comp.body[order[k]];
+            skippable.add(bodyNode.id);
+            const rk = "map" in bodyNode ? bodyNode.map.relationKind : bodyNode.relationKind;
+            skippableKind.set(bodyNode.id, rk);
+        }
+    }
+    const out = skippable.size > 0
+        ? emitProducedAwareValue(comp.output, outRef, typedNodes, plan, skippable, skippableKind)
+        : emitTypedValue(comp.output, outRef, typedNodes, plan);
+    lines.push(`    let __out = ${out.expr};`);
+    lines.push(`    Ok(__out)`);
+    lines.push(`}`);
+    return lines.join("\n");
+}
+/**
+ * emitParallelStageArm (bc#87/#94, rust CONCRETE) — EXPLICIT static parallel orchestration for a real-
+ * concurrency stage. Reproduces run_plan_parallel's deterministic protocol so the observed value / op
+ * multiset / failure precedence byte-match run_behavior:
+ *   1. PREFLIGHT (ascending): parent-produced gate + build each member's CONCRETE ports struct.
+ *   2. DISPATCH (bounded scoped threads): share `&H` (the concrete trait; `H: Sync`), pull runnable
+ *      members from a shared atomic cursor in ascending order, call the concrete node_* method. Each
+ *      concrete row lands in a per-member Mutex slot (None = unknown component).
+ *   3. COMMIT (ascending index): interpret policy + move the concrete row into the outType cell —
+ *      lowest-index failure wins.
+ */
+function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes, plan, priorNodeAt) {
+    const lines = [];
+    const ids = stage.map((i) => comp.body[i].id);
+    lines.push(`    // ── bc#87 real-concurrency stage {${ids.map((x) => rustStrLit(x)).join(", ")}} — static parallel`);
+    lines.push(`    // orchestration (scoped threads, bound=${concurrency}); preflight+commit in ascending index order.`);
+    lines.push(`    {`);
+    // 1) PREFLIGHT (ascending): build each member's CONCRETE ports struct into a stage-scoped Option local.
+    for (const i of stage) {
+        const node = comp.body[i];
+        const s = sanitize(node.id);
+        const structName = portsStructName(comp.name, node.id);
+        const gated = node.parent !== undefined && priorNodeAt(node.parent, atPos);
+        let ind = "        ";
+        const closers = [];
+        if (gated) {
+            lines.push(`        let mut ports_${s}: Option<${structName}> = None;`);
+            lines.push(`${ind}if produced_${sanitize(node.parent)}.get() {`);
+            closers.unshift(`${ind}}`);
+            ind += "    ";
+        }
+        const resolveRef = runnerResolveRef(priorNodeAt, atPos, typedNodes, plan, comp.inputPorts);
+        const inits = [];
+        for (const pn of Object.keys(node.ports)) {
+            const expr = node.ports[pn];
+            const ty = portFieldRustType(expr, comp.inputPorts, `port '${pn}' of node '${node.id}'`);
+            inits.push(emitPortInit(pn, expr, ty, resolveRef));
+        }
+        if (gated) {
+            lines.push(`${ind}ports_${s} = Some(${structName} { ${inits.join(", ")} });`);
+        }
+        else {
+            lines.push(`${ind}let ports_${s}: Option<${structName}> = Some(${structName} { ${inits.join(", ")} });`);
+        }
+        for (const c of closers)
+            lines.push(c);
+    }
+    // 2) DISPATCH (bounded scoped threads). Share `&H` (concrete trait; H: Sync). Each worker calls the
+    // concrete node_* method for its member's CONCRETE ports and stores the concrete row in its slot.
+    const nMembers = stage.length;
+    const boundN = Math.min(concurrency, nMembers);
+    const jobsVar = `jobs_${sanitize(comp.name)}`;
+    for (const i of stage) {
+        const s = sanitize(comp.body[i].id);
+        const rowT = rawRowStructName(comp.name, comp.body[i].id);
+        lines.push(`        let slot_${s}: std::sync::Mutex<Option<Option<${rowT}>>> = std::sync::Mutex::new(None);`);
+    }
+    lines.push(`        let mut ${jobsVar}: Vec<usize> = Vec::new();`);
+    stage.forEach((i, slot) => {
+        const s = sanitize(comp.body[i].id);
+        lines.push(`        if ports_${s}.is_some() { ${jobsVar}.push(${slot}); }`);
+    });
+    lines.push(`        let cursor = std::sync::atomic::AtomicUsize::new(0);`);
+    lines.push(`        let workers = ${boundN}usize.min(${jobsVar}.len());`);
+    lines.push(`        std::thread::scope(|scope| {`);
+    lines.push(`            for _ in 0..workers {`);
+    lines.push(`                scope.spawn(|| loop {`);
+    lines.push(`                    let j = cursor.fetch_add(1, std::sync::atomic::Ordering::SeqCst);`);
+    lines.push(`                    if j >= ${jobsVar}.len() { break; }`);
+    lines.push(`                    let slot = ${jobsVar}[j];`);
+    lines.push(`                    match slot {`);
+    stage.forEach((i, slot) => {
+        const node = comp.body[i];
+        const s = sanitize(node.id);
+        lines.push(`                        ${slot} => {`);
+        lines.push(`                            let ports = ports_${s}.as_ref().expect("runnable member has ports");`);
+        lines.push(`                            let row = handlers.${nodeMethodName(node.id)}(ports, None);`);
+        lines.push(`                            *slot_${s}.lock().unwrap() = Some(row);`);
+        lines.push(`                        }`);
+    });
+    lines.push(`                        _ => unreachable!(),`);
+    lines.push(`                    };`);
+    lines.push(`                });`);
+    lines.push(`            }`);
+    lines.push(`        });`);
+    // 3) COMMIT (ascending index): interpret + move the concrete row into the outType cell.
+    stage.forEach((i) => {
+        const node = comp.body[i];
+        const meta = metas[i];
+        const s = sanitize(node.id);
+        const ref = typedNodes.get(node.id);
+        lines.push(`        if ports_${s}.is_some() {`);
+        lines.push(`            let row_${s} = match slot_${s}.lock().unwrap().take() {`);
+        lines.push(`                Some(Some(r)) => r,`);
+        lines.push(`                _ => return Err(unknown_component(${rustStrLit(node.component)})),`);
+        lines.push(`            };`);
+        if (meta.policy === "continue") {
+            lines.push(`            if !row_${s}.is_error {`);
+            lines.push(`                ${emitRowMove(`*${typedCell(node.id)}.borrow_mut()`, `row_${s}`, ref, plan)}`);
+            lines.push(`                produced_${s}.set(true);`);
+            lines.push(`            }`);
+        }
+        else {
+            const label = meta.policy === "retry" ? "retry' policy (exhausted)" : "fail' policy";
+            lines.push(`            if row_${s}.is_error {`);
+            lines.push(`                return Err(BehaviorError::new("OP_FAILED", format!("operation '{}' failed under '${label}: {}", ${rustStrLit(node.id)}, row_${s}.err)));`);
+            lines.push(`            }`);
+            lines.push(`            ${emitRowMove(`*${typedCell(node.id)}.borrow_mut()`, `row_${s}`, ref, plan)}`);
+            lines.push(`            produced_${s}.set(true);`);
+        }
+        lines.push(`        }`);
+    });
+    lines.push(`    }`);
+    return lines.join("\n");
+}
+// bc#90 / runtime-free: the old `emitMapStaticR` map-element port lowering (a Value fallback) is REMOVED
+// — covered map element ports lower to a fully native Rust value in emitPortInit (the map resolveRef
+// reads the $as element / prior-node / input typed fields directly), with a fail-closed on a dynamic port.
+/**
+ * emitMapArm — the struct-native exec of a covered map node (rust CONCRETE). Three shapes:
+ *   - #86 pt2: BATCHED map...into — dispatch once (concrete batch row), augmented-element materializer.
+ *   - #93 shape 2: NON-batched map...into — dispatch ONCE PER ELEMENT (N physical requests), into per element.
+ *   - #93 shape 3: BATCHED map NO into — dispatch once, collect each element from the concrete element row.
+ */
+function emitMapArm(comp, node, atPos, typedNodes, plan, priorNodeAt, isAsync = false) {
+    const m = node.map;
+    const awaitSfx = isAsync ? ".await" : "";
+    const batched = m.batched === true;
+    const hasInto = m.into !== undefined;
+    const s = sanitize(node.id);
+    const structName = portsStructName(comp.name, node.id);
+    const batch = `${structName}Batch`;
+    const overE = classifyExpr(m.over);
+    const overParent = overE.kind === "ref" ? overE.path[0] : "";
+    const overBaseRef = typedNodes.get(overParent);
+    const { ref: overRef } = typedFieldAccess(`${typedCell(overParent)}.borrow()`, overBaseRef, overE.kind === "ref" ? overE.path.slice(1) : [], plan);
+    const overElemRef = overRef.elem;
+    const overFieldPath = overE.kind === "ref" ? overE.path.slice(1).map((p) => `.${rustFieldName(p)}`).join("") : "";
+    const elemMat = mapElemMaterializerName(node.id);
+    const priorHere = (head) => priorNodeAt(head, atPos);
+    const asName = m.as;
+    const portNames = Object.keys(m.ports);
+    const elemArrRef = typedNodes.get(node.id);
+    const elemName = elemArrRef.elem.name;
+    const resolveRef = (head, restPath, opt) => {
+        if (opt)
+            return null;
+        let baseExpr;
+        let baseRef;
+        if (head === asName) {
+            baseExpr = `oel_${s}`;
+            baseRef = overElemRef;
+        }
+        else if (priorHere(head)) {
+            baseExpr = `${typedCell(head)}.borrow()`;
+            baseRef = typedNodes.get(head);
+        }
+        else {
+            if (restPath.length !== 0)
+                return null;
+            const scalar = inputScalarKind(comp.inputPorts?.[head]);
+            if (scalar === undefined)
+                return null;
+            const field = `in_.${rustFieldName(head)}`;
+            return { expr: scalar === "String" ? `${field}.clone()` : field, scalar };
+        }
+        let acc;
+        let expr;
+        try {
+            const r = typedFieldAccess(baseExpr, baseRef, restPath, plan);
+            expr = r.expr;
+            acc = r.ref;
+        }
+        catch {
+            return null;
+        }
+        if (acc.kind !== "scalar" || acc.scalar === "null")
+            return null;
+        const owned = acc.scalar === "string" ? `(${expr}).clone()` : `*(${expr})`;
+        return { expr: owned, scalar: rustScalar(acc.scalar) };
+    };
+    // build the per-element CONCRETE native ports struct. `il` = indent inside the element loop.
+    const buildPorts = (il) => {
+        const out = [];
+        const inits = [];
+        for (const pn of portNames) {
+            const ty = portFieldRustType(m.ports[pn], comp.inputPorts, `map port '${pn}' of node '${node.id}'`);
+            inits.push(emitPortInit(pn, m.ports[pn], ty, resolveRef));
+        }
+        out.push(`${il}let ep_${s} = ${structName} { ${inits.join(", ")} };`);
+        return out;
+    };
+    const lines = [];
+    const closers = [];
+    lines.push(`    // ── map '${node.id}' (${m.component}, ${batched ? "batched" : "per-element"}, into:${JSON.stringify(m.into ?? null)}${m.relationKind ? ", relationKind:" + m.relationKind : ""}${m.parent ? ", parent:" + m.parent : ""}) ──`);
+    let indent = "    ";
+    if (m.parent !== undefined && priorNodeAt(m.parent, atPos)) {
+        lines.push(`${indent}if produced_${sanitize(m.parent)}.get() {`);
+        closers.unshift(`${indent}}`);
+        indent += "    ";
+    }
+    lines.push(`${indent}let over_${s} = ${typedCell(overParent)}.borrow()${overFieldPath}.clone();`);
+    lines.push(`${indent}let mut built_${s}: Vec<${elemName}> = Vec::with_capacity(over_${s}.len());`);
+    if (batched) {
+        lines.push(`${indent}let mut items_${s}: Vec<${structName}> = Vec::with_capacity(over_${s}.len());`);
+        lines.push(`${indent}for oel_${s} in over_${s}.iter() {`);
+        for (const l of buildPorts(indent + "    "))
+            lines.push(l);
+        lines.push(`${indent}    items_${s}.push(ep_${s});`);
+        lines.push(`${indent}}`);
+        lines.push(`${indent}if !items_${s}.is_empty() {`);
+        lines.push(`${indent}    let want_${s} = items_${s}.len();`);
+        lines.push(`${indent}    let bp_${s} = ${batch} { items: items_${s} };`);
+        lines.push(`${indent}    let row_${s} = match handlers.${nodeMethodName(node.id)}(&bp_${s}, None)${awaitSfx} {`);
+        lines.push(`${indent}        Some(r) => r,`);
+        lines.push(`${indent}        None => return Err(unknown_component(${rustStrLit(m.component)})),`);
+        lines.push(`${indent}    };`);
+        lines.push(`${indent}    if row_${s}.is_error {`);
+        lines.push(`${indent}        return Err(BehaviorError::new("OP_FAILED", format!("operation '{}' failed under 'fail' policy: {}", ${rustStrLit(node.id)}, row_${s}.err)));`);
+        lines.push(`${indent}    }`);
+        lines.push(`${indent}    if row_${s}.rows.len() != want_${s} {`);
+        lines.push(`${indent}        return Err(BehaviorError::new("MAP_BATCH_RESULT_MISMATCH", format!("map '{}': batched handler must return a list aligned to items (want {})", ${rustStrLit(node.id)}, want_${s})));`);
+        lines.push(`${indent}    }`);
+        lines.push(`${indent}    let mut rows_iter_${s} = row_${s}.rows.into_iter();`);
+        lines.push(`${indent}    for over_el_${s} in over_${s}.iter() {`);
+        lines.push(`${indent}        let er_${s} = rows_iter_${s}.next().expect("aligned batch row");`);
+        if (hasInto) {
+            lines.push(`${indent}        built_${s}.push(${elemMat}(over_el_${s}, er_${s}));`);
+        }
+        else {
+            lines.push(`${indent}        let _ = &over_el_${s};`);
+            lines.push(`${indent}        ${emitElemMove(`let el_${s}`, `er_${s}`, elemArrRef.elem, plan)}`);
+            lines.push(`${indent}        built_${s}.push(el_${s});`);
+        }
+        lines.push(`${indent}    }`);
+        lines.push(`${indent}}`);
+    }
+    else {
+        // #93 shape 2: NON-batched map...into — dispatch ONCE PER ELEMENT.
+        lines.push(`${indent}for oel_${s} in over_${s}.iter() {`);
+        for (const l of buildPorts(indent + "    "))
+            lines.push(l);
+        lines.push(`${indent}    let er_${s} = match handlers.${nodeMethodName(node.id)}(&ep_${s}, None)${awaitSfx} {`);
+        lines.push(`${indent}        Some(r) => r,`);
+        lines.push(`${indent}        None => return Err(unknown_component(${rustStrLit(m.component)})),`);
+        lines.push(`${indent}    };`);
+        lines.push(`${indent}    if er_${s}.is_error {`);
+        lines.push(`${indent}        return Err(BehaviorError::new("OP_FAILED", format!("operation '{}' failed under 'fail' policy: {}", ${rustStrLit(node.id)}, er_${s}.err)));`);
+        lines.push(`${indent}    }`);
+        if (hasInto) {
+            lines.push(`${indent}    built_${s}.push(${elemMat}(oel_${s}, er_${s}));`);
+        }
+        else {
+            lines.push(`${indent}    ${emitElemMove(`let el_${s}`, `er_${s}`, elemArrRef.elem, plan)}`);
+            lines.push(`${indent}    built_${s}.push(el_${s});`);
+        }
+        lines.push(`${indent}}`);
+    }
+    lines.push(`${indent}*${typedCell(node.id)}.borrow_mut() = built_${s};`);
+    lines.push(`${indent}produced_${sanitize(node.id)}.set(true);`);
+    for (const c of closers)
+        lines.push(c);
+    return lines.join("\n");
+}
+/** emitElemMove — move a concrete element row (RawElemNR, error already handled) into a fresh `let` local
+ * of the element outType. Named → struct literal from moved fields; scalar/arr/opt → .val. */
+function emitElemMove(letBind, rowExpr, ref, plan) {
+    if (ref.kind === "named") {
+        const decl = findDecl(plan, ref.name);
+        const inits = decl.fields.map((f) => `${rustFieldName(f.name)}: ${rowExpr}.${rustFieldName(f.name)}`).join(", ");
+        return `${letBind} = ${ref.name} { ${inits} };`;
+    }
+    return `${letBind} = ${rowExpr}.val;`;
+}
+/**
+ * emitProducedAwareValue — the #86 part 1 produced-aware output lowering (rust twin of the go one).
+ */
+function emitProducedAwareValue(node, expected, typedNodes, plan, skippable, skippableKind) {
+    const e = classifyExpr(node);
+    if (e.kind === "ref" && e.path.length >= 1 && typedNodes.has(e.path[0])) {
+        const head = e.path[0];
+        const baseRef = typedNodes.get(head);
+        if (skippable.has(head)) {
+            const base = `${typedCell(head)}.borrow().clone()`;
+            const { expr, ref } = typedFieldAccess(base, baseRef, e.path.slice(1), plan);
+            const producedExpr = valueLeafProduced(expr, ref, expected);
+            const isConn = skippableKind.get(head) === "connection" && e.path.length === 1;
+            let unproduced;
+            if (isConn) {
+                const connTy = expected && expected.kind === "opt" ? renderTypeRef(expected.inner) : renderTypeRef(expected ?? ref);
+                unproduced = expected && expected.kind === "opt" ? `Some(${connTy}::default())` : `${connTy}::default()`;
+            }
+            else {
+                unproduced = expected && expected.kind === "opt" ? "None" : "Default::default()";
+            }
+            return {
+                expr: `if produced_${sanitize(head)}.get() { ${producedExpr} } else { ${unproduced} }`,
+                ref: expected ?? ref,
+            };
+        }
+        const isBareCopyScalar = e.path.length === 1 && baseRef.kind === "scalar" && (baseRef.scalar === "int" || baseRef.scalar === "float" || baseRef.scalar === "bool");
+        const base = isBareCopyScalar ? `*${typedCell(head)}.borrow()` : `${typedCell(head)}.borrow().clone()`;
+        const { expr, ref } = typedFieldAccess(base, baseRef, e.path.slice(1), plan);
+        return { expr, ref };
+    }
+    if (node !== null && typeof node === "object" && !Array.isArray(node)) {
+        const keys = Object.keys(node);
+        if (keys.length === 1 && keys[0] === "obj" && expected && expected.kind === "named") {
+            const decl = findDecl(plan, expected.name);
+            const fields = node.obj;
+            const inits = decl.fields.map((f) => {
+                const sub = emitProducedAwareValue(fields[f.name], f.type, typedNodes, plan, skippable, skippableKind);
+                return `${rustFieldName(f.name)}: ${sub.expr}`;
+            });
+            return { expr: `${expected.name} { ${inits.join(", ")} }`, ref: expected };
+        }
+    }
+    return emitTypedValue(node, expected, typedNodes, plan);
+}
+function valueLeafProduced(expr, ref, expected) {
+    if (expected && expected.kind === "opt") {
+        if (ref.kind === "opt")
+            return expr;
+        return `Some(${expr})`;
+    }
+    return expr;
+}
+// bc#90 / runtime-free: the old `valueLeafInner` (which serialized a bindField to a boxed `Value` for the
+// binding check) is REMOVED — the bound value is now a typed `Option<K>` built by direct field access
+// (Some(field.clone()) / the opt field's Option), and the produced gate is `Option::is_some()`.
+// ── struct dispatch surface (STRUCT-only — no Value bind, no serializer) ─────────────────
+function emitStructSurface(native) {
+    const names = native.map((c) => rustStrLit(c.name));
+    return `// COMPONENT_NAMES_NATIVE_RAW — covered reads exposed on the combined struct-native path. Each is
+// driven via run_native_raw_struct_<comp>(handlers, in_) -> Result<T, BehaviorError>: a STRUCT return
+// (the consumer builds the CONCRETE InNR_<comp> input + implements the CONCRETE HandlerNR<comp> trait).
+// See INTEGRATION.md §6.
+pub const COMPONENT_NAMES_NATIVE_RAW: [&str; ${names.length}] = [${names.join(", ")}];`;
+}
+// ── unknown_component helper (self-contained; the module carries no straight-line body) ──
+const UNKNOWN_COMPONENT_HELPER = `#[allow(dead_code)]
+fn unknown_component(component: &str) -> BehaviorError {
+    BehaviorError::new("UNKNOWN_COMPONENT", format!("component '{component}' has no handler (fail-closed)"))
+}`;
+// ── module assembly ──────────────────────────────────────────────────────────────────
+function emit(ctx) {
+    // bc#97: uniform I/O model for THIS generation — async terminal handlers ⇒ async fn + .await.
+    const isAsync = ctx.ioModel === "async";
+    for (const c of ctx.ir.components)
+        assertTypedCoverage(c);
+    const native = ctx.ir.components.filter(isNativeRaw);
+    const nonNative = ctx.ir.components.filter((c) => !isNativeRaw(c));
+    // FAIL CLOSED (bc#86/#89): the --typed-native (native codegen) surface is native-only. Previously a
+    // non-covered component was SILENTLY DROPPED (emitted only as a comment note), concealing that it
+    // never got native codegen. We now throw a LOUD GeneratorFailure naming every uncovered component +
+    // its specific reject reason. A fully-covered module is unchanged.
+    if (nonNative.length > 0) {
+        const rejects = nonNative
+            .map((c) => `  - component '${c.name}': ${coverageRejectReason(c) ?? "not a covered native read"}`)
+            .join("\n");
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust typed-native (native codegen) surface: ${nonNative.length} component(s) are NOT a covered native read:\n${rejects}\n\n` +
+            `The --typed-native (native codegen) surface is native-only and fail-closed: it does not silently ` +
+            `box uncovered shapes. Implement native coverage for this shape, fix the spec if the shape is ` +
+            `genuinely runtime-dynamic, or generate this component on the --ir dynamic interpreter surface.`);
+    }
+    if (native.length === 0) {
+        // an empty native surface (no covered read) carries no runner and no failure — nothing references
+        // bc-runtime, so it stays runtime-free (bc#90) with only the component-names const.
+        return `#![allow(dead_code, unused_imports)]
+${emitStructSurface([])}
+`;
+    }
+    const plan = buildTypePlan(ctx.ir);
+    // The typed-native module is a de-boxed CONSUMER artifact: the covered runner RETURNS these outType
+    // structs and the consumer reads their fields natively. So the decls (and their FIELDS) are pub — the
+    // consumer keeps the model native (mirrors Go's exported outType struct fields on the covered path).
+    const decls = emitTypeDecls(plan)
+        .replace(/\nstruct /g, "\npub struct ")
+        .replace(/^struct /gm, "pub struct ")
+        .replace(/^( {4})([a-z_][A-Za-z0-9_]*: )/gm, "$1pub $2")
+        .replace(/^( {4})(r#[a-z_][A-Za-z0-9_]*: )/gm, "$1pub $2");
+    const defaults = emitDefaults(plan);
+    const structs = [];
+    const rowStructs = [];
+    const handlerTraits = [];
+    const inStructs = [];
+    const elemMaterializers = [];
+    for (const c of native) {
+        const typedNodes = new Map();
+        for (const n of c.body) {
+            if ("map" in n)
+                structs.push(emitMapPortsStructs(c, n));
+            else
+                structs.push(emitPortsStruct(c, n));
+            typedNodes.set(n.id, deriveTypeRef(n.outType, plan));
+        }
+        rowStructs.push(emitRawRowStructs(c, typedNodes, plan));
+        handlerTraits.push(emitHandlerTrait(c, typedNodes, plan, isAsync));
+        inStructs.push(emitInStruct(c));
+        const mm = emitMapElemMaterializers(c, typedNodes, plan);
+        if (mm)
+            elemMaterializers.push(mm);
+    }
+    const runners = native.map((c) => emitNativeRawRunner(c, plan, isAsync)).join("\n\n");
+    const structSurface = emitStructSurface(native);
+    // (nonNative.length === 0 is guaranteed here — the fail-closed guard above threw otherwise.)
+    const banner = `#![allow(dead_code, unused_imports, non_snake_case)]
+// GENERATED by behavior-contracts (bc#90, rust-typed-native — the RUNTIME-FREE read de-box; STRUCT-ONLY,
+// FULLY-NATIVE). A covered read is a strictly-sequential typed componentRef chain (point reads +
+// relationKind:single children), emitted ONLY as a STRUCT-returning runner GENERIC over a per-component
+// CONCRETE handler trait (HandlerNR<comp>): native ports struct IN (direct construction — every port is a
+// CONCRETE Rust value: String / bool / Vec<&str> projection / i64 limit — NO boxed Value, NO by-name
+// accessor); the handler takes a typed produced-aware 'bound' Option and returns the node's CONCRETE row
+// struct (typed fields = the projected outType), and the runner reads row.<field> DIRECTLY into the node's
+// outType struct. The covered plane carries NO bc-runtime reference at all — failures use the LOCAL
+// BehaviorError (same codes, byte-equal to run_behavior). INLINE sequential (no plan driver) so a relation
+// child reads the parent's REAL struct result via direct field access and the child-present decision is
+// made from the real parent value — relationSingle / connection converge with run_behavior (fixes
+// #323/#74). The exposed API is run_native_raw_struct_<comp>(handlers, in_) over the CONCRETE InNR_<comp>
+// input struct + the CONCRETE HandlerNR<comp> trait (the consumer builds/implements both, keeping the
+// model native). This module is FULLY NATIVE: a naive grep for boxing primitives OR for the bc-runtime
+// crate finds nothing, by design (bc#90 / runtime-free).
+use std::cell::RefCell;`;
+    const sections = [
+        banner,
+        `// Local concrete failure type (runtime-free) — a covered runner returns Result<T, BehaviorError> over\n// THIS local type instead of a bc-runtime failure, so the fully-covered module imports ZERO bc runtime.\n${emitBehaviorErrorType()}`,
+        decls || undefined,
+        defaults || undefined,
+        UNKNOWN_COMPONENT_HELPER,
+        `// Native ports structs (one per componentRef node; typed per the static port type — CONCRETE).\n${structs.join("\n\n")}`,
+        `// CONCRETE per-node row structs (typed fields = the node's outType; + error signal).\n${rowStructs.join("\n\n")}`,
+        `// CONCRETE per-component input structs (fields = inputPorts).\n${inStructs.join("\n\n")}`,
+        `// CONCRETE per-component handler traits (one node_* method per node — native ports IN, row OUT).\n${handlerTraits.join("\n\n")}`,
+        elemMaterializers.length
+            ? `// map augmented-element copiers (pure struct field assignment — no dynamic value read).\n${elemMaterializers.join("\n\n")}`
+            : undefined,
+        `// Combined read runners (STRUCT-returning — the fully de-plumbed CONCRETE path).\n${runners}`,
+        structSurface,
+    ];
+    return `${sections.filter((x) => !!x).join("\n\n")}\n`;
+}
+/**
+ * rustTypedNativeObserve — the TEST-ONLY observe companion (a submodule string the test harness writes
+ * alongside the covered module). It carries the typed->Value serializers (ser_*) + a CONCRETE scripted
+ * handler (ScriptedNativeRaw) that implements every HandlerNR<comp> trait by decoding a scripted Value
+ * into the concrete per-node row, + an observe_native_raw dispatch that decodes the generic input into the
+ * concrete InNR_<comp>, drives the module-private struct runner, and serializes its result to a canonical
+ * Value for the equivalence pin. Lives OUTSIDE the covered module so the module stays literal whole-file
+ * zero (the ser_* / decode helpers are test glue, never on the consumer's read hot path).
+ */
+export function rustTypedNativeObserve(ir) {
+    const components = ir.components;
+    const native = components.filter(isNativeRaw);
+    const plan = buildTypePlan(ir);
+    const needSync = native.some((c) => concurrencyPlan(c) !== null);
+    const serializers = emitSerializers(plan);
+    const marshallers = emitMarshallers(plan);
+    // ── per-component input decoders: generic &[(String,Value)] -> concrete InNR_<comp> (test glue). ──
+    const inDecoders = native.map((c) => emitInDecoder(c, plan)).join("\n\n");
+    // ── concrete scripted handler: implements every HandlerNR<comp> trait by decoding a scripted Value
+    // into the concrete per-node row (the generic scripted-source queue meets the concrete seam). ──
+    const decodeFns = [];
+    const emittedDecode = new Set();
+    const traitImpls = [];
+    for (const c of native) {
+        const typedNodes = new Map();
+        for (const n of c.body)
+            typedNodes.set(n.id, deriveTypeRef(n.outType, plan));
+        const methods = [];
+        for (const n of c.body) {
+            const ref = typedNodes.get(n.id);
+            // bc#90 / runtime-free: the scripted impl's `_bound` param mirrors the trait's typed produced-aware
+            // Option<K> (NOT a boxed Value) — computed per node so the impl signature matches the trait.
+            const bt = boundRustType(n, typedNodes, plan);
+            if ("map" in n) {
+                const m = n.map;
+                const batched = m.batched === true;
+                const arrRef = ref;
+                const elemRowRef = mapElemRowRef(n, arrRef, plan);
+                const elemT = rawElemStructName(c.name, n.id);
+                const batchT = rawRowStructName(c.name, n.id);
+                const elemDecode = emitDecodeRow(c.name, n.id, elemT, elemRowRef, plan, emittedDecode, decodeFns, "Elem");
+                const portsT = batched ? `${portsStructName(c.name, n.id)}Batch` : portsStructName(c.name, n.id);
+                const retT = batched ? batchT : elemT;
+                if (batched) {
+                    methods.push(`    fn ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Option<${batchT}> {
+        let (is_err, err, ok) = self.next(${rustStrLit(m.component)})?;
+        if is_err {
+            return Some(${batchT} { is_error: true, err, ..Default::default() });
+        }
+        let arr = match ok { Some(Value::Arr(a)) => a, _ => Vec::new() };
+        let rows = arr.iter().map(${elemDecode}).collect();
+        Some(${batchT} { rows, ..Default::default() })
+    }`);
+                }
+                else {
+                    methods.push(`    fn ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Option<${elemT}> {
+        let (is_err, err, ok) = self.next(${rustStrLit(m.component)})?;
+        if is_err {
+            return Some(${elemT} { is_error: true, err, ..Default::default() });
+        }
+        let v = ok.unwrap_or(Value::Null);
+        Some(${elemDecode}(&v))
+    }`);
+                }
+                void retT;
+                continue;
+            }
+            const node = n;
+            const rowT = rawRowStructName(c.name, node.id);
+            const decode = emitDecodeRow(c.name, node.id, rowT, ref, plan, emittedDecode, decodeFns, "");
+            methods.push(`    fn ${nodeMethodName(node.id)}(&self, _ports: &${portsStructName(c.name, node.id)}, _bound: ${bt}) -> Option<${rowT}> {
+        let (is_err, err, ok) = self.next(${rustStrLit(node.component)})?;
+        if is_err {
+            return Some(${rowT} { is_error: true, err, ..Default::default() });
+        }
+        let v = ok.unwrap_or(Value::Null);
+        Some(${decode}(&v))
+    }`);
+        }
+        traitImpls.push(`impl ${handlerTraitName(c.name)} for ScriptedNativeRaw {\n${methods.join("\n")}\n}`);
+    }
+    const arms = native
+        .map((c) => {
+        const outRef = c.outputType !== undefined ? deriveTypeRef(c.outputType, plan) : undefined;
+        const ser = outRef ? serializeTyped("tv", outRef, plan) : "tv";
+        // bc#90 / runtime-free: the covered runner returns the module-LOCAL `BehaviorError` (via super::*);
+        // bridge it to the bc-runtime `behavior_contracts::BehaviorError` at the observe boundary (same
+        // code/message) so the conformance harness (main.rs) reads the stable code without the covered
+        // module ever touching bc runtime. decode_* is test glue and returns the local error too.
+        return `        ${rustStrLit(c.name)} => {\n            let in_ = decode_${inStructName(c.name)}(input).map_err(to_rt_err)?;\n            let tv = super::run_native_raw_struct_${sanitize(c.name)}(handlers, in_).map_err(to_rt_err)?;\n            Ok(${ser})\n        }`;
+    })
+        .join("\n");
+    // the scripted handler is passed as `&ScriptedNativeRaw`; the observe entry takes `&ScriptedNativeRaw`
+    // directly (the harness constructs it). Sync is inherent (the queues live behind a Mutex, seen behind
+    // an atomic) so a concurrency stage runs it in parallel.
+    const adapter = `// ScriptedNativeRaw — the CONCRETE test handler: it satisfies every HandlerNR<comp> trait by draining a
+// per-COMPONENT scripted-outcome queue and decoding the scripted ok Value into the concrete row struct.
+// The decode (decode_row_*) is generated (it knows the concrete row type), so the runner stays fully
+// concrete. Sync (queues behind a Mutex, the probe counter an atomic) so a bc#87 stage parallelizes it.
+pub struct ScriptedNativeRaw {
+    queues: std::sync::Mutex<std::collections::HashMap<String, (Vec<serde_json::Value>, bool)>>,
+    #[allow(dead_code)]
+    seen: std::sync::atomic::AtomicUsize,
+}
+
+impl ScriptedNativeRaw {
+    // build from the JSON handlers spec: { "<component>": {ok|error} | [ {ok|error}, … ] }.
+    pub fn new(spec: &serde_json::Map<String, serde_json::Value>) -> Self {
+        let mut queues = std::collections::HashMap::new();
+        for (name, raw) in spec {
+            let (items, single) = match raw {
+                serde_json::Value::Array(a) => (a.clone(), false),
+                other => (vec![other.clone()], true),
+            };
+            queues.insert(name.clone(), (items, single));
+        }
+        ScriptedNativeRaw {
+            queues: std::sync::Mutex::new(queues),
+            seen: std::sync::atomic::AtomicUsize::new(0),
+        }
+    }
+
+    // drain one scripted outcome for a component (last entry repeats — mirrors the reference scripted
+    // handlers); None when the component has no scripted queue (fail-closed). Returns (is_error, err,
+    // ok_value). The bc#87 parallel-stage runner calls node_* from multiple threads, so the drain is
+    // Mutex-guarded.
+    fn next(&self, component: &str) -> Option<(bool, String, Option<Value>)> {
+        self.seen.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+        let mut queues = self.queues.lock().unwrap();
+        let (queue, single) = queues.get_mut(component)?;
+        let raw = if *single || queue.len() <= 1 { queue[0].clone() } else { queue.remove(0) };
+        if let Some(okv) = raw.get("ok") {
+            let v = behavior_contracts::decode_value(okv).expect("decode ok");
+            Some((false, String::new(), Some(v)))
+        } else {
+            let e = raw.get("error").and_then(|e| e.as_str()).unwrap_or("").to_string();
+            Some((true, e, None))
+        }
+    }
+}`;
+    const observeBound = needSync ? "" : "";
+    void observeBound;
+    return `// GENERATED test-only observe companion (bc#77/#94) — NOT part of the covered module. Serializes the
+// struct-native runner's result to a canonical Value for the equivalence pin, and carries the CONCRETE
+// scripted test handler (ScriptedNativeRaw) that satisfies every HandlerNR<comp> trait by decoding a
+// scripted Value into the concrete per-node row. The consumer never uses this (it keeps the model native
+// + implements HandlerNR<comp> over its own wire payload); it exists only so the test harness can
+// byte-compare the STRUCT-only covered read against run_behavior. A submodule of the covered module
+// (reads its pub run_native_raw_struct_* + the CONCRETE structs/traits — incl. the LOCAL BehaviorError —
+// via super::*). bc#90 / runtime-free: the covered module's BehaviorError is LOCAL, so this test-glue
+// companion refers to it via super::* (as \`BehaviorError\`) and refers to the bc-runtime failure type
+// FULLY-QUALIFIED (\`behavior_contracts::BehaviorError\`) only where it bridges at the observe boundary.
+#![allow(dead_code, unused_imports)]
+use behavior_contracts::Value;
+use super::*;
+
+// bridge the covered module's LOCAL BehaviorError (super::BehaviorError) to the bc-runtime failure type
+// the conformance harness reads (same code + message) — the ONLY place the two meet (test glue).
+fn to_rt_err(e: BehaviorError) -> behavior_contracts::BehaviorError {
+    behavior_contracts::BehaviorError::new(e.code, e.message)
+}
+
+${serializers}
+
+// Value -> typed struct marshallers for the concrete-row decode (TEST glue only).
+${marshallers}
+
+${emitMarshalHelpers()}
+
+// per-node concrete-row decoders (scripted Value -> RawRowNR_/RawElemNR_ struct).
+${decodeFns.join("\n\n")}
+
+// input decoders (generic &[(String,Value)] -> concrete InNR_<comp>; TEST glue, one decode at the boundary).
+${inDecoders}
+
+${adapter}
+
+// scripted handler trait impls (one per covered component — the concrete node_* seam, test glue).
+${traitImpls.join("\n\n")}
+
+// observe_native_raw drives the CONCRETE struct-native runner and serializes to a canonical Value (test
+// only). Takes the CONCRETE &ScriptedNativeRaw handler so each enclosed run_native_raw_struct_* call is
+// instantiated at the concrete handler type (direct per-node method calls), not at a trait object.
+pub fn observe_native_raw(
+    name: &str,
+    handlers: &ScriptedNativeRaw,
+    input: &[(String, Value)],
+) -> Result<Value, behavior_contracts::BehaviorError> {
+    match name {
+${arms}
+        other => Err(behavior_contracts::BehaviorError::new("UNKNOWN_ENTRY", format!("component '{other}' is not a covered read (fail-closed)"))),
+    }
+}
+`;
+}
+/** emitInDecoder — a TEST-glue decoder `decode_InNR_<comp>(input) -> Result<InNR_<comp>, BehaviorError>`.
+ * Reads each declared input port from the generic &[(String,Value)] into the concrete field (scalar →
+ * typed read; Value-typed → the raw Value clone). A missing key leaves Default (every covered input is
+ * required + supplied by the corpus). Lives ONLY in the observe companion. */
+function emitInDecoder(comp, plan) {
+    void plan;
+    const name = inStructName(comp.name);
+    const ports = Object.keys(comp.inputPorts ?? {});
+    const lines = [];
+    lines.push(`fn decode_${name}(input: &[(String, Value)]) -> Result<${name}, BehaviorError> {`);
+    lines.push(`    let mut in_ = ${name}::default();`);
+    if (ports.length === 0 || comp.inputPorts === undefined) {
+        lines.push(`    let _ = input;`);
+        lines.push(`    Ok(in_)`);
+        lines.push(`}`);
+        return lines.join("\n");
+    }
+    // an if/else-if chain (clippy-clean regardless of port count — a single-arm `match` trips single_match).
+    lines.push(`    for (k, v) in input {`);
+    ports.forEach((p, i) => {
+        const field = rustFieldName(p);
+        const scalar = inputScalarKind(comp.inputPorts[p]);
+        const head = i === 0 ? "        if" : "        } else if";
+        lines.push(`${head} k == ${rustStrLit(p)} {`);
+        if (scalar === undefined) {
+            lines.push(`            in_.${field} = v.clone();`);
+        }
+        else {
+            const pat = scalar === "String" ? "Value::Str(sv)" : scalar === "i64" ? "Value::Int(sv)" : scalar === "f64" ? "Value::Float(sv)" : "Value::Bool(sv)";
+            const label = scalar === "String" ? "string" : scalar === "i64" ? "int" : scalar === "f64" ? "float" : "bool";
+            const bind = scalar === "String" ? "sv.clone()" : "*sv";
+            // bc#90 / runtime-free: build the module-LOCAL BehaviorError (TYPE_MISMATCH) via the local
+            // marshal_type_error helper — decode_* returns the local error, bridged at the observe boundary.
+            lines.push(`            match v { ${pat} => in_.${field} = ${bind}, other => return Err(marshal_type_error(${rustStrLit(`decode input ${p}: expected ${label}, got `)}, other.type_name())) }`);
+        }
+    });
+    lines.push(`        }`);
+    lines.push(`    }`);
+    lines.push(`    Ok(in_)`);
+    lines.push(`}`);
+    return lines.join("\n");
+}
+/** emitDecodeRow — emit (once, deduped) a decoder `decode_row_<comp>_<node><suffix>(v: &Value) -> <rowT>`
+ * that materializes the scripted ok Value into the concrete row struct. Named: reuse the Value->struct
+ * marshaller + move fields; scalar/arr/opt: materialize into .val. TEST glue only. */
+function emitDecodeRow(compName, nodeId, rowT, ref, plan, emitted, out, suffix) {
+    const fn = `decode_row_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}${suffix.toLowerCase()}`;
+    if (emitted.has(fn))
+        return fn;
+    emitted.add(fn);
+    const lines = [];
+    lines.push(`fn ${fn}(v: &Value) -> ${rowT} {`);
+    if (ref.kind === "named") {
+        const decl = findDecl(plan, ref.name);
+        lines.push(`    let t = marshal_${ref.name}(v).expect("scripted row decode");`);
+        const inits = decl.fields.map((f) => `${rustFieldName(f.name)}: t.${rustFieldName(f.name)}`).join(", ");
+        lines.push(`    ${rowT} { ${inits}, ..Default::default() }`);
+    }
+    else {
+        const mat = materializeExpr("v", ref, plan);
+        lines.push(`    let val = (|| -> Result<${renderTypeRef(ref)}, BehaviorError> { Ok(${mat}) })().expect("scripted row decode");`);
+        lines.push(`    ${rowT} { val, ..Default::default() }`);
+    }
+    lines.push(`}`);
+    out.push(lines.join("\n"));
+    return fn;
+}
+export const rustTypedNativeEmitter = {
+    language: "rust-typed-native",
+    fileExtension: ".rs",
+    defaultRuntimeImport: "behavior_contracts",
+    filenameHint: "behaviors_typed_native_generated.rs",
+    emit,
+};
+//# sourceMappingURL=emit-typed-native-rust.js.map