behavior-contracts 0.7.3 → 0.8.1

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

@@ -1,4 +1,5 @@
 import { GeneratorFailure } from "./core.js";
+import { isControlGate } from "../behavior.js";
 import { rustStraightlineInternals } from "./emit-shared-rust.js";
 import { rustTypedInternals } from "./emit-shared-rust-typed.js";
 import { buildTypePlan, deriveTypeRef, findDecl } from "./typed.js";
@@ -178,13 +179,17 @@ function staticStringArrElems(node) {
  * 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", asBinding, plan) {
+function portFieldRustType(node, inputPorts, where = "port", asBinding, plan, typedNodes) {
     if (staticStringArrElems(node) !== null)
         return "Vec<&'static str>";
     // #110: a componentRef port bound to a runtime array input port (with a resolvable elemType) → Vec<ElemT>.
     const arrElem = portArrayElemRef(node, inputPorts, plan);
     if (arrElem !== null)
         return `Vec<${renderTypeRef(arrElem)}>`;
+    // #129: a leaf port that is a ref into a PRIOR NODE's typed arr outType (node→leaf array dataflow) → Vec<ElemT>.
+    const priorArr = priorNodeArrElemInfo(node, typedNodes, plan);
+    if (priorArr !== null)
+        return `Vec<${renderTypeRef(priorArr.elemRef)}>`;
     const num = numLiteralRustExpr(node);
     if (num !== null)
         return typeof node === "number" && Number.isInteger(node) ? "i64" : "f64";
@@ -201,13 +206,13 @@ function portFieldRustType(node, inputPorts, where = "port", asBinding, plan) {
  * 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, asBinding, plan) {
+function emitPortsStruct(comp, node, asBinding, plan, typedNodes) {
     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}'`, asBinding, plan));
+    const types = portNames.map((p) => portFieldRustType(node.ports[p], comp.inputPorts, `port '${p}' of node '${node.id}'`, asBinding, plan, typedNodes));
     const fields = portNames
         .map((p, i) => `    pub ${portFieldName(p)}: ${types[i]}, // ${JSON.stringify(p)}`)
         .join("\n");
@@ -681,6 +686,44 @@ function mapOverElemInfo(comp, node, typedNodes, plan) {
 function mapOverElemType(comp, node, typedNodes, plan) {
     return renderTypeRef(mapOverElemInfo(comp, node, typedNodes, plan).elemRef);
 }
+/**
+ * priorNodeArrElemInfo (#129, rust twin) — resolve a leaf port that is a `ref` into a PRIOR BODY NODE
+ * whose annotated `outType` is (or reaches, through a field path) a native array, to its element TypeRef
+ * + the OWNED Rust Vec expression that yields it. GENERALIZES the `map…over` prior-node-arr dataflow
+ * (mapOverElemInfo's first branch) to ANY leaf input port: a fold/dedup leaf whose `items` port is
+ * `{ref:["<priorNode>"]}` (or `.items` of a prior connection node) now lowers to `Vec<ElemT>` cloned
+ * out of the prior node's typed cell — ZERO boxed Value on the read hot path.
+ *
+ * The element type comes STRICTLY from the prior node's EXPLICIT `outType` annotation walked through
+ * typedFieldAccess (BC does NOT infer — consumer-interface C3 / [[graphddb-typed-native-static-link]]):
+ * if the head is not a prior body node, or its outType (through the field path) is not an `arr`, this
+ * returns null and the caller keeps its existing fail-closed behaviour (never a silent box). A
+ * single-segment INPUT-array port (elemType) is a DIFFERENT covered shape (portArrayElemRef) — handled
+ * ahead of this. Requires the typedNodes map (prior-node outType TypeRefs) and a TypePlan.
+ */
+function priorNodeArrElemInfo(node, typedNodes, plan) {
+    if (typedNodes === undefined || plan === undefined)
+        return null;
+    if (staticArrElems(node) !== null)
+        return null; // a static array literal — not a prior-node ref.
+    const e = classifyExpr(node);
+    if (e.kind !== "ref" || e.opt || e.path.length < 1)
+        return null;
+    if (!typedNodes.has(e.path[0]))
+        return null; // head is not a prior body node → not this shape.
+    const baseRef = typedNodes.get(e.path[0]);
+    let acc;
+    try {
+        acc = typedFieldAccess(`${typedCell(e.path[0])}.borrow()`, baseRef, e.path.slice(1), plan);
+    }
+    catch {
+        return null; // the field path does not resolve on the prior node's outType → fail-closed at caller.
+    }
+    if (acc.ref.kind !== "arr")
+        return null; // the prior-node result (through the path) is not an array.
+    // OWNED: clone the borrowed slice out of the RefCell so the ports struct owns its Vec<ElemT>.
+    return { elemRef: acc.ref.elem, overExpr: `${acc.expr}.clone()` };
+}
 // ── eligibility ─────────────────────────────────────────────────────────────────────
 function reconstructR(e) {
     switch (e.kind) {
@@ -884,14 +927,27 @@ function coverageRejectReason(comp) {
     // shape). Kept fail-closed: a non-componentRef member is rejected.
     for (const [i] of ep.parallelStageOf) {
         const n = comp.body[i];
+        // #125: a when(...) control-gate cond IS allowed as a parallel-stage member — it is a pure
+        // Expression (no dispatch), settled in ascending preflight order like the bindField key gate, so its
+        // produced_<gate> flag is决定済み before the stage's gated children dispatch. No handler, no boxed
+        // result — it does not disturb the bounded-concurrency error-precedence protocol.
+        if (isControlGate(n))
+            continue;
         if (!("component" in n))
             return `node '${n.id}' is a non-componentRef member of 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) {
-            // #108: a cond node is native-covered (its if/then/else compile via the runtime-free
-            // NativeExprCompiler; an uncovered expr fails closed at emit). cond requires outType.
+            // #125: a when(...) control-gate cond (`{if, then:{obj:{ok:true}}, else:null}`) は制御スキップ
+            // マーカーで出力データ型を持たない（A3 の typeless design）— outType を要求しない。gate は `if` を
+            // native bool へコンパイルし produced_<gate> に写すだけで、分岐内ノードは既存の
+            // `parent=gate, bindField:"ok"` skip-gate（run_behavior の null-binding skip）が実行選択する。
+            if (isControlGate(n))
+                continue;
+            // #108: a DATA-JOIN cond node (Φ 合流) is native-covered (its if/then/else compile via the runtime-
+            // free NativeExprCompiler; an uncovered expr fails closed at emit). A data-join cond requires outType
+            // （合流値を de-box する対象だから — control gate だけがこの要求を免除される）。
             if (n.outType === undefined)
                 return `node '${n.id}' cond has no outType (required to de-box the branch join)`;
             continue;
@@ -911,7 +967,12 @@ function coverageRejectReason(comp) {
         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")
+        // #125: a when(...) control-gate child (`parent=gate, bindField:"ok"`). Its bindField is the gate's
+        // skip signal, NOT a relation data key — so the relationKind constraint below (which governs a
+        // relation bindField into a single|connection parent) does not apply. Its skip is driven by the
+        // gate's produced_<gate> flag; the child itself can be a plain point read (or a relation read).
+        const childOfGate = cr.parent !== undefined && isControlGate(comp.body.find((b) => b.id === cr.parent));
+        if (!childOfGate && 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}')`;
@@ -926,8 +987,10 @@ function coverageRejectReason(comp) {
 function isFullyTyped(comp) {
     if (comp.outputType === undefined)
         return false;
+    // #125: a control-gate cond is a typeless skip marker (A3) — it never de-boxes a result, so it is
+    // exempt from the "every node carries outType" de-box requirement (matches type-gate's exemption).
     for (const n of comp.body)
-        if (n.outType === undefined)
+        if (!isControlGate(n) && n.outType === undefined)
             return false;
     return true;
 }
@@ -1069,7 +1132,7 @@ function emitNativeScalar(node, want, resolveRef) {
  * 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, inputPorts, plan) {
+function emitPortInit(pn, expr, fieldRustType, resolveRef, inputPorts, plan, typedNodes) {
     const field = portFieldName(pn);
     // #110: a componentRef port bound to a runtime array input port (with elemType) → the native Vec<ElemT>,
     // cloned out of the concrete input struct (`in_.<field>.clone()`) — ZERO boxed Value on the read hot path.
@@ -1079,6 +1142,12 @@ function emitPortInit(pn, expr, fieldRustType, resolveRef, inputPorts, plan) {
             return `${field}: in_.${rustFieldName(e.path[0])}.clone()`;
         }
     }
+    // #129: a leaf port that is a ref into a PRIOR NODE's typed arr outType (node→leaf array dataflow) →
+    // the native Vec<ElemT> cloned off the prior node's typed cell (`t_<node>.borrow().field….clone()`) —
+    // ZERO boxed Value on the read hot path (a fold/dedup leaf whose `items` = a prior node's array result).
+    const priorArr = priorNodeArrElemInfo(expr, typedNodes, plan);
+    if (priorArr !== null)
+        return `${field}: ${priorArr.overExpr}`;
     // change #2: a static string array (projection) → a native `vec![...]` of &'static str.
     const strArr = staticStringArrElems(expr);
     if (strArr !== null) {
@@ -1165,7 +1234,8 @@ function emitNativeRawRunner(comp, plan, ap) {
     }
     const typedNodes = new Map();
     for (const n of comp.body)
-        typedNodes.set(n.id, deriveTypeRef(n.outType, plan));
+        if (!isControlGate(n))
+            typedNodes.set(n.id, deriveTypeRef(n.outType, plan)); // #125: control-gate は typeless（typedNodes に載せない）
     const idToIndex = new Map();
     comp.body.forEach((n, i) => idToIndex.set(n.id, i));
     const opsLiteral = comp.body.map((n) => {
@@ -1258,8 +1328,13 @@ function emitNativeRawRunner(comp, plan, ap) {
     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());`);
+        const nd = comp.body[order[k]];
+        const id = nd.id;
+        // #125: a control-gate cond has no typed data cell — only a produced_<gate> flag (its `if` result),
+        // which its gated children read via the existing `if produced_<parent>.get()` skip-gate.
+        if (!isControlGate(nd)) {
+            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)};`);
     }
@@ -1293,11 +1368,19 @@ function emitNativeRawRunner(comp, plan, ap) {
         lines.push(`    // ── op '${node.id}' (${node.component}${node.relationKind ? ", relationKind:" + node.relationKind : ""}${node.parent ? ", parent:" + node.parent : ""}) ──`);
         let indent = "    ";
         const closers = [];
+        const parentIsGate = node.parent !== undefined && isControlGate(comp.body.find((b) => b.id === node.parent));
         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) {
+            if (node.bindField !== undefined && parentIsGate) {
+                // #125: a when(...) control-gate parent. gate の bindField:"ok" は run_behavior では成立時 `true`
+                // / 不成立時 `null`（→ null-binding skip）。native では produced_<gate>（= gate の `if`）が既に
+                // その skip を担うので、ここに来た時点で gate は成立。bound は skip の sentinel（データキーでは
+                // ない — 子の ports は実データ親を参照する）として、非 None の `Option<String>` を渡す。
+                lines.push(`${indent}let bound_${s}: ${boundRustType(node, typedNodes, plan)} = Some("ok".to_string());`);
+            }
+            else 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`
@@ -1323,8 +1406,8 @@ function emitNativeRawRunner(comp, plan, ap) {
         const inits = [];
         for (const pn of portNames) {
             const expr = node.ports[pn];
-            const ty = portFieldRustType(expr, comp.inputPorts, `port '${pn}' of node '${node.id}'`, undefined, plan);
-            inits.push(emitPortInit(pn, expr, ty, resolveRef, comp.inputPorts, plan));
+            const ty = portFieldRustType(expr, comp.inputPorts, `port '${pn}' of node '${node.id}'`, undefined, plan, typedNodes);
+            inits.push(emitPortInit(pn, expr, ty, resolveRef, comp.inputPorts, plan, typedNodes));
         }
         const boundArg = node.bindField !== undefined ? `bound_${s}` : "None";
         // bc#97: derived per-node await — this point-read's future is awaited HERE (its result-consumption
@@ -1429,8 +1512,8 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
         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}'`, undefined, plan);
-            inits.push(emitPortInit(pn, expr, ty, resolveRef, comp.inputPorts, plan));
+            const ty = portFieldRustType(expr, comp.inputPorts, `port '${pn}' of node '${node.id}'`, undefined, plan, typedNodes);
+            inits.push(emitPortInit(pn, expr, ty, resolveRef, comp.inputPorts, plan, typedNodes));
         }
         if (gated) {
             lines.push(`${ind}ports_${s} = Some(${structName} { ${inits.join(", ")} });`);
@@ -1862,7 +1945,6 @@ function rustInputHeadRef(head, comp, plan) {
 function emitCondArm(comp, node, atPos, typedNodes, plan, priorNodeAt) {
     const c = node.cond;
     const s = sanitize(node.id);
-    const nodeRef = typedNodes.get(node.id);
     const priorHere = (head) => priorNodeAt(head, atPos);
     const resolveHead = (head) => {
         if (priorHere(head))
@@ -1870,8 +1952,29 @@ function emitCondArm(comp, node, atPos, typedNodes, plan, priorNodeAt) {
         return rustInputHeadRef(head, comp, plan);
     };
     const compiler = new NativeExprCompiler(makeRustExprBackend(resolveHead, plan));
-    const resolveDecl = (name) => findDecl(plan, name).fields;
     const cond = compiler.compileBool(c.if);
+    // #125: a when(...) control-gate cond は出力データ型を持たない制御スキップマーカー。typed cell へ何も
+    // materialize せず、`if` を native bool にして produced_<gate> に写すだけ。分岐内ノード
+    // （`parent=gate, bindField:"ok"`）は既存の `if produced_<gate>.get()` skip-gate が実行選択する。
+    if (isControlGate(node)) {
+        const glines = [];
+        glines.push(`    // ── control-gate cond '${node.id}'${c.parent ? " (parent:" + c.parent + ")" : ""} — when(...) skip marker (no data type) ──`);
+        let gindent = "    ";
+        const gclosers = [];
+        if (c.parent !== undefined && priorNodeAt(c.parent, atPos)) {
+            glines.push(`${gindent}if produced_${sanitize(c.parent)}.get() {`);
+            gclosers.unshift(`${gindent}}`);
+            gindent += "    ";
+        }
+        for (const st of cond.stmts)
+            glines.push(`${gindent}${st}`);
+        glines.push(`${gindent}produced_${s}.set(${rustStripOuterParens(cond.expr)});`);
+        for (const cl of gclosers)
+            glines.push(cl);
+        return glines.join("\n");
+    }
+    const nodeRef = typedNodes.get(node.id);
+    const resolveDecl = (name) => findDecl(plan, name).fields;
     const thenC = compiler.compileTo(c.then, nodeRef, resolveDecl);
     const elseC = compiler.compileTo(c.else, nodeRef, resolveDecl);
     const lines = [];
@@ -2031,7 +2134,8 @@ ${emitStructSurface([])}
         const typedNodes = new Map();
         // build the full typed-node map FIRST so a map's over-element resolution can see every node.
         for (const n of c.body)
-            typedNodes.set(n.id, deriveTypeRef(n.outType, plan));
+            if (!isControlGate(n))
+                typedNodes.set(n.id, deriveTypeRef(n.outType, plan)); // #125: control-gate は typeless（typedNodes に載せない）
         for (const n of c.body) {
             if ("fanout" in n)
                 structs.push(emitFanoutPortsStructs(c, n, typedNodes, plan));
@@ -2041,7 +2145,7 @@ ${emitStructSurface([])}
                 // #108: a cond node has NO ports struct (pure Expression — no handler dispatch).
             }
             else
-                structs.push(emitPortsStruct(c, n, undefined, plan));
+                structs.push(emitPortsStruct(c, n, undefined, plan, typedNodes)); // #129: typedNodes for prior-node arr leaf ports.
         }
         rowStructs.push(emitRawRowStructs(c, typedNodes, plan));
         handlerTraits.push(emitHandlerTrait(c, typedNodes, plan, asyncPlans.get(c.name)));
@@ -2129,7 +2233,8 @@ export function rustTypedNativeObserve(ir, ioModel = "sync") {
         const fnKwFor = (nodeId) => (ap.nodeIsAsync(nodeId) ? "async fn" : "fn");
         const typedNodes = new Map();
         for (const n of c.body)
-            typedNodes.set(n.id, deriveTypeRef(n.outType, plan));
+            if (!isControlGate(n))
+                typedNodes.set(n.id, deriveTypeRef(n.outType, plan)); // #125: control-gate は typeless（typedNodes に載せない）
         const methods = [];
         for (const n of c.body) {
             if ("cond" in n)
@@ -2149,7 +2254,7 @@ export function rustTypedNativeObserve(ir, ioModel = "sync") {
                 const elemDecode = emitDecodeRow(c.name, n.id, elemT, elemRowRef, plan, emittedDecode, decodeFns, "Elem");
                 const portsT = `${portsStructName(c.name, n.id)}Batch`;
                 methods.push(`    ${fnKw} ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Option<${batchT}> {
-        let (is_err, err, ok) = self.next(${rustStrLit(f.component)})?;
+        let (is_err, err, ok, _echo) = self.next(${rustStrLit(f.component)})?;
         if is_err {
             return Some(${batchT} { is_error: true, err, ..Default::default() });
         }
@@ -2179,7 +2284,7 @@ export function rustTypedNativeObserve(ir, ioModel = "sync") {
                 const retT = batched ? batchT : elemT;
                 if (batched) {
                     methods.push(`    ${fnKw} ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Option<${batchT}> {
-        let (is_err, err, ok) = self.next(${rustStrLit(m.component)})?;
+        let (is_err, err, ok, _echo) = self.next(${rustStrLit(m.component)})?;
         if is_err {
             return Some(${batchT} { is_error: true, err, ..Default::default() });
         }
@@ -2190,7 +2295,7 @@ export function rustTypedNativeObserve(ir, ioModel = "sync") {
                 }
                 else {
                     methods.push(`    ${fnKw} ${nodeMethodName(n.id)}(&self, _ports: &${portsT}, _bound: ${bt}) -> Option<${elemT}> {
-        let (is_err, err, ok) = self.next(${rustStrLit(m.component)})?;
+        let (is_err, err, ok, _echo) = self.next(${rustStrLit(m.component)})?;
         if is_err {
             return Some(${elemT} { is_error: true, err, ..Default::default() });
         }
@@ -2204,11 +2309,22 @@ export function rustTypedNativeObserve(ir, ioModel = "sync") {
             const node = n;
             const rowT = rawRowStructName(c.name, node.id);
             const decode = emitDecodeRow(c.name, node.id, rowT, ref, plan, emittedDecode, decodeFns, "");
-            methods.push(`    ${fnKw} ${nodeMethodName(node.id)}(&self, _ports: &${portsStructName(c.name, node.id)}, _bound: ${bt}) -> Option<${rowT}> {
-        let (is_err, err, ok) = self.next(${rustStrLit(node.component)})?;
+            // #129 (TEST glue): if this node has an `items` port and its outType is a bare arr, support the
+            // reference scriptedHandlers' `echo === "items"` — the scripted handler ECHOES the NATIVE `f_items`
+            // port back as its result. This makes the node→leaf array dataflow test non-vacuous: the leaf's
+            // observed result is exactly the native array that flowed into its ports struct, so a dropped or
+            // boxed native array would diverge from run_behavior. `ports` is bound only on the echo path.
+            const canEcho = ref.kind === "arr" && Object.prototype.hasOwnProperty.call(node.ports, "items");
+            const portsParam = canEcho ? "ports" : "_ports";
+            const echoBranch = canEcho
+                ? `\n        if echo == "items" {\n            return Some(${rowT} { val: ${portsParam}.${portFieldName("items")}.clone(), ..Default::default() });\n        }`
+                : "";
+            const okBind = canEcho ? "(is_err, err, ok, echo)" : "(is_err, err, ok, _echo)";
+            methods.push(`    ${fnKw} ${nodeMethodName(node.id)}(&self, ${portsParam}: &${portsStructName(c.name, node.id)}, _bound: ${bt}) -> Option<${rowT}> {
+        let ${okBind} = self.next(${rustStrLit(node.component)})?;
         if is_err {
             return Some(${rowT} { is_error: true, err, ..Default::default() });
-        }
+        }${echoBranch}
         let v = ok.unwrap_or(Value::Null);
         Some(${decode}(&v))
     }`);
@@ -2263,19 +2379,22 @@ impl ScriptedNativeRaw {
 
     // 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>)> {
+    // ok_value, echo). The bc#87 parallel-stage runner calls node_* from multiple threads, so the drain
+    // is Mutex-guarded. #129: \`echo\` carries the reference scriptedHandlers' \`echo\` directive (e.g.
+    // "items") so a scripted node can ECHO a named input PORT back — used to make the node→leaf array
+    // dataflow test non-vacuous (the leaf returns its \`items\` port; a dropped/boxed array diverges).
+    fn next(&self, component: &str) -> Option<(bool, String, Option<Value>, String)> {
         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) };
+        let echo = raw.get("echo").and_then(|e| e.as_str()).unwrap_or("").to_string();
         if let Some(okv) = raw.get("ok") {
             let v = behavior_contracts::decode_value(okv).expect("decode ok");
-            Some((false, String::new(), Some(v)))
+            Some((false, String::new(), Some(v), echo))
         } else {
             let e = raw.get("error").and_then(|e| e.as_str()).unwrap_or("").to_string();
-            Some((true, e, None))
+            Some((true, e, None, echo))
         }
     }
 }`;
@@ -2442,6 +2561,7 @@ function emitDecodeRow(compName, nodeId, rowT, ref, plan, emitted, out, suffix)
 }
 export const rustTypedNativeEmitter = {
     language: "rust-typed-native",
+    classification: "codegen", // native: 型付きフラットコード生成・IR/dict 非在（#128/A6）
     fileExtension: ".rs",
     defaultRuntimeImport: "behavior_contracts",
     filenameHint: "behaviors_typed_native_generated.rs",