behavior-contracts 0.2.4 → 0.2.6

package/dist/generator/emit-straightline-rust.js

@@ -1,5 +1,5 @@
-import { emitDocLiteral, emitDocLiteralCompact } from "./literal.js";
-import { emitStraightlineModule, } from "./straightline.js";
+import { emitDocLiteralCompact } from "./literal.js";
+import { emitStraightlineModule, sequentialOrder, analyzeSequentialOps, classifyExpr, isScopeFree, componentNeedsScope, } from "./straightline.js";
 /** primitive namespace（生成コード内）。crate から `primitives` を use する。 */
 const P = "primitives";
 /**
@@ -14,8 +14,26 @@ const SCOPE = "scope()";
  * `mscope()`（Vec<(String, Value)> を返すクロージャ）をローカル定義し、port/guard 式はそれを呼ぶ。
  */
 const MAP_SCOPE = "mscope()";
+/**
+ * 生成中 module の `json!` マクロ使用の構造的トラッカー（emitModule が emit 前に reset し、
+ * emit 後に serde_json import の要否として読む）。`json!` を emit する唯一の経路は jsonLit()
+ * なので、この関数が呼ばれた事実 = 使用。生成テキストの substring 判定（文字列リテラル
+ * 内容の "json!" に誤反応）はしない。
+ */
+let jsonMacroEmitted = false;
+/**
+ * typed emitter（bc#48 rust-typed）が base straight-line モジュールを同梱し、その上に RunPlan-style の
+ * struct-native typed runner を積む場合、runner は `run_plan`/`OpSpec`/`ExecOutcome`/`RelationKind`/
+ * `json!` を参照する。bc#75 で base は逐次 component からそれらを落とすため、typed 層はこの flag で
+ * base に「RunPlan-path の import と serde_json を必ず含めよ」と要求する（typed 経路の後方互換）。
+ */
+let forceRunPlanImports = null;
+export function setRustForceRunPlanImports(req) {
+    forceRunPlanImports = req;
+}
 /** IR リテラルを rust の `json!(...)` 引数（単一行）へ落とす（未評価 Expr 被演算子用）。 */
 function jsonLit(node) {
+    jsonMacroEmitted = true;
     return `json!(${emitDocLiteralCompact(node, "rust")})`;
 }
 /** args 配列（二項/単項 op の被演算子）を `&json!(a), &json!(b)` の形へ。 */
