behavior-contracts 0.2.3 → 0.2.5

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

@@ -1,21 +1,42 @@
-import { emitDocLiteral, emitDocLiteralCompact } from "./literal.js";
-import { emitStraightlineModule, } from "./straightline.js";
+import { emitDocLiteralCompact } from "./literal.js";
+import { emitStraightlineModule, buildComponentPlan, sequentialOrder, analyzeSequentialOps, classifyExpr, isScopeFree, componentNeedsScope, } from "./straightline.js";
 /** runtime package alias（生成コード内）。emit-go.ts と同じ `dslcontracts`。 */
 const PKG = "dslcontracts";
+/** scope 式（RunPlan 経路のみ）。逐次経路は進行形 scope ローカル `scope` を使う。 */
+const SCOPE = "baseScope()";
+/** map 本体の要素 scope 式（RunPlan 経路の map 展開用 — 逐次経路は per-map ローカル）。 */
+const MAP_SCOPE = "mscope()";
 /**
- * scope 式（生成コード内）。scope は「input + それまでの ok 結果」のその時点のスナップ。
- * baseScope() 関数呼びで呼び時点の results を読む（決定的）。
+ * 生成中 module の json.Number 使用 / helper 要否の構造的トラッカー（emitModule が emit 前に reset）。
+ * 生成テキストの substring 判定（文字列リテラル内容に誤反応）はしない。
  */
-const SCOPE = "baseScope()";
+const usage = {
+    json: false,
+    runPlan: false,
+    slBind: false,
+    slField: false,
+    slCat: false,
+    slEmpty: false,
+    slPart: false, // RunPlan 経路の concat closure part（実並行のみ）
+    unproduced: false,
+};
 /**
- * map 本体（over/guard/ports）の要素 scope 式（生成コード内）。RunBehavior の map と同じく
- * baseScope に `as`→要素値 を足したスナップ。生成コードは map arm 内で per-element に
- * `mscope()`（*Obj を返すクロージャ）をローカル定義し、port/guard 式はそれを呼ぶ。
+ * typed emitter（bc#47 go-typed）が base straight-line モジュールを同梱し、その上に **RunPlan-style の
+ * struct-native runner** を積む場合、runner は `sync` と RunPlan-path native helper（slRef/slConcat/slPart/
+ * slVal）を参照する。bc#75 で base は逐次 component から RunPlan-path helper を落とすため、typed 層は
+ * この flag で base に「RunPlan-path helper と sync を必ず含めよ」と要求する（typed 経路の後方互換）。
  */
-const MAP_SCOPE = "mscope()";
+let forceRunPlanHelpers = false;
+export function setGoForceRunPlanHelpers(on) {
+    forceRunPlanHelpers = on;
+}
+function resetUsage() {
+    for (const k of Object.keys(usage))
+        usage[k] = false;
+}
 /** IR リテラルを単一行 Go 式として emit（primitive 被演算子用）。 */
 function lit(node) {
-    return emitDocLiteralCompact(node, "go");
+    return emitDocLiteralCompact(node, "go", "$", usage);
 }
 /** args 配列（binary/unary primitive の被演算子）を個別 IR リテラルへ落として `, ` 連結。 */
 function argList(arg) {
@@ -23,9 +44,8 @@ function argList(arg) {
 }
 /**
  * OP_PRIM — overflow/短絡/型判定を持つ演算子 → A0 primitive 直呼びの綴じ方。
- * 命名は go/primitives.go の `Prim*`。被演算子は expr.go の Expr 契約どおり**未評価 IR リテラル**
- * （`and`/`or`/`cond`/`coalesce` の短絡を primitive 内 evaluate が保存する）。
- * NB: ここに `ref`/`refOpt`/`concat` は無い（native 化するため — AC#2）。
+ * 命名は go/primitives.go の `Prim*`。被演算子は expr.go の Expr 契約どおり**未評価 IR リテラル**。
+ * NB: ここに `ref`/`refOpt`/`concat` は無い（native 化する — AC#2）。
  */
 const OP_PRIM = {
     int: (a, s) => `${PKG}.PrimIntLit(${lit(a)}, ${s})`,
@@ -52,25 +72,10 @@ const OP_PRIM = {
     len: (a, s) => `${PKG}.PrimLen(${argList(a)}, ${s})`,
 };
 /**
- * emitExpr — Expression IR ノードを「scope を受けて (Value, error) を返す」Go 式に落とす。
- *
- * 単純式は **native Go helper** へ（脱解釈 — AC#2）、overflow/短絡系は A0 primitive SSoT へ、
- * むき出しスカラは EvalExpr（同一 SSoT）へ落とす。生成される Go 式はどれも `(Value, error)` を
- * 返すので、直線関数側は `must(<expr>)` で 1 行に畳んで scope へ束ねる。
- *   - `{ref:[...]}`    → `${PKG}.slRef(<path>, scope)`      （native scope/field walk）
- *   - `{refOpt:[...]}` → `${PKG}? no — slRefOpt`            （native, null 伝播）
- *   - `{concat:[...]}` → `slConcat([]slPart{...}, scope)`   （native strings.Builder）
- *   - overflow/短絡    → `${PKG}.PrimAdd(...)` 等            （SSoT 直呼び）
- *   - bare scalar      → `${PKG}.EvalExpr(<lit>, scope)`    （SSoT）
- * slRef/slRefOpt/slConcat は **生成モジュール内の native helper**（`EvaluateExpression`/`Prim*`
- * を呼ばない）で、pure ref/concat の生成コードには evaluate/primitive 呼びが一切現れない
- * （AC#2 の構造的 grep 証明）。
+ * emitExpr — Expression IR ノードを「scope を受けて (Value, error) を返す」Go 式に落とす
+ * （**dynamic 式専用**の legacy 経路 — RunPlan 経路と typed emitter が流用する seam）。
  */
 function emitExpr(node, scopeVar) {
-    // ── bare スカラ literal: 型判定の無い string/bool/null は native 化（脱解釈）──────
-    // これらは expr.go でも素通し（INVALID_LITERAL/range 判定を持たない）ので、native Go 値を
-    // そのまま (Value, error) へ包む。number は checked-range/型区別（int vs float）の意味論を
-    // 持つため native 化せず EvalExpr(SSoT) に委譲する（下の fall-through）。
     if (node === null)
         return `slVal(nil)`;
     if (typeof node === "boolean")
@@ -82,22 +87,20 @@ function emitExpr(node, scopeVar) {
         if (keys.length === 1) {
             const op = keys[0];
             const arg = node[op];
-            // ── 単純式: native 化（脱解釈） ─────────────────────────────────────────
             if (op === "ref" || op === "refOpt") {
-                // path は string リテラル配列。native helper へ Go の []string を直接渡す。
+                // RunPlan-path: native slRef/slRefOpt（slPart 枝で定義）を使う。逐次 slFieldVE ではない。
+                usage.slPart = true;
                 return `slRef${op === "refOpt" ? "Opt" : ""}(${emitStringPath(arg)}, ${scopeVar})`;
             }
             if (op === "concat") {
-                // parts は Expression IR 配列。各 part を再帰 native emit した slPart のスライスへ。
+                usage.slPart = true;
                 return `slConcat([]slPart{${emitConcatParts(arg, scopeVar)}}, ${scopeVar})`;
             }
-            // ── overflow/短絡/型判定: A0 primitive SSoT（再実装しない） ──────────────
             const prim = OP_PRIM[op];
             if (prim)
                 return prim(arg, scopeVar);
         }
     }
-    // むき出しスカラ（string/number/bool/null）等 — evaluate SSoT に委譲（同一意味論）。
     return `${PKG}.EvalExpr(${lit(node)}, ${scopeVar})`;
 }
 /** ref/refOpt の path（string リテラル配列）を Go の `[]string{...}` へ。非 string は不正 IR。 */
@@ -111,19 +114,453 @@ function emitStringPath(arg) {
     });
     return `[]string{${segs.join(", ")}}`;
 }
