behavior-contracts 0.8.1 → 0.8.2

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

@@ -138,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";
                 }
@@ -193,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
@@ -317,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 }.
@@ -593,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) {
@@ -829,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;
@@ -927,11 +1025,14 @@ 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))
+        // #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)`;
@@ -1009,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";
@@ -1024,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";
     }
@@ -1032,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";
@@ -1132,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) {
@@ -1233,9 +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)
         if (!isControlGate(n))
-            typedNodes.set(n.id, deriveTypeRef(n.outType, plan)); // #125: control-gate は typeless（typedNodes に載せない）
+            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) => {
@@ -1471,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) {
@@ -1493,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") {
@@ -1526,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}); }`);
     });
@@ -1548,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";
@@ -1564,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);
@@ -1676,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;
@@ -2135,7 +2291,7 @@ ${emitStructSurface([])}
         // build the full typed-node map FIRST so a map's over-element resolution can see every node.
         for (const n of c.body)
             if (!isControlGate(n))
-                typedNodes.set(n.id, deriveTypeRef(n.outType, plan)); // #125: control-gate は typeless（typedNodes に載せない）
+                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));
@@ -2234,7 +2390,7 @@ export function rustTypedNativeObserve(ir, ioModel = "sync") {
         const typedNodes = new Map();
         for (const n of c.body)
             if (!isControlGate(n))
-                typedNodes.set(n.id, deriveTypeRef(n.outType, plan)); // #125: control-gate は typeless（typedNodes に載せない）
+                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)
@@ -2516,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();`);
         }