behavior-contracts 0.8.0 → 0.8.2

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";
@@ -137,12 +138,12 @@ function inferPortType(node, inputPorts, asBinding) {
             if (e.path.length === 1) {
                 const s = inputPorts[e.path[0]];
                 if (s) {
-                    if (s.type === "string")
-                        return "String";
+                    if (s.type === "string" || s.type === "literal")
+                        return "String"; // literal = constrained String.
                     if (s.type === "int")
                         return "i64";
-                    if (s.type === "float")
-                        return "f64";
+                    if (s.type === "float" || s.type === "number")
+                        return "f64"; // `"number"` = the float channel.
                     if (s.type === "bool")
                         return "bool";
                 }
@@ -192,12 +193,84 @@ function portFieldRustType(node, inputPorts, where = "port", asBinding, plan, ty
     const num = numLiteralRustExpr(node);
     if (num !== null)
         return typeof node === "number" && Number.isInteger(node) ? "i64" : "f64";
+    // a ref to a `$as` element field (or an input port) whose type is a MAP or NAMED struct (NOT a bare
+    // scalar) → the native map/struct type. #108-map: a `{map:V}`-typed field (e.g. a nested
+    // `map<map<obj>>` write port) lowers to BTreeMap; a named field lowers to its struct. Reuses the same
+    // typedFieldAccess resolution as the scalar path; a genuinely-untyped ref still falls through.
+    const composite = portCompositeRef(node, inputPorts, asBinding, plan);
+    if (composite !== null)
+        return renderTypeRef(composite);
     const ft = inferPortType(node, inputPorts, asBinding);
     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;
 }
+/** portCompositeRef — the full TypeRef of a port that is a `{ref:[...]}` into a `$as` element field OR
+ * an input port whose type is a MAP or NAMED struct (a non-scalar covered field). Returns null when the
+ * node is not such a ref (so the caller falls through to the scalar/array inference). #108-map: enables a
+ * `{map:V}`-typed field port (e.g. a nested map write port) to lower to the native BTreeMap. */
+function portCompositeRef(node, inputPorts, asBinding, plan) {
+    const e = classifyExpr(node);
+    if (e.kind !== "ref" || plan === undefined)
+        return null;
+    let ref = null;
+    if (asBinding !== undefined && e.path[0] === asBinding.name) {
+        try {
+            ref = typedFieldAccess(asBinding.name, asBinding.ref, e.path.slice(1), asBinding.plan).ref;
+        }
+        catch {
+            return null;
+        }
+    }
+    else if (e.path.length >= 1) {
+        const s = inputPorts[e.path[0]];
+        // a whole-port ref to an input MAP port carrying an elemType → its BTreeMap type (mirrors
+        // inputPortRustType); a deeper path into an input port is not resolved here (no field type source).
+        if (s !== undefined && s.type === "map" && e.path.length === 1) {
+            const et = s.elemType;
+            if (et !== undefined)
+                return { kind: "map", value: deriveTypeRef(et, plan) };
+        }
+        return null;
+    }
+    if (ref === null)
+        return null;
+    // only MAP / NAMED composite fields here — scalars/arrays keep their existing dedicated paths.
+    if (ref.kind === "map" || ref.kind === "named")
+        return ref;
+    return null;
+}
+/** emitCompositePortValue — the OWNED native value expr for a port that is a ref to a `$as` element
+ * MAP/NAMED field (or an input map port): a typed field access `.clone()` (the concrete BTreeMap/struct,
+ * ZERO boxed Value). `elemBaseExpr` is the map arm's element base (`oel_<mapId>`) for a `$as`-headed ref;
+ * omitted at the top level (only input-port composite refs resolve there). Returns null otherwise. */
+function emitCompositePortValue(node, inputPorts, asBinding, plan, elemBaseExpr) {
+    const e = classifyExpr(node);
+    if (e.kind !== "ref")
+        return null;
+    if (asBinding !== undefined && elemBaseExpr !== undefined && e.path[0] === asBinding.name) {
+        let acc;
+        try {
+            acc = typedFieldAccess(elemBaseExpr, asBinding.ref, e.path.slice(1), plan);
+        }
+        catch {
+            return null;
+        }
+        if (acc.ref.kind !== "map" && acc.ref.kind !== "named")
+            return null;
+        return `${acc.expr}.clone()`;
+    }
+    // a WHOLE-port ref to an input MAP port (with elemType) — valid at top level OR inside a map node (a
+    // ref head that is NOT the `$as` element binding). Clones the native BTreeMap off the input struct.
+    if ((asBinding === undefined || e.path[0] !== asBinding.name) && e.path.length === 1) {
+        const s = inputPorts[e.path[0]];
+        if (s !== undefined && s.type === "map" && s.elemType !== undefined) {
+            return `in_.${rustFieldName(e.path[0])}.clone()`;
+        }
+    }
+    return null;
+}
 /**
  * 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
@@ -316,6 +389,12 @@ function makeRustExprBackend(resolveHead, plan) {
         notOp: (a) => `(!${a})`,
         structLit: (name, inits) => `${name} { ${inits.map((i) => `${rustFieldName(i.field)}: ${i.expr}`).join(", ")} }`,
         arrLit: (elemTy, items) => `{ let __v: Vec<${elemTy}> = vec![${items.join(", ")}]; __v }`,
+        // an opt (`Option<T>`) NONE literal. Annotate as `Option::<T>::None` so it type-infers in ANY
+        // position (a bare `None` can be ambiguous; the explicit turbofish keeps it a fully-typed value).
+        optNone: (innerTy) => `Option::<${innerTy}>::None`,
+        // opt (`Option<T>`) null-presence test: present = `expr.is_some()`, absent = `expr.is_none()`.
+        optIsSome: (expr) => `${expr}.is_some()`,
+        optIsNone: (expr) => `${expr}.is_none()`,
         ternary: (cond, t, e, _ty) => `(if ${rustStripOuterParens(cond)} { ${rustStripOuterParens(t)} } else { ${rustStripOuterParens(e)} })`,
         shortCircuitBool: (op, temp, left, rStmts, rExpr) => {
             // and: let temp = if left { <rStmts> rExpr } else { false };  or: if left { true } else { <rStmts> rExpr }.
@@ -592,6 +671,19 @@ function emitHandlerTrait(comp, typedNodes, plan, ap) {
 function mapElemMaterializerName(nodeId) {
     return `materialize_map_elem_${typedCell(nodeId)}`;
 }
+/** mapNodeArrRef — the map node's PRODUCED-ARRAY TypeRef from its `outType`, normalizing the two IR
+ * conventions to the one array shape every downstream site assumes (`typedNodes.get(mapId)` is an arr):
+ *   - the RECORDER SoT (authoring.ts recordMap): `node.outType` is the ELEMENT (pre-array-wrap) — wrap
+ *     it to `{arr:element}` here (the map produces `[]element`), matching type-gate's outputType wrap
+ *     (`"map" in n ? {arr:ot} : ot`). This is the declarative-authoring form (graphddb batchWrite/forEach).
+ *   - legacy hand-built IR: `node.outType` is already the `{arr:element}` produced form — take it as-is.
+ * A map ELEMENT is never itself an `{arr:…}` in the covered corpus, so the `arr`-keyed discriminator is
+ * unambiguous. Both converge to the SAME produced-array ref, so existing goldens stay byte-identical. */
+function mapNodeArrRef(node, plan) {
+    const outT = node.outType;
+    const isArr = outT !== null && typeof outT === "object" && "arr" in outT;
+    return deriveTypeRef((isArr ? outT : { arr: outT }), plan);
+}
 /** 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) {
@@ -828,6 +920,13 @@ function coveredMapNode(n, bodyIds, comp) {
         return false;
     if (m.relationKind !== undefined && m.relationKind !== "single" && m.relationKind !== "connection")
         return false;
+    // A map node must carry an outType (its ELEMENT type per the recorder SoT — authoring.ts recordMap
+    // holds `node.outType = mapElem`, the PRE-array-wrap element; the emitter synthesizes the produced
+    // `[]element`). A map WITHOUT outType is uncovered. (Legacy hand-built IR that already carries the
+    // `{arr:element}` produced form is ALSO accepted — mapNodeElemRef normalizes both to the element.)
+    const outT = n.outType;
+    if (outT === undefined || typeof outT !== "object")
+        return false;
     const overE = classifyExpr(m.over);
     if (overE.kind !== "ref")
         return false;
@@ -926,14 +1025,30 @@ 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/#108: a cond node IS allowed as a parallel-stage member — it is a pure Expression (no
+        // dispatch), settled in ascending preflight order, so its produced flag / typed result cell is
+        // settled before any dispatch. No handler, no boxed result — it does not disturb the bounded-
+        // concurrency error-precedence protocol. Covers BOTH the when(...) control-gate cond (#136,
+        // {ok}/null skip marker) AND the Φ-merge VALUE cond (#108, has outType — the sibling Φ-join). A
+        // value cond's outType requirement is enforced by the per-node cond check below, so a parallel
+        // value cond without outType still loud-rejects there.
+        if ("cond" in 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;
@@ -953,7 +1068,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}')`;
@@ -968,8 +1088,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;
 }
@@ -988,10 +1110,16 @@ function assertTypedCoverage(comp) {
 function inputPortRustType(schema, plan) {
     switch (schema?.type) {
         case "string":
+        // a `"literal"` port is a constrained STRING union (`param.literal('a','b',…)`, stored 'S') — its
+        // native representation is a plain String (the union constraint is a validation concern, not a type).
+        case "literal":
             return "String";
         case "int":
             return "i64";
         case "float":
+        // a `"number"` port is a FLOAT (run_behavior: `typeName(number) === "float"`, expr-eval.ts §value):
+        // a JS number is IEEE754 → f64. (An i64 value is declared `"int"`; `"number"` is the float channel.)
+        case "number":
             return "f64";
         case "bool":
             return "bool";
@@ -1003,6 +1131,13 @@ function inputPortRustType(schema, plan) {
                 return `Vec<${renderTypeRef(deriveTypeRef(et, plan))}>`;
             return "Value";
         }
+        case "map": {
+            // an input MAP port (dynamic string keys, declared value elemType) lowers to a native BTreeMap.
+            const et = schema.elemType;
+            if (et !== undefined && plan !== undefined)
+                return `std::collections::BTreeMap<String, ${renderTypeRef(deriveTypeRef(et, plan))}>`;
+            return "Value";
+        }
         default:
             return "Value";
     }
@@ -1011,10 +1146,12 @@ function inputPortRustType(schema, plan) {
 function inputScalarKind(schema) {
     switch (schema?.type) {
         case "string":
+        case "literal": // a `"literal"` union is a constrained String (see inputPortRustType).
             return "String";
         case "int":
             return "i64";
         case "float":
+        case "number": // a `"number"` port is the FLOAT channel (run_behavior: number → float / f64).
             return "f64";
         case "bool":
             return "bool";
@@ -1111,8 +1248,16 @@ 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, typedNodes) {
+function emitPortInit(pn, expr, fieldRustType, resolveRef, inputPorts, plan, typedNodes, asBinding, elemBaseExpr) {
     const field = portFieldName(pn);
+    // #108-map: a port that is a ref to a `$as` element MAP/NAMED field (or an input map port) → CLONE the
+    // typed composite value directly off the element/input (native BTreeMap / struct — ZERO boxed Value).
+    // Reuses portCompositeRef for the type; the value is the typed field access `.clone()`.
+    if (plan !== undefined) {
+        const compExpr = emitCompositePortValue(expr, inputPorts ?? {}, asBinding, plan, elemBaseExpr);
+        if (compExpr !== null)
+            return `${field}: ${compExpr}`;
+    }
     // #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.
     if (inputPorts !== undefined && portArrayElemRef(expr, inputPorts, plan) !== null) {
@@ -1212,8 +1357,11 @@ function emitNativeRawRunner(comp, plan, ap) {
         throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust typed-native async (bc#97): component '${comp.name}' has a bc#87 real-concurrency stage AND an async terminal handler, but a scoped-std-thread stage cannot host \`.await\`. Async + concurrent-stage (join! over the stage's futures) is a follow-up — declare this component's terminals sync, or split the concurrency stage.`);
     }
     const typedNodes = new Map();
+    // #125: control-gate は typeless（typedNodes に載せない）。map ノードは produced-array ref に正規化
+    // （recorder SoT の element outType を {arr:element} へラップ / legacy {arr} はそのまま）。
     for (const n of comp.body)
-        typedNodes.set(n.id, deriveTypeRef(n.outType, plan));
+        if (!isControlGate(n))
+            typedNodes.set(n.id, "map" in n ? mapNodeArrRef(n, plan) : deriveTypeRef(n.outType, plan));
     const idToIndex = new Map();
     comp.body.forEach((n, i) => idToIndex.set(n.id, i));
     const opsLiteral = comp.body.map((n) => {
@@ -1306,8 +1454,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)};`);
     }
@@ -1341,11 +1494,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`
@@ -1436,17 +1597,41 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
     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.`);
+    // #125/#108: a stage member may be a cond node — a pure Expression (NO handler/dispatch). The scoped-
+    // thread orchestration governs only the componentRef fan-out members; a cond is settled in ascending
+    // preflight order — BEFORE any dispatch — via the SAME emitCondArm the sequential path uses (no forked
+    // lowering). emitCondArm routes internally: a when(...) control-gate cond (#136, isControlGate, no
+    // outType) commits produced_<gate> ({ok}/null skip marker); a Φ-merge VALUE cond (#108, has outType,
+    // then/else are data branches) materializes its typed result cell (the sibling Φ-join — e.g. two
+    // when-gated connection relations each folding to `ref | emptyConn`). Both are mutually independent
+    // (§1), so ascending-at-head is byte-equal to run_behavior. A cond never shares a stage with a node
+    // that depends on it (an intra-stage parent/child dep is rejected by concurrencyPlan).
+    const condMembers = stage.filter((i) => "cond" in comp.body[i]);
+    const refMembers = stage.filter((i) => !("cond" in comp.body[i]));
+    for (const i of condMembers) {
+        lines.push(emitCondArm(comp, comp.body[i], atPos + stage.indexOf(i), typedNodes, plan, priorNodeAt));
+    }
+    // A cond-ONLY stage carries no handler fan-out — the conds above ARE the whole stage. Skip the scoped-
+    // thread orchestration block entirely (an empty one is dead scaffolding clippy rejects: never_loop /
+    // match_single_binding on a zero-job scope).
+    if (refMembers.length === 0)
+        return lines.join("\n");
     lines.push(`    {`);
     // 1) PREFLIGHT (ascending): build each member's CONCRETE ports struct into a stage-scoped Option
     // local. #114: a bindField relation child ALSO reads its produced-aware bound key from the SETTLED
     // parent struct field (typed access — no serialize) into a stage-scoped Option; a None bound =>
     // UNPRODUCED/skip (ports_<s> stays None), exactly run_behavior's preflightOp bindField skip, before
     // any dispatch. The bound is captured (cloned) by the member's scoped-thread worker.
-    for (const i of stage) {
+    for (const i of refMembers) {
         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);
+        // #125: a member gated by a PRIOR-stage control gate (`parent=gate, bindField:"ok"`). Its bindField is
+        // the gate's skip sentinel, NOT a relation data key — the gate is typeless (no struct field to read).
+        // Mirror the sequential arm: past the produced_<gate> gate we are past the skip, so the bound is the
+        // non-None "ok" sentinel (the child's ports read the REAL data parent, not the gate).
+        const parentIsGate = node.parent !== undefined && isControlGate(comp.body.find((b) => b.id === node.parent));
         let ind = "        ";
         const closers = [];
         if (node.bindField !== undefined) {
@@ -1458,7 +1643,10 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
             lines.push(`${ind}if produced_${sanitize(node.parent)}.get() {`);
             closers.unshift(`${ind}}`);
             ind += "    ";
-            if (node.bindField !== undefined) {
+            if (node.bindField !== undefined && parentIsGate) {
+                lines.push(`${ind}bound_${s} = Some("ok".to_string());`);
+            }
+            else if (node.bindField !== undefined) {
                 const parentRef = typedNodes.get(node.parent);
                 const { expr: bfExpr, ref: bfRef } = typedFieldAccess(`${typedCell(node.parent)}.borrow()`, parentRef, [node.bindField], plan);
                 if (bfRef.kind === "opt") {
@@ -1491,16 +1679,18 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
     }
     // 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;
+    // #125: the fan-out (slots / jobs / workers) spans the COMPONENTREF members only — a control gate
+    // dispatches no handler (committed in preflight above), so it is not a scoped-thread job.
+    const nMembers = refMembers.length;
     const boundN = Math.min(concurrency, nMembers);
     const jobsVar = `jobs_${sanitize(comp.name)}`;
-    for (const i of stage) {
+    for (const i of refMembers) {
         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) => {
+    refMembers.forEach((i, slot) => {
         const s = sanitize(comp.body[i].id);
         lines.push(`        if ports_${s}.is_some() { ${jobsVar}.push(${slot}); }`);
     });
@@ -1513,7 +1703,7 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
     lines.push(`                    if j >= ${jobsVar}.len() { break; }`);
     lines.push(`                    let slot = ${jobsVar}[j];`);
     lines.push(`                    match slot {`);
-    stage.forEach((i, slot) => {
+    refMembers.forEach((i, slot) => {
         const node = comp.body[i];
         const s = sanitize(node.id);
         const boundArg = node.bindField !== undefined ? `bound_${s}.clone()` : "None";
@@ -1529,7 +1719,7 @@ function emitParallelStageArm(comp, stage, atPos, concurrency, metas, typedNodes
     lines.push(`            }`);
     lines.push(`        });`);
     // 3) COMMIT (ascending index): interpret + move the concrete row into the outType cell.
-    stage.forEach((i) => {
+    refMembers.forEach((i) => {
         const node = comp.body[i];
         const meta = metas[i];
         const s = sanitize(node.id);
@@ -1641,7 +1831,8 @@ isAsync = false) {
         const asBinding = { name: asName, ref: overElemRef, plan };
         for (const pn of portNames) {
             const ty = portFieldRustType(m.ports[pn], comp.inputPorts, `map port '${pn}' of node '${node.id}'`, asBinding, plan);
-            inits.push(emitPortInit(pn, m.ports[pn], ty, resolveRef, comp.inputPorts, plan));
+            // #108-map: pass the element binding + base expr so a `$as` MAP/NAMED field port clones the typed composite.
+            inits.push(emitPortInit(pn, m.ports[pn], ty, resolveRef, comp.inputPorts, plan, undefined, asBinding, `oel_${s}`));
         }
         out.push(`${il}let ep_${s} = ${structName} { ${inits.join(", ")} };`);
         return out;
@@ -1910,7 +2101,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))
@@ -1918,8 +2108,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 = [];
@@ -2079,7 +2290,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, "map" in n ? mapNodeArrRef(n, plan) : deriveTypeRef(n.outType, plan)); // #125: control-gate typeless; map は produced-array ref に正規化
         for (const n of c.body) {
             if ("fanout" in n)
                 structs.push(emitFanoutPortsStructs(c, n, typedNodes, plan));
@@ -2177,7 +2389,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, "map" in n ? mapNodeArrRef(n, plan) : deriveTypeRef(n.outType, plan)); // #125: control-gate typeless; map は produced-array ref に正規化
         const methods = [];
         for (const n of c.body) {
             if ("cond" in n)
@@ -2459,6 +2672,12 @@ function emitInDecoder(comp, plan) {
             lines.push(`                other => return Err(marshal_type_error(${rustStrLit(`decode input ${p}: expected array, got `)}, other.type_name())),`);
             lines.push(`            }`);
         }
+        else if (schema?.type === "map" && et !== undefined) {
+            // #108-map: decode the boxed Value::Obj into the native BTreeMap<String, V> (test glue — the input
+            // map port carries a declared elemType). materializeExpr covers the map de-box (obj → BTreeMap).
+            const mapRef = { kind: "map", value: deriveTypeRef(et, plan) };
+            lines.push(`            in_.${field} = ${materializeExpr("v", mapRef, plan)};`);
+        }
         else if (scalar === undefined) {
             lines.push(`            in_.${field} = v.clone();`);
         }