-/**
- * concat の各 part を native `slPart` へ。slPart は「self-eval なクロージャ」= func(scope) (Value, error)。
- * part 自身が式なので `func(s *${PKG}.Obj) (${PKG}.Value, error) { return <emitExpr(part)>; }` で
- * 再帰 native emit する（part が別の concat/ref なら native、overflow なら primitive のまま）。
- */
+/** concat の各 part を native `slPart` closure へ（RunPlan 経路のみ）。 */
 function emitConcatParts(arg, scopeVar) {
     if (!Array.isArray(arg))
         throw new Error("straight-line go: concat args must be an array literal");
-    // part の scope 変数は helper 引数 `s`（呼び時点の scope を受ける）。scopeVar は無視される。
     void scopeVar;
     return arg.map((p) => `func(s *${PKG}.Obj) (${PKG}.Value, error) { return ${emitExpr(p, "s")} }`).join(", ");
 }
-// ── per-node exec 分岐 / component 関数 / module の綴じ方 ──────────────────────
+/** dynamic 式に渡す scope 式（scope-free なら空 scope 定数）。 */
+function seqScope(node, ctx) {
+    if (isScopeFree(node)) {
+        usage.slEmpty = true;
+        return "slEmpty()";
+    }
+    if (ctx.mapAs)
+        return ctx.mapAs.mscopeVar;
+    if (!ctx.scopeVar)
+        throw new Error("straight-line go: scope-reading expr in a scopeless component (analysis bug)");
+    return ctx.scopeVar;
+}
+/**
+ * 静的 ref の head を配線解決した Go 式（`slVE` を返す）。ローカル直読み / input fallback /
+ * UNKNOWN_BINDING。Go は多値 spread が「唯一引数」のときしか許さないため、逐次経路の式は
+ * すべて単一の `slVE` 値（{Val, Err}）へ落とし、slField/slCat が合成できるようにする。
+ */
+function seqRefHead(head, ctx) {
+    if (ctx.mapAs && head === ctx.mapAs.as) {
+        usage.slBind = true;
+        return `slOkVE(${ctx.mapAs.elVar})`;
+    }
+    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);
+            usage.slBind = true;
+            if (ctx.atOutput || !(meta.canSkip || meta.alwaysSkip))
+                return `slOkVE(${local})`;
+            return `slHeadOrVE(${ctx.okFlag.get(head)}, ${local}, input, ${JSON.stringify(head)})`;
+        }
+    }
+    usage.slBind = true;
+    return `slBindVE(input, ${JSON.stringify(head)})`;
+}
+/** 分類済み StaticExpr を Go 式へ（`slVE` を返す — 逐次経路のネイティブ inline）。 */
+function seqStatic(e, ctx) {
+    switch (e.kind) {
+        case "str":
+            usage.slBind = true;
+            return `slValVE(${JSON.stringify(e.value)})`;
+        case "bool":
+            usage.slBind = true;
+            return `slValVE(${e.value ? "true" : "false"})`;
+        case "null":
+            usage.slBind = true;
+            return `slValVE(nil)`;
+        case "ref": {
+            const head = seqRefHead(e.path[0], ctx);
+            if (e.path.length === 1)
+                return head;
+            usage.slField = true;
+            const segs = e.path.slice(1).map((p) => JSON.stringify(p)).join(", ");
+            return `slFieldVE(${JSON.stringify(e.opt ? "refOpt" : "ref")}, ${head}, []string{${segs}})`;
+        }
+        case "concat": {
+            usage.slCat = true;
+            return `slCatVE(${e.parts.map((p) => seqStatic(p, ctx)).join(", ")})`;
+        }
+        case "dynamic":
+            // primitive 経路は (Value, error) を返す — slVE2 で単一 slVE へ包む（唯一引数 spread）。
+            usage.slBind = true;
+            return `slVE2(${emitExpr(e.node, seqScope(e.node, ctx))})`;
+    }
+}
+/** Expression IR → Go 式（逐次経路、`slVE` を返す）。 */
+function seqExpr(node, ctx) {
+    return seqStatic(classifyExpr(node), ctx);
+}
+/** component 名を Go 関数名に使える形へ（決定的。名前一意は DUPLICATE_COMPONENT で保証）。 */
+function sanitize(name) {
+    return name.replace(/[^A-Za-z0-9_]/g, "_");
+}
+/** 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;
+}
+/** 未生成表現の Go 式（single → nil / connection → 空 connection Obj）。 */
+function unproducedGo(relationKind) {
+    usage.unproduced = true;
+    return `${PKG}.UnproducedValue(${JSON.stringify(relationKind === "connection" ? "connection" : "single")})`;
+}
+/** policy 解釈（fail/retry → OP_FAILED、continue → skip）。plan.go interpretOutcome と code/msg 一致。 */
+function seqPolicyThrow(outcomeVar, opId, meta, ind) {
+    if (meta.policy === "retry") {
+        return [
+            `${ind}if ${outcomeVar}.IsError {`,
+            `${ind}\treturn nil, ${PKG}.NewPlanFailure("OP_FAILED", fmt.Sprintf("operation '%s' failed under 'retry' policy (exhausted): %s", ${JSON.stringify(opId)}, ${outcomeVar}.Err))`,
+            `${ind}}`,
+        ];
+    }
+    // fail（既定・未知は手前で UNKNOWN_POLICY throw 済みで到達しない）。
+    return [
+        `${ind}if ${outcomeVar}.IsError {`,
+        `${ind}\treturn nil, ${PKG}.NewPlanFailure("OP_FAILED", fmt.Sprintf("operation '%s' failed under 'fail' policy: %s", ${JSON.stringify(opId)}, ${outcomeVar}.Err))`,
+        `${ind}}`,
+    ];
+}
+/**
+ * emitSeqOp — 逐次直線化された 1 op の文列。policy 検証 → skip 判定（parent 連鎖 / bindField）→
+ * 実行（componentRef/map/cond）→ policy 解釈 → 結果ローカル格納（＋進行形 scope 書き足し）。
+ */
+function emitSeqOp(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(`\t// ── op '${id}' (${op.kind === "cond" ? "cond" : op.kind === "map" ? `map ${op.component}` : op.component}${o.policy ? `, policy ${JSON.stringify(o.policy)}` : ""}) ──`);
+    // policy 検証は skip 判定より先（plan.go preflightOp と同順）。
+    if (typeof meta.policy === "object") {
+        lines.push(`\treturn nil, ${PKG}.NewPlanFailure("UNKNOWN_POLICY", ${JSON.stringify(`unknown policy kind: ${meta.policy.invalid}`)})`);
+        return;
+    }
+    const canSkip = meta.canSkip || meta.alwaysSkip;
+    if (canSkip) {
+        lines.push(`\tvar ${local} ${PKG}.Value = nil`, `\t${ctx.okFlag.get(id)} := false`);
+    }
+    if (meta.alwaysSkip) {
+        lines.push(`\t// parent '${o.parent}' runs later — preflight sees an unsettled parent: 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 bv = `bv_${sanitize(id)}`;
+        const inner = [];
+        const ind = guards.length > 0 ? "\t\t\t" : "\t\t";
+        // parent result[bindField]（parent が Obj のときのみ）。null/欠落なら skip。
+        inner.push(`${ind}${bv}Obj, ${bv}IsObj := ${pLocal}.(*${PKG}.Obj)`);
+        inner.push(`${ind}if ${bv}IsObj {`);
+        inner.push(`${ind}\t${bv}, ${bv}Present := ${bv}Obj.Get(${JSON.stringify(o.bindField)})`);
+        inner.push(`${ind}\tif ${bv}Present && ${bv} != nil {`);
+        emitSeqExec(op, plan, ctx, inner, `${ind}\t\t`);
+        inner.push(`${ind}\t}`);
+        inner.push(`${ind}}`);
+        if (guards.length > 0) {
+            lines.push(`\tif ${guards[0]} {`);
+            lines.push(...inner);
+            lines.push(`\t}`);
+        }
+        else {
+            lines.push(...inner);
+        }
+        return;
+    }
+    if (guards.length > 0) {
+        lines.push(`\tif ${guards[0]} {`);
+        emitSeqExec(op, plan, ctx, lines, "\t\t");
+        lines.push(`\t}`);
+        return;
+    }
+    emitSeqExec(op, plan, ctx, lines, "\t");
+}
+/** op 本体（handler 呼び + policy 解釈 + 結果格納）を indent 付きで emit。 */
+function emitSeqExec(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;
+    // 成功時の格納（ローカル + 進行形 scope）。
+    const store = (valueExpr, target, sind) => {
+        if (canSkip) {
+            target.push(`${sind}${local} = ${valueExpr}`, `${sind}${ctx.okFlag.get(id)} = true`);
+        }
+        else {
+            target.push(`${sind}${local} := ${valueExpr}`, `${sind}_ = ${local}`);
+        }
+        if (ctx.scopeVar)
+            target.push(`${sind}${ctx.scopeVar}.Set(${JSON.stringify(id)}, ${local})`);
+    };
+    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}${v}, ${v}Err := ${emitExpr(node, seqScope(node, ctx))}`);
+        lines.push(`${ind}if ${v}Err != nil {`, `${ind}\treturn nil, ${v}Err`, `${ind}}`);
+        store(v, lines, ind);
+        return;
+    }
+    if (op.kind === "map") {
+        emitSeqMap(op, plan, ctx, lines, ind, store);
+        return;
+    }
+    // componentRef: ports 構築 → handler 呼び → policy 解釈。
+    const savedPos = ctx.currentPos;
+    const portsVar = `ports_${sanitize(id)}`;
+    lines.push(`${ind}${portsVar} := ${PKG}.NewObj()`);
+    for (const p of op.ports) {
+        const node = plan.component.body[i].ports[p.name];
+        const pv = `pv_${sanitize(id)}_${p.name.replace(/[^A-Za-z0-9_]/g, "_")}`;
+        lines.push(`${ind}${pv} := ${seqExpr(node, ctx)}`);
+        lines.push(`${ind}if ${pv}.Err != nil {`, `${ind}\treturn nil, ${pv}.Err`, `${ind}}`);
+        lines.push(`${ind}${portsVar}.Set(${JSON.stringify(p.name)}, ${pv}.Val)`);
+    }
+    ctx.currentPos = savedPos;
+    const oc = `o_${sanitize(id)}`;
+    lines.push(`${ind}${oc}, ${oc}Resolved := ${PKG}.ExecHandler(handlers, ${JSON.stringify(id)}, ${JSON.stringify(op.component)}, ${portsVar}, nil)`);
+    lines.push(`${ind}if !${oc}Resolved {`, `${ind}\treturn nil, ${PKG}.NewBehaviorFailure("UNKNOWN_COMPONENT", "component '${op.component}' has no handler (fail-closed)")`, `${ind}}`);
+    if (meta.policy === "continue") {
+        lines.push(`${ind}if !${oc}.IsError {`);
+        store(`${oc}.Ok`, lines, `${ind}\t`);
+        lines.push(`${ind}}`);
+    }
+    else {
+        lines.push(...seqPolicyThrow(oc, id, meta, ind));
+        store(`${oc}.Ok`, lines, ind);
+    }
+}
+/** emitSeqMap — map ノードの逐次直線展開（RunPlan 経路と観測等価。per-expr scope snapshot 無し）。 */
+function emitSeqMap(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 = JSON.stringify(op.component);
+    const asKey = JSON.stringify(m.as);
+    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 baseScopeExpr = ctx.scopeVar;
+    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 mapCtx = { ...ctx, mapAs: { as: m.as, elVar, mscopeVar } };
+    lines.push(`${ind}${overVar}VE := ${seqExpr(m.over, ctx)}`);
+    lines.push(`${ind}if ${overVar}VE.Err != nil {`, `${ind}\treturn nil, ${overVar}VE.Err`, `${ind}}`);
+    lines.push(`${ind}${overVar}, ${overVar}IsArr := ${overVar}VE.Val.([]${PKG}.Value)`);
+    lines.push(`${ind}if !${overVar}IsArr {`, `${ind}\treturn nil, ${PKG}.NewBehaviorFailure("MAP_OVER_NOT_ARRAY", "map '${id}': 'over' did not evaluate to an array")`, `${ind}}`);
+    lines.push(`${ind}${keptVar} := make([]int, 0, len(${overVar}))`);
+    if (contFlag)
+        lines.push(`${ind}${skipVar} := false`);
+    const mscopeLines = (ind2) => {
+        if (!mapNeedsScope)
+            return [];
+        return [
+            `${ind2}${mscopeVar} := ${PKG}.NewObj()`,
+            ...(baseScopeExpr
+                ? [`${ind2}for _, ${mscopeVar}k := range ${baseScopeExpr}.Keys {`, `${ind2}\t${mscopeVar}.Set(${mscopeVar}k, ${baseScopeExpr}.Vals[${mscopeVar}k])`, `${ind2}}`]
+                : [`${ind2}for _, ${mscopeVar}k := range input.Keys {`, `${ind2}\t${mscopeVar}.Set(${mscopeVar}k, input.Vals[${mscopeVar}k])`, `${ind2}}`]),
+            `${ind2}${mscopeVar}.Set(${asKey}, ${elVar})`,
+        ];
+    };
+    const guardLines = (ind2) => {
+        if (guardIR === undefined)
+            return [];
+        const g = `g_${s}`;
+        return [
+            `${ind2}${g}, ${g}Err := ${emitExpr(guardIR, isScopeFree(guardIR) ? "slEmpty()" : mscopeVar)}`,
+            `${ind2}if ${g}Err != nil {`,
+            `${ind2}\treturn nil, ${g}Err`,
+            `${ind2}}`,
+            `${ind2}if ${g} != true {`,
+            `${ind2}\tcontinue`,
+            `${ind2}}`,
+        ];
+    };
+    const portLines = (ind2, portsVar) => {
+        const out = [`${ind2}${portsVar} := ${PKG}.NewObj()`];
+        for (const p of op.ports) {
+            const pv = `pv_${s}_${p.name.replace(/[^A-Za-z0-9_]/g, "_")}`;
+            out.push(`${ind2}${pv} := ${seqExpr(m.ports[p.name], mapCtx)}`);
+            out.push(`${ind2}if ${pv}.Err != nil {`, `${ind2}\treturn nil, ${pv}.Err`, `${ind2}}`);
+            out.push(`${ind2}${portsVar}.Set(${JSON.stringify(p.name)}, ${pv}.Val)`);
+        }
+        return out;
+    };
+    if (op.batched) {
+        const items = `items_${s}`;
+        lines.push(`${ind}${items} := make([]${PKG}.Value, 0, len(${overVar}))`);
+        lines.push(`${ind}for ${elVar}Idx, ${elVar} := range ${overVar} {`);
+        lines.push(...mscopeLines(`${ind}\t`), ...guardLines(`${ind}\t`), ...portLines(`${ind}\t`, `ports_${s}`));
+        lines.push(`${ind}\t${items} = append(${items}, ports_${s})`, `${ind}\t${keptVar} = append(${keptVar}, ${elVar}Idx)`, `${ind}}`);
+        lines.push(`${ind}var ${collected} []${PKG}.Value`);
+        lines.push(`${ind}if len(${items}) == 0 {`, `${ind}\t${collected} = []${PKG}.Value{}`, `${ind}} else {`);
+        const bp = `bp_${s}`;
+        lines.push(`${ind}\t${bp} := ${PKG}.NewObj()`, `${ind}\t${bp}.Set("items", ${items})`);
+        const oc = `mo_${s}`;
+        lines.push(`${ind}\t${oc}, ${oc}Resolved := ${PKG}.ExecHandler(handlers, ${JSON.stringify(id)}, ${comp}, ${bp}, nil)`);
+        lines.push(`${ind}\tif !${oc}Resolved {`, `${ind}\t\treturn nil, ${PKG}.NewBehaviorFailure("UNKNOWN_COMPONENT", "component '${op.component}' has no handler (fail-closed)")`, `${ind}\t}`);
+        if (contFlag) {
+            lines.push(`${ind}\tif ${oc}.IsError {`, `${ind}\t\t${skipVar} = true`, `${ind}\t} else {`);
+            lines.push(...batchOk(oc, collected, items, id, s, `${ind}\t\t`));
+            lines.push(`${ind}\t}`);
+        }
+        else {
+            lines.push(...seqPolicyThrow(oc, id, meta, `${ind}\t`));
+            lines.push(...batchOk(oc, collected, items, id, s, `${ind}\t`));
+        }
+        lines.push(`${ind}}`);
+    }
+    else {
+        lines.push(`${ind}${collected} := make([]${PKG}.Value, 0, len(${overVar}))`);
+        lines.push(`${ind}for ${elVar}Idx, ${elVar} := range ${overVar} {`);
+        lines.push(...mscopeLines(`${ind}\t`), ...guardLines(`${ind}\t`), ...portLines(`${ind}\t`, `ports_${s}`));
+        const oc = `mo_${s}`;
+        lines.push(`${ind}\t${oc}, ${oc}Resolved := ${PKG}.ExecHandler(handlers, ${JSON.stringify(id)}, ${comp}, ports_${s}, ${elVar})`);
+        lines.push(`${ind}\tif !${oc}Resolved {`, `${ind}\t\treturn nil, ${PKG}.NewBehaviorFailure("UNKNOWN_COMPONENT", "component '${op.component}' has no handler (fail-closed)")`, `${ind}\t}`);
+        if (contFlag) {
+            lines.push(`${ind}\tif ${oc}.IsError {`, `${ind}\t\t${skipVar} = true`, `${ind}\t\tbreak`, `${ind}\t}`);
+        }
+        else {
+            lines.push(...seqPolicyThrow(oc, id, meta, `${ind}\t`));
+        }
+        lines.push(`${ind}\t${collected} = append(${collected}, ${oc}.Ok)`, `${ind}\t${keptVar} = append(${keptVar}, ${elVar}Idx)`, `${ind}}`);
+    }
+    // finish（into zip-attach or collected）— continue はエラー時 skip して未生成。
+    const finish = [];
+    const fInd = contFlag ? `${ind}\t` : ind;
+    if (m.into === undefined) {
+        store(collected, finish, fInd);
+    }
+    else {
+        const aug = `aug_${s}`;
+        finish.push(`${fInd}${aug} := make([]${PKG}.Value, 0, len(${overVar}))`);
+        finish.push(`${fInd}mk_${s} := 0`);
+        finish.push(`${fInd}for mj_${s}, oel_${s} := range ${overVar} {`);
+        finish.push(`${fInd}\tif mk_${s} < len(${keptVar}) && ${keptVar}[mk_${s}] == mj_${s} {`);
+        finish.push(`${fInd}\t\toelObj_${s}, isObj_${s} := oel_${s}.(*${PKG}.Obj)`);
+        finish.push(`${fInd}\t\tif !isObj_${s} {`, `${fInd}\t\t\treturn nil, ${PKG}.NewBehaviorFailure("MAP_INTO_ELEMENT_NOT_OBJECT", fmt.Sprintf("map '${id}': 'into' requires object elements (element %d is not an object)", mj_${s}))`, `${fInd}\t\t}`);
+        finish.push(`${fInd}\t\tcp_${s} := ${PKG}.NewObj()`);
+        finish.push(`${fInd}\t\tfor _, fk_${s} := range oelObj_${s}.Keys {`, `${fInd}\t\t\tcp_${s}.Set(fk_${s}, oelObj_${s}.Vals[fk_${s}])`, `${fInd}\t\t}`);
+        finish.push(`${fInd}\t\tcp_${s}.Set(${JSON.stringify(m.into)}, ${collected}[mk_${s}])`);
+        finish.push(`${fInd}\t\t${aug} = append(${aug}, cp_${s})`, `${fInd}\t\tmk_${s}++`);
+        finish.push(`${fInd}\t} else {`, `${fInd}\t\t${aug} = append(${aug}, oel_${s})`, `${fInd}\t}`);
+        finish.push(`${fInd}}`);
+        store(aug, finish, fInd);
+    }
+    if (contFlag) {
+        lines.push(`${ind}if !${skipVar} {`);
+        lines.push(...finish);
+        lines.push(`${ind}}`);
+    }
+    else {
+        lines.push(...finish);
+    }
+}
+/** batched handler の ok を collected へ（長さ整合検査つき）。 */
+function batchOk(oc, collected, items, id, s, ind) {
+    return [
+        `${ind}r_batch_${s}, isArr_${s} := ${oc}.Ok.([]${PKG}.Value)`,
+        `${ind}if !isArr_${s} || len(r_batch_${s}) != len(${items}) {`,
+        `${ind}\treturn nil, ${PKG}.NewBehaviorFailure("MAP_BATCH_RESULT_MISMATCH", fmt.Sprintf("map '${id}': batched handler must return a list aligned to items (want %d)", len(${items})))`,
+        `${ind}}`,
+        `${ind}${collected} = r_batch_${s}`,
+    ];
+}
+/**
+ * emitSequentialGoFn — 逐次 plan の component を素の文列として綴じる（bc#75 の核）。
+ * RunPlan / OpSpec テーブル / baseScope snapshot / exec closure / per-op ID 探索は無い。
+ */
+function emitSequentialGoFn(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 ctx = {
+        pos,
+        idToIndex,
+        metas,
+        local,
+        okFlag,
+        scopeVar: needScope ? "scope" : null,
+        currentPos: 0,
+        atOutput: false,
+    };
+    const lines = [];
+    lines.push(`func run_${sanitize(plan.name)}(handlers ${PKG}.ComponentExec, input *${PKG}.Obj) (${PKG}.Value, error) {`);
+    lines.push(`\tif input == nil {`, `\t\tinput = ${PKG}.NewObj()`, `\t}`);
+    if (needScope) {
+        // 進行形 scope: input のコピー（bind 側で input は private コピー済み）へノード結果を書き足す。
+        lines.push(`\tscope := ${PKG}.NewObj()`);
+        lines.push(`\tfor _, k := range input.Keys {`, `\t\tscope.Set(k, input.Vals[k])`, `\t}`);
+    }
+    let unreachable = false;
+    for (const k of order.keys()) {
+        const opIdx = order[k];
+        ctx.currentPos = k;
+        if (unreachable)
+            break;
+        emitSeqOp(plan.ops[opIdx], plan, ctx, lines);
+        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;
+            lines.push(`\tif !${okFlag.get(id)} {`);
+            lines.push(`\t\t${local.get(id)} = ${unproducedGo(plan.opsLiteral[i].relationKind)}`);
+            if (needScope)
+                lines.push(`\t\tscope.Set(${JSON.stringify(id)}, ${local.get(id)})`);
+            lines.push(`\t}`);
+        }
+        const outNode = plan.component.output;
+        lines.push(`\toutVE := ${seqExpr(outNode, ctx)}`);
+        lines.push(`\tif outVE.Err != nil {`, `\t\treturn nil, outVE.Err`, `\t}`);
+        lines.push(`\treturn outVE.Val, nil`);
+    }
+    lines.push(`}`);
+    return lines.join("\n");
+}
+// ══════════════════════════════════════════════════════════════════════════════════
+// RunPlan 経路（実並行 plan のみ — bounded 並行の意味論 SSoT を保持）
+// ══════════════════════════════════════════════════════════════════════════════════
 /** ops リテラル（RunPlan に渡す []OpSpec の Go リテラル）を綴じる。 */
 function emitOpsLiteral(plan) {
     const rows = plan.opsLiteral.map((o) => {
@@ -143,7 +580,6 @@ function emitExecArm(op) {
     if (op.kind === "map")
         return emitMapArm(op);
     if (op.kind === "cond") {
-        // cond は純 Expression。scope を渡して 1 式評価（handler は呼ばない）。式は (Value,error)。
         return `\t\tif i == ${op.index} {
 \t\t\tv, err := ${op.expr}
 \t\t\tif err != nil {
@@ -152,7 +588,6 @@ function emitExecArm(op) {
 \t\t\treturn ${PKG}.OkOutcome(v)
 \t\t}`;
     }
-    // componentRef: 各 port を名前付き native/primitive 呼びで評価 → handler 注入呼び。
     const portEvals = op.ports
         .map((p) => `\t\t\t${goPortVar(p.name)}, err := ${p.expr}
 \t\t\tif err != nil {
@@ -170,11 +605,11 @@ function emitExecArm(op) {
 \t\t\treturn outcome
 \t\t}`;
 }
-/** port ローカル変数名（Go 識別子として安全・一意）。宣言順に p0,p1,… を index で衝突回避。 */
+/** port ローカル変数名（Go 識別子として安全）。 */
 function goPortVar(name) {
     return `pv_${name.replace(/[^A-Za-z0-9_]/g, "_")}`;
 }
-/** map arm の要素 ports 構築（要素 scope `mscope()` で各 port を native/primitive 評価）。 */
+/** map arm の要素 ports 構築（RunPlan 経路）。 */
 function emitMapPortEvals(op) {
     if (op.ports.length === 0)
         return `\t\t\t\tports := ${PKG}.NewObj()`;
@@ -187,13 +622,7 @@ function emitMapPortEvals(op) {
         .join("\n");
     return `\t\t\t\tports := ${PKG}.NewObj()\n${lines}`;
 }
-/**
- * emitMapArm — map ノードの直線展開（要素反復・guard skip・per-element/batched handler・into
- * zip-attach）。RunBehavior の map 分岐（behavior.go）を生成 Go へ直線展開する。op-log 等価のため
- * ExecHandler は RunBehavior と同じ ctx（非 batched は bound=要素値、batched は nil）・同じ ports で
- * 呼ぶ。guard は PrimCond（strict-bool SSoT）、into は inline zip-attach（MAP_INTO_ELEMENT_NOT_OBJECT
- * fail-closed で Failure code 一致）。要素反復は宣言どおり逐次。
- */
+/** emitMapArm — map ノードの直線展開（RunPlan 経路）。 */
 function emitMapArm(op) {
     const comp = JSON.stringify(op.component);
     const nodeId = JSON.stringify(op.id);
@@ -293,16 +722,27 @@ ${body}
 \t\t}`;
 }
 /**
- * emitComponentFn — 1 component の直線 Go 関数を綴じる。RunBehavior の実行フロー（results 蓄積 +
- * baseScope + RunPlan + skip→unproduced + output 評価）を **生成コードに直線展開**する
- * （汎用 exec/nodeKind/evalPorts は無い。各 exec 分岐は index で確定・ハードコード）。
+ * emitPlanDrivenGoFn — 実並行 plan（複数 op の stage）の component を RunPlan primitive で綴じる。
+ * bounded 並行・Skip 伝播・Policy Kind の意味論 SSoT は RunPlan が保持する。per-op exec は index で
+ * 確定した分岐（`for k := range ops` 線形 ID 探索は idx 解決に一度だけ・switch はハードコード）。
  */
-function emitComponentFn(plan) {
+function emitPlanDrivenGoFn(plan) {
+    usage.runPlan = true;
+    usage.unproduced = true;
     const arms = plan.ops.map(emitExecArm).join("\n");
     const planLiteral = plan.component.plan
         ? emitBehaviorPlanLiteral(plan.component.plan)
         : `(*${PKG}.ExecutionPlanSpec)(nil)`;
     const output = emitExpr(plan.component.output, SCOPE);
+    // arms は buildComponentPlan 由来の op.expr（emitModule の reset より前に生成）。json/slField/slPart/
+    // slConcat の使用は実 emit テキストで確定させる（arms は我々の生成した go 式で、user 由来 string は
+    // JObjOf/リテラルの内側にあるため token 出現＝実使用で安全）。
+    if (/json\.Number\(|json\.RawMessage/.test(arms))
+        usage.json = true;
+    // slRef/slRefOpt/slConcat/slPart は RunPlan-path helper（usage.slPart 枝で定義）。逐次 slFieldVE
+    // （usage.slField 枝・slVE 型必須）ではないので slPart を立てる。
+    if (/slRef(Opt)?\(|slConcat\(\[\]slPart\{/.test(arms))
+        usage.slPart = true;
     const relationKinds = plan.opsLiteral.map((o) => (o.relationKind === "connection" ? "connection" : "single"));
     const rkLiteral = `[]string{${relationKinds.map((r) => JSON.stringify(r)).join(", ")}}`;
     return `func run_${sanitize(plan.name)}(handlers ${PKG}.ComponentExec, input *${PKG}.Obj) (${PKG}.Value, error) {
@@ -312,7 +752,8 @@ function emitComponentFn(plan) {
 \t}
 \tresults := ${PKG}.NewObj()
 \tvar resultsMu sync.Mutex
-\t// baseScope = input params + accumulated ok results (snapshot at call time).
+\t// baseScope = input params + accumulated ok results (snapshot at call time) — REAL
+\t// concurrency needs a deterministic scope snapshot per exec (bc#75: only this path).
 \tbaseScope := func() *${PKG}.Obj {
 \t\ts := ${PKG}.NewObj()
 \t\tfor _, k := range input.Keys {
@@ -326,28 +767,25 @@ function emitComponentFn(plan) {
 \t\treturn s
 \t}
 \trelationKinds := ${rkLiteral}
-\t// exec-internal failures (BehaviorFailure/ExprFailure) cannot unwind through the
-\t// RunPlan ExecOutcome seam, so each op records its own error and returns a synthetic
-\t// aborted ErrOutcome; sequential precedence is restored after RunPlan (bc#23).
 \texecErrs := make([]error, len(ops))
 \tabort := func(idx int, err error) ${PKG}.ExecOutcome {
 \t\texecErrs[idx] = err
 \t\treturn ${PKG}.ErrOutcome("aborted")
 \t}
-\texec := func(op ${PKG}.OpSpec, _ ${PKG}.Value) ${PKG}.ExecOutcome {
-\t\tidx := -1
-\t\tfor k := range ops {
-\t\t\tif ops[k].ID == op.ID {
-\t\t\t\tidx = k
-\t\t\t\tbreak
-\t\t\t}
-\t\t}
+\t// per-op exec は op の index（RunPlan が渡す OpSpec の位置）で確定する switch。opIndex は
+\t// ops リテラルと 1:1 なので線形 ID 探索は不要（RunPlan が visit 順に呼ぶ i を使う）。
+\texecByIndex := func(idx int) ${PKG}.ExecOutcome {
 \t\ti := idx
 ${arms}
-\t\treturn abort(idx, ${PKG}.NewBehaviorFailure("UNKNOWN_NODE_KIND", "op '"+op.ID+"' has no generated exec arm (fail-closed)"))
+\t\treturn abort(idx, ${PKG}.NewBehaviorFailure("UNKNOWN_NODE_KIND", "op has no generated exec arm (fail-closed)"))
+\t}
+\topIndex := make(map[string]int, len(ops))
+\tfor k := range ops {
+\t\topIndex[ops[k].ID] = k
 \t}
 \twrappedExec := func(op ${PKG}.OpSpec, bound ${PKG}.Value) ${PKG}.ExecOutcome {
-\t\toutcome := exec(op, bound)
+\t\t_ = bound
+\t\toutcome := execByIndex(opIndex[op.ID])
 \t\tif !outcome.IsError {
 \t\t\tresultsMu.Lock()
 \t\t\tresults.Set(op.ID, outcome.Ok)
@@ -363,17 +801,11 @@ ${arms}
 \tif err != nil {
 \t\treturn nil, err
 \t}
-\t// Skipped nodes contribute their unproduced representation to the scope.
 \tfor _, id := range run.Skipped {
 \t\tif _, present := results.Get(id); present {
 \t\t\tcontinue
 \t\t}
-\t\tfor k := range ops {
-\t\t\tif ops[k].ID == id {
-\t\t\t\tresults.Set(id, ${PKG}.UnproducedValue(relationKinds[k]))
-\t\t\t\tbreak
-\t\t\t}
-\t\t}
+\t\tresults.Set(id, ${PKG}.UnproducedValue(relationKinds[opIndex[id]]))
 \t}
 \treturn ${output}
 }`;
@@ -386,130 +818,116 @@ function emitBehaviorPlanLiteral(plan) {
     const conc = p.concurrency ?? 1;
     return `&${PKG}.ExecutionPlanSpec{Groups: ${groupsLit}, Concurrency: ${conc}}`;
 }
-/** component 名を Go 関数名に使える形へ（決定的。名前一意は DUPLICATE_COMPONENT で保証）。 */
-function sanitize(name) {
-    return name.replace(/[^A-Za-z0-9_]/g, "_");
-}
 function emitComponent(plan, _ctx) {
-    return emitComponentFn(plan);
+    const order = sequentialOrder(plan.component);
+    if (order !== null)
+        return emitSequentialGoFn(plan, order);
+    return emitPlanDrivenGoFn(plan);
 }
 function emitModule(plans, ctx) {
     const { fingerprint, specVersions, componentNames, runtimeImport } = ctx;
     const names = componentNames.map((n) => JSON.stringify(n)).join(", ");
-    const irLiteral = emitDocLiteral(ctx.ir, "go");
+    // buildComponentPlan は逐次経路が使わない op.expr を先に emit するため usage を過大に立てる。
+    // 実 emit 直前で reset し、emitComponent 内の呼び出しだけが import/helper 要否を立てるようにする。
+    resetUsage();
     const fns = plans.map((p) => emitComponent(p, ctx)).join("\n\n");
+    if (forceRunPlanHelpers) {
+        // typed 層（go-typed）の struct-native runner は RunPlan-path helper（slRef/slRefOpt/slConcat/slPart/
+        // slVal）と sync を参照する。それらは usage.slPart 枝（slPart type + slConcat + slRef/slRefOpt/
+        // slRefWalk）に集約されている。逐次 slVE 系（slField=slFieldVE 等）は typed runner が使わないので
+        // 立てない（誤って slFieldVE を emit すると slVE 型が要る）。
+        usage.slPart = true;
+        usage.runPlan = true; // sync import
+    }
+    const usesJson = usage.json;
     const dispatchArms = plans
         .map((p) => `\tif name == ${JSON.stringify(p.name)} {\n\t\treturn run_${sanitize(p.name)}(handlers, input)\n\t}`)
         .join("\n");
-    return `// GENERATED by behavior-contracts common generator (bc#38, 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#38 A2): each
-// component is emitted as a native Go function that drives the plan via the RunPlan
-// primitive (#36) and injected handlers. Simple ports are NATIVE-IZED (Phase B
-// de-interpretation): ref/refOpt -> native scope/field walk (slRef/slRefOpt), concat ->
-// native string concatenation (slConcat) — NO EvaluateExpression / Prim* call for those.
-// Only overflow/short-circuit-prone ops (add/sub/mul/div/mod/and/or/cond/coalesce/…) route
-// through the A0 primitive SSoT to preserve fail-closed semantics. It does NOT go through
-// RunBehavior's tree-walk (no nodeKind dispatch / no evalPorts loop / no generic exec).
-// Handlers are ALWAYS injected at the boundary; they are never generated.
-// irFingerprint: ${fingerprint}
-
-package behaviors
-
-import (
-\t"encoding/json"
-\t"fmt"
-\t"strings"
-\t"sync"
-
-\t${PKG} ${JSON.stringify(runtimeImport)}
-)
-
-// ExpectedSpecVersions are the spec versions baked at generation time
-// (fail-closed constant comparison at init).
-var ExpectedSpecVersions = map[string]int64{"behavior": ${specVersions.behavior}, "expression": ${specVersions.expression}, "plan": ${specVersions.plan}}
-
-// IRFingerprint is the FNV-1a 64 fingerprint of the source portable IR
-// (CanonicalJSON discipline, #208).
-const IRFingerprint = ${JSON.stringify(fingerprint)}
-
-// ComponentNames are the components exposed by Bind(), in IR declaration order.
-var ComponentNames = []string{${names}}
-
-// IR is the portable component-graph IR, embedded for the init-time fingerprint
-// self-check only (the straight-line functions do NOT interpret it at run time).
-var IR ${PKG}.JNode = ${irLiteral}
-
-// init — load-time fail-closed checks (#208 prepared-artifact discipline).
-func init() {
-\tfor k, want := range ExpectedSpecVersions {
-\t\tif got := ${PKG}.SpecVersions[k]; got != want {
-\t\t\tpanic(fmt.Sprintf("behavior-contracts generated module: spec-version skew for '%s' (generated=%d, runtime=%d) — regenerate against this runtime (fail-closed)", k, want, got))
-\t\t}
-\t}
-\tgot, err := ${PKG}.FingerprintComponentGraph(IR)
-\tif err != nil {
-\t\tpanic(fmt.Sprintf("behavior-contracts generated module: fingerprint recompute failed: %v (fail-closed)", err))
-\t}
-\tif got != IRFingerprint {
-\t\tpanic(fmt.Sprintf("behavior-contracts generated module: IR fingerprint mismatch (baked=%s, embedded literal=%s) — the generated code was modified or corrupted (fail-closed)", IRFingerprint, got))
-\t}
-}
-
-// ── native simple-expression helpers (Phase B de-interpretation, bc#38) ────────
-// These are NATIVE Go — they never call EvaluateExpression / Prim*. They reproduce
-// expr.go's ref/refOpt/concat semantics (same Failure codes) so the straight-line
-// path is observationally equivalent to RunBehavior for simple ports while removing
-// the expression-tree interpretation.
-
-// slPart is a self-evaluating concat part (recursively native / primitive).
-type slPart = func(scope *${PKG}.Obj) (${PKG}.Value, error)
-
-// slVal wraps a native Go literal (string/bool/null) as a (Value, error) result —
-// bare scalars carry no INVALID_LITERAL/range semantics, so no evaluate is needed.
-func slVal(v ${PKG}.Value) (${PKG}.Value, error) { return v, nil }
-
-// slRef walks a non-empty string path over scope (native; expr.go ref semantics).
-func slRef(path []string, scope *${PKG}.Obj) (${PKG}.Value, error) {
-\treturn slRefWalk("ref", path, scope)
+    // 生成 helper（構造的トラッキングで必要なものだけ emit）。
+    const helpers = [];
+    helpers.push(`// slVal wraps a native Go literal as a (Value, error) result (dynamic/RunPlan path).
+func slVal(v ${PKG}.Value) (${PKG}.Value, error) { return v, nil }`);
+    if (usage.slEmpty)
+        helpers.push(`// slEmpty is the empty scope constant passed to scope-free primitive exprs (bc#75:
+// literal eval never reads scope, so no snapshot is materialized).
+func slEmpty() *${PKG}.Obj { return ${PKG}.NewObj() }`);
+    if (usage.slBind)
+        helpers.push(`// slVE packs a single (Value, error) result so statically-wired inline exprs compose as
+// one expression (bc#75: Go only spreads a multi-return call as the sole argument).
+type slVE struct {
+\tVal ${PKG}.Value
+\tErr error
 }
-
-// slRefOpt is the null-safe variant: a null intermediate propagates null.
-func slRefOpt(path []string, scope *${PKG}.Obj) (${PKG}.Value, error) {
-\treturn slRefWalk("refOpt", path, scope)
+// slVE2 folds a primitive (Value, error) return into an slVE (dynamic residual exprs).
+func slVE2(v ${PKG}.Value, err error) slVE { return slVE{Val: v, Err: err} }
+// slValVE wraps a native literal (string/bool/null) — no evaluate needed.
+func slValVE(v ${PKG}.Value) slVE { return slVE{Val: v} }
+// slOkVE wraps an already-resolved local (statically-wired ref read: no scope snapshot).
+func slOkVE(v ${PKG}.Value) slVE { return slVE{Val: v} }
+// slBindVE reads a scope-bound head directly (UNKNOWN_BINDING matches expr.go).
+func slBindVE(scope *${PKG}.Obj, head string) slVE {
+\tv, ok := scope.Get(head)
+\tif !ok {
+\t\treturn slVE{Err: ${PKG}.NewExprFailure("UNKNOWN_BINDING", "unknown binding: "+head)}
+\t}
+\treturn slVE{Val: v}
 }
-
-func slRefWalk(op string, path []string, scope *${PKG}.Obj) (${PKG}.Value, error) {
-\tif len(path) == 0 {
-\t\treturn nil, ${PKG}.NewExprFailure("INVALID_NODE", op+" expects a non-empty string path")
+// slHeadOrVE — a skippable node's ref head: its local if produced, else the same-named input
+// binding (scope-composition fall-through), else UNKNOWN_BINDING (expr.go semantics).
+func slHeadOrVE(ok bool, local ${PKG}.Value, scope *${PKG}.Obj, head string) slVE {
+\tif ok {
+\t\treturn slVE{Val: local}
 \t}
-\thead := path[0]
-\tcur, ok := scope.Get(head)
-\tif !ok {
-\t\treturn nil, ${PKG}.NewExprFailure("UNKNOWN_BINDING", "unknown binding: "+head)
+\treturn slBindVE(scope, head)
+}`);
+    if (usage.slField)
+        helpers.push(`// slFieldVE walks a static field path over an already-resolved head (bc#75: the head is a
+// local read, not a scope walk). Reproduces expr.go ref/refOpt field semantics.
+func slFieldVE(op string, head slVE, path []string) slVE {
+\tif head.Err != nil {
+\t\treturn head
 \t}
-\tfor _, seg := range path[1:] {
+\tcur := head.Val
+\tfor _, seg := range path {
 \t\tif cur == nil {
 \t\t\tif op == "refOpt" {
-\t\t\t\treturn nil, nil
+\t\t\t\treturn slVE{Val: nil}
 \t\t\t}
-\t\t\treturn nil, ${PKG}.NewExprFailure("NULL_REF", "null intermediate at ."+seg+" (use ?.)")
+\t\t\treturn slVE{Err: ${PKG}.NewExprFailure("NULL_REF", "null intermediate at ."+seg+" (use ?.)")}
 \t\t}
 \t\to, ok := cur.(*${PKG}.Obj)
 \t\tif !ok {
-\t\t\treturn nil, ${PKG}.NewExprFailure("TYPE_MISMATCH", "cannot access ."+seg+" on "+${PKG}.TypeName(cur))
+\t\t\treturn slVE{Err: ${PKG}.NewExprFailure("TYPE_MISMATCH", "cannot access ."+seg+" on "+${PKG}.TypeName(cur))}
 \t\t}
 \t\tnext, present := o.Get(seg)
 \t\tif !present {
-\t\t\treturn nil, ${PKG}.NewExprFailure("MISSING_PROP", "missing property ."+seg)
+\t\t\treturn slVE{Err: ${PKG}.NewExprFailure("MISSING_PROP", "missing property ."+seg)}
 \t\t}
 \t\tcur = next
 \t}
-\treturn cur, nil
-}
-
-// slConcat concatenates n>=2 string parts natively (expr.go concat semantics:
-// strings only, no implicit toString; arity < 2 is invalid IR).
+\treturn slVE{Val: cur}
+}`);
+    if (usage.slCat)
+        helpers.push(`// slCatVE concatenates already-evaluated string parts natively (bc#75: no closures, no
+// slPart func values). Same "all-eval then string check" order + TYPE_MISMATCH as expr.go.
+func slCatVE(parts ...slVE) slVE {
+\tvar b strings.Builder
+\tfor _, p := range parts {
+\t\tif p.Err != nil {
+\t\t\treturn p
+\t\t}
+\t\ts, ok := p.Val.(string)
+\t\tif !ok {
+\t\t\treturn slVE{Err: ${PKG}.NewExprFailure("TYPE_MISMATCH", "concat: strings only (got "+${PKG}.TypeName(p.Val)+"; no implicit toString)")}
+\t\t}
+\t\tb.WriteString(s)
+\t}
+\treturn slVE{Val: b.String()}
+}`);
+    if (usage.slPart)
+        helpers.push(`// slPart is a self-evaluating concat part (RunPlan path only — real-concurrency plans).
+type slPart = func(scope *${PKG}.Obj) (${PKG}.Value, error)
+// slConcat concatenates n>=2 string parts (RunPlan path); arity<2 is invalid IR.
 func slConcat(parts []slPart, scope *${PKG}.Obj) (${PKG}.Value, error) {
 \tif len(parts) < 2 {
 \t\treturn nil, ${PKG}.NewExprFailure("INVALID_NODE", fmt.Sprintf("concat expects >= 2 args, got %d", len(parts)))
@@ -528,15 +946,98 @@ func slConcat(parts []slPart, scope *${PKG}.Obj) (${PKG}.Value, error) {
 \t}
 \treturn b.String(), nil
 }
+// slRef/slRefOpt: RunPlan-path native scope/field walk (expr.go ref semantics).
+func slRef(path []string, scope *${PKG}.Obj) (${PKG}.Value, error) { return slRefWalk("ref", path, scope) }
+func slRefOpt(path []string, scope *${PKG}.Obj) (${PKG}.Value, error) { return slRefWalk("refOpt", path, scope) }
+func slRefWalk(op string, path []string, scope *${PKG}.Obj) (${PKG}.Value, error) {
+\tif len(path) == 0 {
+\t\treturn nil, ${PKG}.NewExprFailure("INVALID_NODE", op+" expects a non-empty string path")
+\t}
+\tcur, ok := scope.Get(path[0])
+\tif !ok {
+\t\treturn nil, ${PKG}.NewExprFailure("UNKNOWN_BINDING", "unknown binding: "+path[0])
+\t}
+\tfor _, seg := range path[1:] {
+\t\tif cur == nil {
+\t\t\tif op == "refOpt" {
+\t\t\t\treturn nil, nil
+\t\t\t}
+\t\t\treturn nil, ${PKG}.NewExprFailure("NULL_REF", "null intermediate at ."+seg+" (use ?.)")
+\t\t}
+\t\to, isObj := cur.(*${PKG}.Obj)
+\t\tif !isObj {
+\t\t\treturn nil, ${PKG}.NewExprFailure("TYPE_MISMATCH", "cannot access ."+seg+" on "+${PKG}.TypeName(cur))
+\t\t}
+\t\tnext, present := o.Get(seg)
+\t\tif !present {
+\t\t\treturn nil, ${PKG}.NewExprFailure("MISSING_PROP", "missing property ."+seg)
+\t\t}
+\t\tcur = next
+\t}
+\treturn cur, nil
+}`);
+    // 依存 import の構造的判定。
+    const imports = [];
+    if (usesJson)
+        imports.push(`\t"encoding/json"`);
+    imports.push(`\t"fmt"`);
+    if (usage.slCat || usage.slPart)
+        imports.push(`\t"strings"`);
+    if (usage.runPlan)
+        imports.push(`\t"sync"`);
+    imports.push(``);
+    imports.push(`\t${PKG} ${JSON.stringify(runtimeImport)}`);
+    return `// GENERATED by behavior-contracts common generator (bc#38/#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): each component is
+// emitted as STATIC native Go (bc#75). Strictly-sequential plans compile to plain
+// statements in dependency order — no RunPlan, no []OpSpec table, no per-op ID search, no
+// baseScope() per-expression snapshots. Statically-wired refs read locals directly; static
+// concat is a flat slCat(...) over already-evaluated values. Only plans with REAL bounded
+// concurrency (multi-op stages) drive the RunPlan primitive (semantics SSoT), and there the
+// per-op exec is index-resolved (no linear ID scan). Fail-closed operator semantics
+// (overflow arithmetic, strict-bool short-circuit, obj/arr construction, checked literals)
+// still route through the A0 Prim* primitives (#36) — the semantics SSoT stays single-
+// sourced. Handlers are ALWAYS injected at the boundary; they are never generated.
+// The portable IR is NOT embedded: this module carries only IRFingerprint + ComponentNames.
+// irFingerprint: ${fingerprint}
+
+package behaviors
+
+import (
+${imports.join("\n")}
+)
+
+// ExpectedSpecVersions are the spec versions baked at generation time
+// (fail-closed constant comparison at init).
+var ExpectedSpecVersions = map[string]int64{"behavior": ${specVersions.behavior}, "expression": ${specVersions.expression}, "plan": ${specVersions.plan}}
+
+// IRFingerprint is the FNV-1a 64 fingerprint of the source portable IR
+// (CanonicalJSON discipline, #208), computed at GENERATION time.
+const IRFingerprint = ${JSON.stringify(fingerprint)}
+
+// ComponentNames are the components exposed by Bind(), in IR declaration order.
+var ComponentNames = []string{${names}}
+
+// init — load-time fail-closed checks (#208 prepared-artifact discipline).
+func init() {
+\tfor k, want := range ExpectedSpecVersions {
+\t\tif got := ${PKG}.SpecVersions[k]; got != want {
+\t\t\tpanic(fmt.Sprintf("behavior-contracts generated module: spec-version skew for '%s' (generated=%d, runtime=%d) — regenerate against this runtime (fail-closed)", k, want, got))
+\t\t}
+\t}
+}
+
+// ── native static-wiring helpers (bc#75) — no scope snapshots, no closures ─────
+// These are NATIVE Go — they never call EvaluateExpression / Prim*. They reproduce
+// expr.go's ref/refOpt/concat semantics (same Failure codes) for the statically-wired
+// inline path while removing the expression-tree interpretation.
+${helpers.join("\n\n")}
 
 // ── straight-line component functions (no RunBehavior tree-walk) ───────────────
 ${fns}
 
-// Bind — inject handlers (boundary injection; catalog name → implementation) and get
-// one executor per component. Each executor runs the straight-line function for that
-// component (plan via RunPlan primitive + per-node native/primitive port eval +
-// injected handler) — NOT the RunBehavior tree-walk. Observationally equivalent to the
-// RunBehavior path: same values, same emitted op sequence, same Failure code.
+// Bind — inject handlers (boundary injection) and get one executor per component.
 func Bind(handlers ${PKG}.ComponentExec) map[string]func(input *${PKG}.Obj) (${PKG}.Value, error) {
 \tbound := make(map[string]func(input *${PKG}.Obj) (${PKG}.Value, error), len(ComponentNames))
 \tfor _, name := range ComponentNames {
@@ -559,12 +1060,12 @@ const dialect = {
     mapScopeVar: MAP_SCOPE,
     emitComponent,
     emitModule,
+    beginModule() {
+        resetUsage();
+    },
 };
 /**
- * go-typed（bc#47）が struct-native exec を綴じるために再利用する内部 emit ヘルパ。straight-line の
- * plan/handler-dispatch SSoT（RunPlan + ExecHandler + native/primitive port eval）をそのまま使い、
- * 「結果を Value scope でなく struct scope に持つ」差分だけを typed 側で足すための seam。runtime 語彙
- * （PKG）と ops/plan リテラル・式 emit を共有する（意味論の二重実装を避ける）。
+ * go-typed（bc#47）が struct-native exec を綴じるために再利用する内部 emit ヘルパ。
  */
 export const goStraightlineInternals = {
     PKG,
@@ -578,10 +1079,6 @@ export const goStraightlineInternals = {
 function emit(ctx) {
     return emitStraightlineModule(ctx, dialect, SCOPE);
 }
-/**
- * goStraightlineEmitter — 言語識別子 `"go-straightline"` の emitter plugin。
- * 既存の `go`（リテラル焼き込み・endpoint 3-literal）と併存する additive な第2モード。
- */
 export const goStraightlineEmitter = {
     language: "go-straightline",
     fileExtension: ".go",
@@ -589,4 +1086,5 @@ export const goStraightlineEmitter = {
     filenameHint: "behaviors.straightline.generated.go",
     emit,
 };
+void buildComponentPlan;
 //# sourceMappingURL=emit-straightline-go.js.map