behavior-contracts 0.7.3 → 0.8.0

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

@@ -178,13 +178,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 +205,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 +685,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) {
@@ -1069,7 +1111,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 +1121,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) {
@@ -1323,8 +1371,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 +1477,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(", ")} });`);
@@ -2041,7 +2089,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)));
@@ -2149,7 +2197,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 +2227,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 +2238,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 +2252,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 +2322,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 +2504,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",