@@ -339,13 +357,466 @@ ${portRows}
             return outcome;
         }`;
 }
+/** dynamic 式に渡す scope 式（scope-free なら空 scope 定数 `&[]`）。 */
+function rSeqScope(node, ctx) {
+    if (isScopeFree(node))
+        return "sl_empty()";
+    if (ctx.mapAs)
+        return ctx.mapAs.mscopeVar;
+    if (!ctx.scopeVar)
+        throw new Error("straight-line rust: scope-reading expr in a scopeless component (analysis bug)");
+    return ctx.scopeVar;
+}
+/** 静的 ref の head を配線解決した rust 式片。単一 local 直読み = 生 Value（infallible）。 */
+function rSeqRefHead(head, ctx) {
+    if (ctx.mapAs && head === ctx.mapAs.as)
+        return { expr: `${ctx.mapAs.elVar}.clone()`, fallible: false };
+    const idx = ctx.idToIndex.get(head);
+    if (idx !== undefined) {
+        const executedBefore = ctx.atOutput || ctx.pos[idx] < ctx.currentPos;
+        if (executedBefore) {
+            const meta = ctx.metas[idx];
+            const local = ctx.local.get(head);
+            if (ctx.atOutput || !(meta.canSkip || meta.alwaysSkip))
+                return { expr: `${local}.clone()`, fallible: false };
+            // 実行済みだが skip され得る: 未生成なら input の同名 key へ fall-through。UNKNOWN_BINDING は
+            // runtime SSoT（ref_native）が出す（意味論の再実装をしない）。
+            ctx.usesInput.value = true;
+            return { expr: `sl_head_or(${ctx.okFlag.get(head)}, &${local}, input, ${rustStrLit(head)})`, fallible: true };
+        }
+    }
+    // 単一 head の scope 束縛は runtime SSoT ref_native（UNKNOWN_BINDING も同一）。
+    ctx.usesInput.value = true;
+    return { expr: `${P}::ref_native(&[${rustStrLit(head)}], input)`, fallible: true };
+}
+/** fallible な式片を「`?` で Value 化」した式へ。 */
+function useVal(p) {
+    return p.fallible ? `(${p.expr})?` : p.expr;
+}
+/** 分類済み StaticExpr を rust 式片へ（逐次経路のネイティブ inline）。 */
+function rSeqStatic(e, ctx) {
+    switch (e.kind) {
+        case "str":
+            return { expr: `Value::Str(${rustStrLit(e.value)}.to_string())`, fallible: false };
+        case "bool":
+            return { expr: `Value::Bool(${e.value ? "true" : "false"})`, fallible: false };
+        case "null":
+            return { expr: `Value::Null`, fallible: false };
+        case "ref": {
+            const head = rSeqRefHead(e.path[0], ctx);
+            if (e.path.length === 1)
+                return head;
+            const fn = e.opt ? "ref_opt_native" : "ref_native";
+            const rest = e.path.slice(1).map(rustStrLit).join(", ");
+            // head を 1-entry scope で SSoT ref_native へ（field walk の意味論を再実装しない）。
+            return {
+                expr: `${P}::${fn}(&["__sl_head", ${rest}], &[("__sl_head".to_string(), ${useVal(head)})])`,
+                fallible: true,
+            };
+        }
+        case "concat": {
+            // concat_native は評価済み Value のスライスを受ける（closure/part 関数値は無い）。
+            const parts = e.parts.map((p) => useVal(rSeqStatic(p, ctx))).join(", ");
+            return { expr: `${P}::concat_native(&[${parts}])`, fallible: true };
+        }
+        case "dynamic":
+            return { expr: emitExpr(e.node, rSeqScope(e.node, ctx)), fallible: true };
+    }
+}
+/** Expression IR → rust 式片（逐次経路）。 */
+function rSeqExpr(node, ctx) {
+    return rSeqStatic(classifyExpr(node), ctx);
+}
+/** node id 群 → 衝突しない決定的ローカル名。 */
+function allocLocals(prefix, ids) {
+    const out = new Map();
+    const taken = new Set();
+    ids.forEach((id, i) => {
+        let name = `${prefix}${sanitize(id)}`;
+        if (taken.has(name))
+            name = `${name}_${i}`;
+        taken.add(name);
+        out.set(id, name);
+    });
+    return out;
+}
+/** 未生成表現の rust 式（single → Null / connection → 空 connection）。 */
+function unproducedRust(relationKind, ctx) {
+    ctx.usesRelationKind.value = true;
+    const kind = relationKind === "connection" ? "Some(RelationKind::Connection)" : "Some(RelationKind::Single)";
+    return `${P}::unproduced_value(${kind})`;
+}
+/** policy 解釈（fail/retry → OP_FAILED、continue → skip）。plan.rs interpret_outcome と code/msg 一致。 */
+function rSeqPolicyThrow(errVar, opId, meta, ind) {
+    const msg = meta.policy === "retry"
+        ? `format!("operation '{}' failed under 'retry' policy (exhausted): {}", ${rustStrLit(opId)}, ${errVar})`
+        : `format!("operation '{}' failed under 'fail' policy: {}", ${rustStrLit(opId)}, ${errVar})`;
+    return [`${ind}return Err(BehaviorError::new("OP_FAILED", ${msg}));`];
+}
+/** op 本体（ports 構築 + handler 呼び + policy 解釈 + 結果格納）を indent 付きで emit。 */
+function emitRSeqExec(op, plan, ctx, lines, ind) {
+    const i = op.index;
+    const meta = ctx.metas[i];
+    const o = plan.opsLiteral[i];
+    const id = o.id;
+    const local = ctx.local.get(id);
+    const canSkip = meta.canSkip || meta.alwaysSkip;
+    const store = (valueExpr, target, sind) => {
+        if (canSkip) {
+            target.push(`${sind}${local} = ${valueExpr};`, `${sind}${ctx.okFlag.get(id)} = true;`);
+        }
+        else {
+            target.push(`${sind}let ${local}: Value = ${valueExpr};`);
+        }
+        if (ctx.scopeVar)
+            target.push(`${sind}${ctx.scopeVar}.push((${rustStrLit(id)}.to_string(), ${local}.clone()));`);
+    };
+    if (op.kind === "cond") {
+        const c = plan.component.body[i].cond;
+        const node = { cond: [c.if, c.then, c.else] };
+        const v = `v_${sanitize(id)}`;
+        lines.push(`${ind}let ${v}: Value = (${emitExpr(node, rSeqScope(node, ctx))}).map_err(BehaviorError::from)?;`);
+        store(v, lines, ind);
+        return;
+    }
+    if (op.kind === "map") {
+        emitRSeqMap(op, plan, ctx, lines, ind, store);
+        return;
+    }
+    // componentRef: ports 構築（名前付き closure で `?` 展開）→ handler 呼び → policy 解釈。
+    const savedPos = ctx.currentPos;
+    const portsFn = `eval_ports_${sanitize(id)}`;
+    const portRows = op.ports.length === 0
+        ? "Ok(Vec::new())"
+        : `Ok(vec![\n${op.ports
+            .map((p) => {
+            const node = plan.component.body[i].ports[p.name];
+            return `${ind}    (${rustStrLit(p.name)}.to_string(), ${useVal(rSeqExpr(node, ctx))}),`;
+        })
+            .join("\n")}\n${ind}])`;
+    ctx.currentPos = savedPos;
+    ctx.usesHandlers.value = true;
+    lines.push(`${ind}let ${portsFn} = || -> Result<Vec<(String, Value)>, behavior_contracts::ExprFailure> { ${portRows} };`);
+    lines.push(`${ind}let ports_${sanitize(id)} = ${portsFn}().map_err(BehaviorError::from)?;`);
+    const oc = `outcome_${sanitize(id)}`;
+    lines.push(`${ind}let ${oc} = match handlers.exec_ctx(${rustStrLit(id)}, ${rustStrLit(op.component)}, &ports_${sanitize(id)}, None) {`, `${ind}    Some(o) => o,`, `${ind}    None => return Err(unknown_component(${rustStrLit(op.component)})),`, `${ind}};`);
+    if (meta.policy === "continue") {
+        lines.push(`${ind}if let ExecOutcome::Ok(v) = ${oc} {`);
+        store("v", lines, `${ind}    `);
+        lines.push(`${ind}}`);
+    }
+    else {
+        lines.push(`${ind}let ${local}_val = match ${oc} {`);
+        lines.push(`${ind}    ExecOutcome::Ok(v) => v,`);
+        lines.push(`${ind}    ExecOutcome::Error(e) => {`);
+        lines.push(...rSeqPolicyThrow("e", id, meta, `${ind}        `));
+        lines.push(`${ind}    }`);
+        lines.push(`${ind}};`);
+        store(`${local}_val`, lines, ind);
+    }
+}
+/** emitRSeqMap — map ノードの逐次直線展開（rust）。 */
+function emitRSeqMap(op, plan, ctx, lines, ind, store) {
+    const i = op.index;
+    const meta = ctx.metas[i];
+    const m = plan.component.body[i].map;
+    const id = op.id;
+    const s = sanitize(id);
+    const comp = rustStrLit(op.component);
+    const nodeId = rustStrLit(op.id);
+    const asKey = rustStrLit(m.as);
+    ctx.usesHandlers.value = true; // map は要素/バッチ handler を必ず呼ぶ。
+    const guardIR = m.when === undefined ? undefined : { cond: [m.when, true, false] };
+    const mapNeedsScope = (guardIR !== undefined && !isScopeFree(guardIR)) ||
+        Object.keys(m.ports).some((k) => {
+            const cls = classifyExpr(m.ports[k]);
+            const needs = (e) => e.kind === "dynamic" ? !isScopeFree(e.node) : e.kind === "concat" ? e.parts.some(needs) : false;
+            return needs(cls);
+        });
+    const elVar = `el_${s}`;
+    const mscopeVar = `mscope_${s}`;
+    const overVar = `over_${s}`;
+    const keptVar = `kept_${s}`;
+    const collected = `collected_${s}`;
+    const contFlag = meta.policy === "continue";
+    const skipVar = `skip_${s}`;
+    const baseScopeExpr = ctx.scopeVar;
+    const mapCtx = { ...ctx, mapAs: { as: m.as, elVar, mscopeVar } };
+    const overPiece = rSeqExpr(m.over, ctx);
+    const overVal = overPiece.fallible ? `(${overPiece.expr}).map_err(BehaviorError::from)?` : overPiece.expr;
+    lines.push(`${ind}let ${overVar}: Vec<Value> = match ${overVal} {`);
+    lines.push(`${ind}    Value::Arr(a) => a,`);
+    lines.push(`${ind}    _ => return Err(BehaviorError::new("MAP_OVER_NOT_ARRAY", "map '${id}': 'over' did not evaluate to an array".to_string())),`);
+    lines.push(`${ind}};`);
+    lines.push(`${ind}let mut ${keptVar}: Vec<usize> = Vec::new();`);
+    lines.push(`${ind}let mut ${collected}: Vec<Value> = Vec::new();`);
+    if (contFlag)
+        lines.push(`${ind}let mut ${skipVar} = false;`);
+    const mscopeLine = (ind2) => {
+        if (!mapNeedsScope)
+            return [];
+        if (!baseScopeExpr)
+            ctx.usesInput.value = true;
+        const base = baseScopeExpr ? `${baseScopeExpr}.clone()` : "input.to_vec()";
+        return [
+            `${ind2}let mut ${mscopeVar}: Vec<(String, Value)> = ${base};`,
+            `${ind2}${mscopeVar}.push((${asKey}.to_string(), ${elVar}.clone()));`,
+        ];
+    };
+    const guardLine = (ind2) => {
+        if (guardIR === undefined)
+            return [];
+        const g = `g_${s}`;
+        return [
+            `${ind2}let ${g} = (${emitExpr(guardIR, isScopeFree(guardIR) ? "sl_empty()" : mscopeVar)}).map_err(BehaviorError::from)?;`,
+            `${ind2}if !matches!(${g}, Value::Bool(true)) {`,
+            `${ind2}    continue;`,
+            `${ind2}}`,
+        ];
+    };
+    const portsLine = (ind2, portsVar) => {
+        const rows = op.ports.length === 0
+            ? "Ok(Vec::new())"
+            : `Ok(vec![\n${op.ports
+                .map((p) => `${ind2}    (${rustStrLit(p.name)}.to_string(), ${useVal(rSeqExpr(m.ports[p.name], mapCtx))}),`)
+                .join("\n")}\n${ind2}])`;
+        return [
+            `${ind2}let eval_ports_${s} = || -> Result<Vec<(String, Value)>, behavior_contracts::ExprFailure> { ${rows} };`,
+            `${ind2}let ${portsVar} = eval_ports_${s}().map_err(BehaviorError::from)?;`,
+        ];
+    };
+    if (op.batched) {
+        const items = `items_${s}`;
+        lines.push(`${ind}let mut ${items}: Vec<Value> = Vec::new();`);
+        lines.push(`${ind}for (${elVar}_idx, ${elVar}) in ${overVar}.iter().enumerate() {`);
+        lines.push(...mscopeLine(`${ind}    `), ...guardLine(`${ind}    `), ...portsLine(`${ind}    `, `ports_${s}`));
+        lines.push(`${ind}    ${items}.push(Value::Obj(ports_${s}));`, `${ind}    ${keptVar}.push(${elVar}_idx);`, `${ind}}`);
+        lines.push(`${ind}if !${items}.is_empty() {`);
+        lines.push(`${ind}    let want_${s} = ${items}.len();`);
+        lines.push(`${ind}    let batch_ports_${s} = vec![("items".to_string(), Value::Arr(std::mem::take(&mut ${items})))];`);
+        lines.push(`${ind}    match handlers.exec_ctx(${nodeId}, ${comp}, &batch_ports_${s}, None) {`);
+        lines.push(`${ind}        None => return Err(unknown_component(${comp})),`);
+        if (contFlag) {
+            lines.push(`${ind}        Some(ExecOutcome::Error(_)) => { ${skipVar} = true; }`);
+        }
+        else {
+            lines.push(`${ind}        Some(ExecOutcome::Error(e)) => {`);
+            lines.push(...rSeqPolicyThrow("e", id, meta, `${ind}            `));
+            lines.push(`${ind}        }`);
+        }
+        lines.push(`${ind}        Some(ExecOutcome::Ok(v)) => match v {`);
+        lines.push(`${ind}            Value::Arr(r) if r.len() == want_${s} => { ${collected} = r; }`);
+        lines.push(`${ind}            _ => return Err(BehaviorError::new("MAP_BATCH_RESULT_MISMATCH", format!("map '${id}': batched handler must return a list aligned to items (want {want_${s}})"))),`);
+        lines.push(`${ind}        },`);
+        lines.push(`${ind}    }`);
+        lines.push(`${ind}}`);
+    }
+    else {
+        lines.push(`${ind}for (${elVar}_idx, ${elVar}) in ${overVar}.iter().enumerate() {`);
+        lines.push(...mscopeLine(`${ind}    `), ...guardLine(`${ind}    `), ...portsLine(`${ind}    `, `ports_${s}`));
+        lines.push(`${ind}    match handlers.exec_ctx(${nodeId}, ${comp}, &ports_${s}, Some(${elVar})) {`);
+        lines.push(`${ind}        None => return Err(unknown_component(${comp})),`);
+        if (contFlag) {
+            lines.push(`${ind}        Some(ExecOutcome::Error(_)) => { ${skipVar} = true; break; }`);
+        }
+        else {
+            lines.push(`${ind}        Some(ExecOutcome::Error(e)) => {`);
+            lines.push(...rSeqPolicyThrow("e", id, meta, `${ind}            `));
+            lines.push(`${ind}        }`);
+        }
+        lines.push(`${ind}        Some(ExecOutcome::Ok(v)) => { ${collected}.push(v); ${keptVar}.push(${elVar}_idx); }`);
+        lines.push(`${ind}    }`);
+        lines.push(`${ind}}`);
+    }
+    const finish = [];
+    const fInd = contFlag ? `${ind}    ` : ind;
+    if (m.into === undefined) {
+        store(`Value::Arr(${collected})`, finish, fInd);
+    }
+    else {
+        const aug = `aug_${s}`;
+        finish.push(`${fInd}let mut ${aug}: Vec<Value> = Vec::with_capacity(${overVar}.len());`);
+        finish.push(`${fInd}let mut mk_${s} = 0usize;`);
+        finish.push(`${fInd}for (mj_${s}, oel_${s}) in ${overVar}.iter().enumerate() {`);
+        finish.push(`${fInd}    if mk_${s} < ${keptVar}.len() && ${keptVar}[mk_${s}] == mj_${s} {`);
+        finish.push(`${fInd}        match oel_${s} {`);
+        finish.push(`${fInd}            Value::Obj(pairs) => {`);
+        finish.push(`${fInd}                let mut next: Vec<(String, Value)> = pairs.clone();`);
+        finish.push(`${fInd}                if let Some(slot) = next.iter_mut().find(|(kk, _)| kk == ${rustStrLit(m.into)}) {`);
+        finish.push(`${fInd}                    slot.1 = ${collected}[mk_${s}].clone();`);
+        finish.push(`${fInd}                } else {`);
+        finish.push(`${fInd}                    next.push((${rustStrLit(m.into)}.to_string(), ${collected}[mk_${s}].clone()));`);
+        finish.push(`${fInd}                }`);
+        finish.push(`${fInd}                ${aug}.push(Value::Obj(next));`);
+        finish.push(`${fInd}            }`);
+        finish.push(`${fInd}            _ => return Err(BehaviorError::new("MAP_INTO_ELEMENT_NOT_OBJECT", format!("map '${id}': 'into' requires object elements (element {mj_${s}} is not an object)"))),`);
+        finish.push(`${fInd}        }`);
+        finish.push(`${fInd}        mk_${s} += 1;`);
+        finish.push(`${fInd}    } else {`);
+        finish.push(`${fInd}        ${aug}.push(oel_${s}.clone());`);
+        finish.push(`${fInd}    }`);
+        finish.push(`${fInd}}`);
+        store(`Value::Arr(${aug})`, finish, fInd);
+    }
+    if (contFlag) {
+        lines.push(`${ind}if !${skipVar} {`);
+        lines.push(...finish);
+        lines.push(`${ind}}`);
+    }
+    else {
+        lines.push(...finish);
+    }
+}
 /**
- * emitComponentFn — 1 component の直線関数を綴じる。run_behavior の実行フロー（results 蓄積 +
- * base_scope + run_plan + skipped→unproduced + output 評価）を**生成コードに直線展開**する
- * （汎用 exec/node_kind/eval_ports は無い。各 exec 分岐は index で確定・ハードコード）。
- * run_behavior_inner と同じく err_cell（pending_err）が run_plan の合成 OP_FAILED に優先する。
+ * emitRSeqOp — 逐次直線化された 1 op の文列。policy 検証 → skip 判定（parent 連鎖 / bindField）→
+ * 実行 → policy 解釈 → 結果ローカル格納（＋進行形 scope 書き足し）。
+ */
+function emitRSeqOp(op, plan, ctx, lines) {
+    const i = op.index;
+    const meta = ctx.metas[i];
+    const o = plan.opsLiteral[i];
+    const id = o.id;
+    const local = ctx.local.get(id);
+    lines.push(`    // ── op '${id}' (${op.kind === "cond" ? "cond" : op.kind === "map" ? `map ${op.component}` : op.component}${o.policy ? `, policy ${JSON.stringify(o.policy)}` : ""}) ──`);
+    if (typeof meta.policy === "object") {
+        lines.push(`    return Err(BehaviorError::new("UNKNOWN_POLICY", ${rustStrLit(`unknown policy kind: ${meta.policy.invalid}`)}.to_string()));`);
+        return;
+    }
+    const canSkip = meta.canSkip || meta.alwaysSkip;
+    if (canSkip) {
+        lines.push(`    let mut ${local}: Value = Value::Null;`, `    let mut ${ctx.okFlag.get(id)} = false;`);
+    }
+    if (meta.alwaysSkip) {
+        lines.push(`    // parent '${o.parent}' runs later — unconditional skip.`);
+        return;
+    }
+    const guards = [];
+    if (o.parent !== null) {
+        const pMeta = ctx.metas[o.parent];
+        if (pMeta.canSkip || pMeta.alwaysSkip)
+            guards.push(ctx.okFlag.get(plan.opsLiteral[o.parent].id));
+    }
+    if (o.bindField !== undefined && o.parent !== null) {
+        const pLocal = ctx.local.get(plan.opsLiteral[o.parent].id);
+        const inner = [];
+        const ind = guards.length > 0 ? "        " : "    ";
+        inner.push(`${ind}if let Value::Obj(bf_pairs_${sanitize(id)}) = &${pLocal} {`);
+        inner.push(`${ind}    if let Some((_, bf_val_${sanitize(id)})) = bf_pairs_${sanitize(id)}.iter().find(|(kk, _)| kk == ${rustStrLit(o.bindField)}) {`);
+        inner.push(`${ind}        if !matches!(bf_val_${sanitize(id)}, Value::Null) {`);
+        emitRSeqExec(op, plan, ctx, inner, `${ind}            `);
+        inner.push(`${ind}        }`);
+        inner.push(`${ind}    }`);
+        inner.push(`${ind}}`);
+        if (guards.length > 0) {
+            lines.push(`    if ${guards[0]} {`);
+            lines.push(...inner);
+            lines.push(`    }`);
+        }
+        else {
+            lines.push(...inner);
+        }
+        return;
+    }
+    if (guards.length > 0) {
+        lines.push(`    if ${guards[0]} {`);
+        emitRSeqExec(op, plan, ctx, lines, "        ");
+        lines.push(`    }`);
+        return;
+    }
+    emitRSeqExec(op, plan, ctx, lines, "    ");
+}
+/**
+ * emitSequentialRustFn — 逐次 plan の component を素の文列として綴じる（bc#75 の核）。
+ * run_plan / OpSpec Vec / base_scope closure / exec closure / per-op ID 探索は無い。
+ */
+function emitSequentialRustFn(plan, order) {
+    const metas = analyzeSequentialOps(plan.opsLiteral, order);
+    const pos = new Array(plan.opsLiteral.length);
+    order.forEach((opIdx, k) => (pos[opIdx] = k));
+    const idToIndex = new Map();
+    plan.opsLiteral.forEach((o, i) => idToIndex.set(o.id, i));
+    const needScope = componentNeedsScope(plan);
+    const ids = plan.opsLiteral.map((o) => o.id);
+    const local = allocLocals("r_", ids);
+    const okFlag = allocLocals("ok_", ids);
+    const usesInput = { value: needScope }; // needScope なら scope = input.to_vec() で input を読む。
+    const usesHandlers = { value: false };
+    const usesRelationKind = { value: false };
+    const ctx = {
+        pos,
+        idToIndex,
+        metas,
+        local,
+        okFlag,
+        scopeVar: needScope ? "scope" : null,
+        currentPos: 0,
+        atOutput: false,
+        usesInput,
+        usesHandlers,
+        usesRelationKind,
+    };
+    // 本体を先に組み、input 参照の有無を確定させてからシグネチャを綴じる。
+    const bodyLines = [];
+    const lines = [];
+    if (needScope) {
+        bodyLines.push(`    let mut scope: Vec<(String, Value)> = input.to_vec();`);
+    }
+    let unreachable = false;
+    for (const k of order.keys()) {
+        const opIdx = order[k];
+        ctx.currentPos = k;
+        if (unreachable)
+            break;
+        emitRSeqOp(plan.ops[opIdx], plan, ctx, bodyLines);
+        if (typeof metas[opIdx].policy === "object")
+            unreachable = true;
+    }
+    if (!unreachable) {
+        ctx.atOutput = true;
+        for (const i of order) {
+            const meta = metas[i];
+            if (!(meta.canSkip || meta.alwaysSkip))
+                continue;
+            const id = plan.opsLiteral[i].id;
+            bodyLines.push(`    if !${okFlag.get(id)} {`);
+            bodyLines.push(`        ${local.get(id)} = ${unproducedRust(plan.opsLiteral[i].relationKind, ctx)};`);
+            if (needScope)
+                bodyLines.push(`        scope.push((${rustStrLit(id)}.to_string(), ${local.get(id)}.clone()));`);
+            bodyLines.push(`    }`);
+        }
+        const outPiece = rSeqExpr(plan.component.output, ctx);
+        bodyLines.push(outPiece.fallible ? `    (${outPiece.expr}).map_err(BehaviorError::from)` : `    Ok(${outPiece.expr})`);
+    }
+    else {
+        // 到達不能で終わる（sole/last op が UNKNOWN_POLICY）: 末尾 `return Err(..);` を tail 式へ
+        // 直す（clippy::needless_return 回避）。UNKNOWN_POLICY 行は必ず fn-body 直下の最後の文。
+        const last = bodyLines[bodyLines.length - 1];
+        const m = last.match(/^(\s*)return (.*);$/);
+        if (m)
+            bodyLines[bodyLines.length - 1] = `${m[1]}${m[2]}`;
+    }
+    const inputParam = usesInput.value ? "input" : "_input";
+    const handlerParam = usesHandlers.value ? "handlers" : "_handlers";
+    if (usesRelationKind.value)
+        relationKindNeeded = true;
+    if (usesHandlers.value)
+        execOutcomeNeeded = true;
+    lines.push(`fn run_${sanitize(plan.name)}<H: ComponentExec>(`);
+    lines.push(`    ${handlerParam}: &mut H,`);
+    lines.push(`    ${inputParam}: &[(String, Value)],`);
+    lines.push(`) -> Result<Value, BehaviorError> {`);
+    lines.push(...bodyLines);
+    lines.push(`}`);
+    return lines.join("\n");
+}
+/**
+ * emitPlanDrivenRustFn — 実並行 plan（複数 op の stage）の component を run_plan primitive で綴じる。
+ * run_behavior の実行フロー（results 蓄積 + base_scope + run_plan + skipped→unproduced + output 評価）を
+ * 生成コードに直線展開する。base_scope snapshot は実並行の決定性のためこの経路だけが組む（bc#75）。
  */
 function emitComponentFn(plan) {
+    relationKindNeeded = true; // RunPlan 経路は skipped→unproduced で RelationKind を使う。
+    execOutcomeNeeded = true; // RunPlan 経路の exec は ExecOutcome を返す。
     const arms = plan.ops.map(emitExecArm).join("\n");
     const planExpr = plan.component.plan ? emitPlanLiteral(plan.component.plan) : "None";
     const output = emitExpr(plan.component.output, SCOPE);
@@ -365,6 +836,11 @@ function emitComponentFn(plan) {
     };
 `
         : "";
+    // RunPlan 経路の arms は buildComponentPlan 由来の op.expr（emitModule の reset より前に生成）。
+    // json! 使用は実 emit テキストで確定させる（op.expr は我々の生成した rust 式で、user 由来 string は
+    // json!(...) の内側にあるため `json!(` の出現＝json 使用で安全）。
+    if (arms.includes("json!(") || output.includes("json!("))
+        jsonMacroEmitted = true;
     return `fn run_${sanitize(plan.name)}<H: ComponentExec>(
     ${handlerParam}: &mut H,
     input: &[(String, Value)],
@@ -434,8 +910,25 @@ function emitPlanLiteral(plan) {
     return `Some(&behavior_contracts::ExecutionPlanSpec { groups: vec![${groups}], concurrency: ${concurrency} })`;
 }
 function emitComponent(plan, _ctx) {
+    const order = sequentialOrder(plan.component);
+    if (order !== null) {
+        seqHelpersNeeded = true;
+        return emitSequentialRustFn(plan, order);
+    }
+    planDrivenNeeded = true;
+    baseNoExecArmNeeded = true; // base が RunPlan-path exec を emit する → no_exec_arm helper を使う。
     return emitComponentFn(plan);
 }
+/** 逐次経路の native helper（sl_head_or/sl_empty）が要るか（構造的トラッキング）。 */
+let seqHelpersNeeded = false;
+/** RunPlan 経路の import（run_plan/OpSpec）が要るか（base plan-driven or typed force）。 */
+let planDrivenNeeded = false;
+/** no_exec_arm helper が要るか（base plan-driven exec だけが使う — typed force では立てない）。 */
+let baseNoExecArmNeeded = false;
+/** RelationKind を import すべきか（unproduced_value を使うモジュールのみ）。 */
+let relationKindNeeded = false;
+/** ExecOutcome を import すべきか（handler を呼ぶモジュールのみ — cond-only は不要）。 */
+let execOutcomeNeeded = false;
 /** rustfmt の fits-on-one-line 規則を模倣した COMPONENT_NAMES 配列 emit。 */
 function componentNamesConst(names) {
     const items = names.map(rustStrLit);
@@ -446,12 +939,77 @@ function componentNamesConst(names) {
 }
 function emitModule(plans, ctx) {
     const { fingerprint, specVersions, componentNames, runtimeImport } = ctx;
-    const irLiteral = emitDocLiteral(ctx.ir, "rust", 1);
+    // buildComponentPlan（straightline.ts）は逐次経路が使わない op.expr を先に emit するため
+    // jsonMacroEmitted を過大に立てる。ここ（実 emit 直前）で reset し、実際に emit される
+    // emitComponent 内の emitExpr/jsonLit 呼び出しだけが json! 使用を立てるようにする（bc#75:
+    // 逐次経路の全静的 component は json! を出さない）。
+    jsonMacroEmitted = false;
     const fns = plans.map((p) => emitComponent(p, ctx)).join("\n\n");
+    if (forceRunPlanImports) {
+        // typed 層（rust-typed）の struct-native runner が実際に参照する import だけを force する
+        //（typed body を scan して確定 — 過剰 import は clippy unused で落ちるため granular に）。
+        if (forceRunPlanImports.runPlan) {
+            planDrivenNeeded = true; // run_plan + OpSpec + no_exec_arm
+            execOutcomeNeeded = true; // ExecOutcome
+        }
+        if (forceRunPlanImports.relationKind)
+            relationKindNeeded = true;
+        if (forceRunPlanImports.json)
+            jsonMacroEmitted = true;
+    }
+    const usesJson = jsonMacroEmitted;
     const dispatchArms = plans
         .map((p) => `        ${rustStrLit(p.name)} => run_${sanitize(p.name)}(&mut self.handlers, input),`)
         .join("\n");
-    return `// GENERATED by behavior-contracts common generator (bc#39, straight-line) — DO NOT EDIT.
+    // 依存 import の構造的判定（unused import は clippy/warn になるため使うものだけ列挙）。
+    const runtimeItems = ["primitives", "BehaviorError", "ComponentExec", "SpecVersions", "Value"];
+    if (execOutcomeNeeded)
+        runtimeItems.push("ExecOutcome");
+    if (relationKindNeeded)
+        runtimeItems.push("RelationKind");
+    if (planDrivenNeeded)
+        runtimeItems.push("run_plan", "OpSpec");
+    runtimeItems.sort();
+    const runtimeUse = `use ${runtimeImport}::{\n    ${runtimeItems.join(", ")},\n};`;
+    // 逐次経路 native helper（bc#75）。sl_bind/sl_head_or/sl_empty は「local 直読み + input
+    // fall-through + UNKNOWN_BINDING」を再現する（scope snapshot 無し）。concat/ref の field walk は
+    // runtime SSoT（concat_native / ref_native）をそのまま呼ぶ（意味論の再実装をしない）。
+    const seqHelpers = seqHelpersNeeded
+        ? `
+/// sl_empty — the empty scope handed to scope-free primitive exprs (bc#75: literal eval
+/// never reads scope, so no real snapshot is materialized — just an empty Vec).
+#[allow(dead_code)]
+fn sl_empty() -> Vec<(String, Value)> {
+    Vec::new()
+}
+
+/// sl_head_or — a skippable node's ref head: its local if produced, else the same-named
+/// input binding (scope-composition fall-through). UNKNOWN_BINDING comes from the runtime
+/// SSoT ref_native (expr.rs semantics), never re-implemented here.
+#[allow(dead_code)]
+fn sl_head_or(
+    ok: bool,
+    local: &Value,
+    scope: &[(String, Value)],
+    head: &str,
+) -> Result<Value, behavior_contracts::ExprFailure> {
+    if ok {
+        Ok(local.clone())
+    } else {
+        primitives::ref_native(&[head], scope)
+    }
+}
+`
+        : "";
+    const noExecArm = baseNoExecArmNeeded
+        ? `
+/// 生成された exec 分岐に無い op（決定的には起きない — fail-closed）。
+fn no_exec_arm(id: &str) -> BehaviorError {
+    BehaviorError::new("UNKNOWN_NODE_KIND", format!("op '{id}' has no generated exec arm (fail-closed)"))
+}
+`
+        : "";
+    return `// GENERATED by behavior-contracts common generator (bc#39/#75, straight-line) — DO NOT EDIT.
 // Input: portable component-graph IR only (scp-ir-architecture.md §5/§7.4).
 // This is the STRAIGHT-LINE codegen endpoint (typed-codegen.md §4.1 / bc#39 A2-rust): each
 // component is emitted as a NATIVE rust function that drives the plan via the run_plan
@@ -464,37 +1022,37 @@ function emitModule(plans, ctx) {
 // loop / no generic exec). Scope: componentRef + cond + simple Expression ports
 // (map/batched/concurrency -> A3, hydration -> A4). Handlers are ALWAYS injected at the
 // boundary; they are never generated.
+// The portable IR is NOT embedded: this module carries only IR_FINGERPRINT +
+// COMPONENT_NAMES, so interpreting the IR here is physically impossible. The fail-closed
+// skew gate lives on the consumer side: compare IR_FINGERPRINT against the fingerprint of
+// the live IR the consumer loaded.
 // irFingerprint: ${fingerprint}
 
 // Generated per-component function names deterministically mirror the IR component
 // identifiers (which may be camelCase), so non_snake_case is expected and intentional.
 #![allow(non_snake_case)]
+// Skippable-node result locals are initialized to Value::Null and then overwritten on the
+// produced path OR by the unproduced writeback (bc#75) — the init is intentionally dead.
+#![allow(unused_assignments)]
 
-use ${runtimeImport}::{
-    fingerprint_component_graph, primitives, run_plan, BehaviorError, ComponentExec, ExecOutcome,
-    OpSpec, RelationKind, SpecVersions, Value,
-};
-use serde_json::{json, Value as J};
-use std::sync::LazyLock;
+${runtimeUse}
+${usesJson ? "use serde_json::json;\n" : ""}use std::sync::LazyLock;
 
 /// Spec versions baked at generation time (fail-closed comparison on first use).
 pub const EXPECTED_SPEC_VERSIONS: [(&str, i64); 3] =
     [("behavior", ${specVersions.behavior}), ("expression", ${specVersions.expression}), ("plan", ${specVersions.plan})];
 
-/// FNV-1a 64 fingerprint of the source portable IR (canonical_json discipline, #208).
+/// FNV-1a 64 fingerprint of the source portable IR (canonical_json discipline, #208),
+/// computed at GENERATION time. The IR itself is not embedded — consumers compare this
+/// constant against fingerprint(live IR) for the fail-closed skew gate.
+#[allow(dead_code)] // consumer-side surface (skew gate); nothing inside the module reads it
 pub const IR_FINGERPRINT: &str = ${rustStrLit(fingerprint)};
 
 /// Component names exposed by bind(), in IR declaration order.
 ${componentNamesConst(componentNames)}
 
-/// The portable component-graph IR, built once on first use — embedded for the
-/// load-time fingerprint self-check ONLY (execution never walks it; the straight-line
-/// functions drive the plan directly).
-pub static IR: LazyLock<J> = LazyLock::new(|| {
-    let ir = json!(${irLiteral});
-    check_generated_module(&ir);
-    ir
-});
+/// First-use fail-closed module checks (#208 prepared-artifact discipline), forced by bind().
+static MODULE_CHECK: LazyLock<()> = LazyLock::new(check_generated_module);
 
 fn runtime_spec_version(key: &str) -> i64 {
     match key {
@@ -507,30 +1065,15 @@ fn runtime_spec_version(key: &str) -> i64 {
     }
 }
 
-// First-use fail-closed checks (#208 prepared-artifact discipline).
-fn check_generated_module(ir: &J) {
+// First-use fail-closed checks (#208 prepared-artifact discipline). IR-independent checks
+// only (spec-version envelope pin) — the module has no embedded IR to self-check.
+fn check_generated_module() {
     for (key, want) in EXPECTED_SPEC_VERSIONS {
         let got = runtime_spec_version(key);
         if got != want {
             panic!("behavior-contracts generated module: spec-version skew for '{key}' (generated={want}, runtime={got}) — regenerate against this runtime (fail-closed)");
         }
     }
-    for name in COMPONENT_NAMES {
-        let found = ir["components"]
-            .as_array()
-            .is_some_and(|cs| cs.iter().any(|c| c["name"] == name));
-        if !found {
-            panic!("behavior-contracts generated module: component '{name}' missing from the embedded IR — the generated code was modified or corrupted (fail-closed)");
-        }
-    }
-    let got_fp = fingerprint_component_graph(ir).unwrap_or_else(|e| {
-        panic!(
-            "behavior-contracts generated module: fingerprint recompute failed: {e} (fail-closed)"
-        )
-    });
-    if got_fp != IR_FINGERPRINT {
-        panic!("behavior-contracts generated module: IR fingerprint mismatch (baked={IR_FINGERPRINT}, embedded literal={got_fp}) — the generated code was modified or corrupted (fail-closed)");
-    }
 }
 
 /// UNKNOWN_COMPONENT の fail-closed error（run_behavior と同一コード・文言）。
@@ -539,12 +1082,7 @@ fn check_generated_module(ir: &J) {
 fn unknown_component(component: &str) -> BehaviorError {
     BehaviorError::new("UNKNOWN_COMPONENT", format!("component '{component}' has no handler (fail-closed)"))
 }
-
-/// 生成された exec 分岐に無い op（決定的には起きない — fail-closed）。
-fn no_exec_arm(id: &str) -> BehaviorError {
-    BehaviorError::new("UNKNOWN_NODE_KIND", format!("op '{id}' has no generated exec arm (fail-closed)"))
-}
-
+${noExecArm}${seqHelpers}
 // ── straight-line component functions (no run_behavior tree-walk) ──────────────────
 ${fns}
 
@@ -554,7 +1092,7 @@ ${fns}
 /// run_behavior tree-walk. Observationally equivalent to the run_behavior path: same values,
 /// same emitted op sequence, same Failure code. Forces the first-use fail-closed checks.
 pub fn bind<H: ComponentExec>(handlers: H) -> Bound<H> {
-    LazyLock::force(&IR);
+    LazyLock::force(&MODULE_CHECK);
     Bound { handlers }
 }
 
@@ -580,6 +1118,16 @@ const dialect = {
     mapScopeVar: MAP_SCOPE,
     emitComponent,
     emitModule,
+    // 式 emit は plan 構築時に走るので、json! 使用トラッカーの reset は plan 構築より前
+    // （この hook）で行う。emitModule 内 reset では plan 構築中に立った flag を消してしまう。
+    beginModule() {
+        jsonMacroEmitted = false;
+        seqHelpersNeeded = false;
+        planDrivenNeeded = false;
+        baseNoExecArmNeeded = false;
+        relationKindNeeded = false;
+        execOutcomeNeeded = false;
+    },
 };
 /**
  * rust-typed（bc#48）が struct-native exec を綴じるために再利用する内部 emit ヘルパ。straight-line の