behavior-contracts 0.2.4 → 0.2.5

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

@@ -1,18 +1,14 @@
 import { emitDocLiteral, emitDocLiteralCompact } from "./literal.js";
-import { emitStraightlineModule, } from "./straightline.js";
+import { emitStraightlineModule, buildComponentPlan, sequentialOrder, analyzeSequentialOps, classifyExpr, isScopeFree, componentNeedsScope, } from "./straightline.js";
 /** primitive namespace alias（生成コード内）。 */
 const CGP = "cgp";
 /**
- * scope 式（生成コード内）。scope は「input + それまでの ok 結果」の**その時点のスナップ**で
- * あり、runBehavior の `baseScope()` と同じく exec ごとに新規に組む。primitive へは
- * `scope()`（関数呼び）を渡す（呼び時点の results を読む — 決定的）。
+ * scope 式（生成コード内・RunPlan 経路のみ）。実並行 plan の component は結果が並行に確定する
+ * ため、runBehavior の `baseScope()` と同じく exec ごとにスナップを組む（決定的）。
+ * 逐次 component は進行形 scope（`scope` ローカル）を使い、この関数形は emit しない。
  */
 const SCOPE = "scope()";
-/**
- * map 本体（over/guard/ports）の要素 scope 式（生成コード内）。runBehavior の map と同じく
- * `{ ...baseScope(), [as]: el }` のスナップを per-element で組む。生成コードはこの名前
- * （`mscope()`）で要素 scope を読む関数を map arm 内にローカル定義する。
- */
+/** map 本体（over/guard/ports）の要素 scope 式（RunPlan 経路の map 展開用 — 逐次経路は `mscope` ローカル）。 */
 const MAP_SCOPE = "mscope()";
 /** IR リテラルを TS 式として emit（primitive 被演算子用の単一行リテラル）。 */
 function lit(node) {
@@ -58,14 +54,33 @@ const OP_EMITTERS = {
     cond: (arg, s) => `${CGP}.cond(${argList(arg)}, ${s})`,
     len: (arg, s) => `${CGP}.len(${argList(arg)}, ${s})`,
 };
+/** module 単位の使用トラッカー（import / 生成 helper の要否を構造的に決める — テキスト scan 禁止）。 */
+const usage = {
+    cgp: false,
+    runPlan: false,
+    runPlanAsync: false,
+    unproducedValue: false,
+    planFailure: false,
+    exprFailure: false,
+    behaviorFailure: false,
+    slBind: false,
+    slField: false,
+    slCat: false,
+    planTypes: false, // Exec/AsyncExec/OpSpec/RelationKind（RunPlan 経路のみ）
+    handlerType: false, // Handler/AsyncHandler（handler を呼ぶ component の run_* param 型）
+};
+function resetUsage() {
+    for (const k of Object.keys(usage))
+        usage[k] = false;
+}
 /**
- * emitExpr — Expression IR ノードを TS の primitive 呼び式に落とす。
- *   - 単一キーの演算子ノード → 対応 primitive（被演算子は IR リテラル＝A0 の Expr 契約）。
- *   - スカラ/ null / bool のむき出しリテラル（例 cond の then=true, ref path 内 string）や
- *     未知の形は `evalExpr`（同一 SSoT）へ落とす。これで型判定を生成コードに残さない。
- * Portability Guard を通過済み（生成時検査）なので未知 operator はここに来ない。
+ * emitExpr — Expression IR ノードを TS の primitive 呼び式に落とす（**dynamic 式専用**の
+ * legacy 経路 — typed emitter（bc#46）が同じ綴じ方を流用する seam でもある）。
+ * 単一キーの演算子ノード → 対応 primitive（被演算子は IR リテラル＝A0 の Expr 契約）、
+ * むき出しスカラ/未知形 → `evalExpr`（同一 SSoT）。
  */
 function emitExpr(node, scopeVar) {
+    usage.cgp = true;
     if (node !== null && typeof node === "object" && !Array.isArray(node)) {
         const keys = Object.keys(node);
         if (keys.length === 1) {
@@ -78,7 +93,461 @@ function emitExpr(node, scopeVar) {
     // スカラリテラル（string/number/bool/null）や obj 以外 — evaluate SSoT に委譲（同一意味論）。
     return `${CGP}.evalExpr(${lit(node)}, ${scopeVar})`;
 }
-// ── per-node exec 分岐 / component 関数 / module の綴じ方 ──────────────────────
+/** dynamic 式に渡す scope 式（scope-free なら空 scope 定数 — リテラル評価は scope を読まない）。 */
+function seqScopeExpr(node, ctx) {
+    if (isScopeFree(node))
+        return "{}";
+    if (ctx.mapAs)
+        return ctx.mapAs.mscopeVar;
+    if (!ctx.scopeVar)
+        throw new Error("straight-line ts: scope-reading expression in a component without a scope (analysis bug)");
+    return ctx.scopeVar;
+}
+/** 静的 ref の head を配線解決した TS 式へ（ローカル直読み / input fallback / UNKNOWN_BINDING）。 */
+function emitRefHead(head, ctx) {
+    // TS の scope 合成 {...input, ...results, [as]: el} は as → results → input の順で shadow する。
+    if (ctx.mapAs && head === ctx.mapAs.as)
+        return 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);
+            if (ctx.atOutput || !(meta.canSkip || meta.alwaysSkip))
+                return local;
+            // 実行済みだが skip され得る: 未生成なら scope 合成は input の同名 key へ fall through する。
+            usage.slBind = true;
+            return `(${ctx.okFlag.get(head)} ? ${local} : slBind(input, ${JSON.stringify(head)}))`;
+        }
+        // まだ実行されていないノード id — results に無いので input の同名 key（無ければ UNKNOWN_BINDING）。
+    }
+    usage.slBind = true;
+    return `slBind(input, ${JSON.stringify(head)})`;
+}
+/** 分類済み StaticExpr を TS 式へ（逐次経路のネイティブ inline）。 */
+function emitStaticExpr(e, ctx) {
+    switch (e.kind) {
+        case "str":
+            return JSON.stringify(e.value);
+        case "bool":
+            return e.value ? "true" : "false";
+        case "null":
+            return "null";
+        case "ref": {
+            const head = emitRefHead(e.path[0], ctx);
+            if (e.path.length === 1)
+                return head;
+            usage.slField = true;
+            return `slField(${JSON.stringify(e.opt ? "refOpt" : "ref")}, ${head}, [${e.path
+                .slice(1)
+                .map((p) => JSON.stringify(p))
+                .join(", ")}])`;
+        }
+        case "concat": {
+            // 可変長 slCat: 引数位置で左→右に評価（evaluate と同順）→ helper 内で string 検査
+            // （evaluate の concat と同じ「全評価 → 型検査」順・同じ TYPE_MISMATCH）。closure 無し。
+            usage.slCat = true;
+            return `slCat(${e.parts.map((p) => emitStaticExpr(p, ctx)).join(", ")})`;
+        }
+        case "dynamic":
+            return emitExpr(e.node, seqScopeExpr(e.node, ctx));
+    }
+}
+/** Expression IR → TS 式（逐次経路: 静的形状は inline・residual は primitive SSoT）。 */
+function emitSeqExpr(node, ctx) {
+    return emitStaticExpr(classifyExpr(node), ctx);
+}
+/** component 名を関数名に使える形へ（決定的・名前は一意 — DUPLICATE_COMPONENT で保証）。 */
+function sanitize(name) {
+    return name.replace(/[^A-Za-z0-9_$]/g, "_");
+}
+/** node id 群 → 衝突しない決定的ローカル名（prefix + sanitize、衝突時は op index を後置）。 */
+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;
+}
+/** component が使う catalog 名（宣言順・重複なし）。bind 時解決の対象。 */
+function componentCatalogNames(plan) {
+    const names = [];
+    for (const op of plan.ops) {
+        if (op.kind === "cond")
+            continue;
+        if (!names.includes(op.component))
+            names.push(op.component);
+    }
+    return names;
+}
+/** catalog 名 → 解決済み handler のローカル変数名（決定的・衝突は index 後置）。 */
+function handlerVars(names) {
+    const out = new Map();
+    const taken = new Set();
+    names.forEach((n, i) => {
+        let v = `h$${sanitize(n)}`;
+        if (taken.has(v))
+            v = `${v}_${i}`;
+        taken.add(v);
+        out.set(n, v);
+    });
+    return out;
+}
+/** 未生成表現の TS リテラル（single → null / connection → 空 connection）。 */
+function unproducedLit(relationKind) {
+    return relationKind === "connection" ? "{ items: [], cursor: null }" : "null";
+}
+/** handler の error outcome を policy で解釈する文（fail/retry → OP_FAILED throw、continue → skip）。 */
+function policyLines(outcomeVar, opId, meta, indent, onContinueSkip) {
+    usage.planFailure = true;
+    if (meta.policy === "fail" || typeof meta.policy === "object") {
+        // 未知 policy はこの手前で UNKNOWN_POLICY を投げているため到達しない（fail は既定）。
+        return [
+            `${indent}if ("error" in ${outcomeVar}) throw new PlanFailure("OP_FAILED", \`operation '${opId}' failed under 'fail' policy: \${${outcomeVar}.error}\`);`,
+        ];
+    }
+    if (meta.policy === "retry") {
+        return [
+            `${indent}if ("error" in ${outcomeVar}) throw new PlanFailure("OP_FAILED", \`operation '${opId}' failed under 'retry' policy (exhausted): \${${outcomeVar}.error}\`);`,
+        ];
+    }
+    // continue: 失敗 op は Port 未生成 → skip（下流へ連鎖）。
+    return [`${indent}if ("error" in ${outcomeVar}) {`, ...onContinueSkip.map((l) => `${indent}  ${l}`), `${indent}} else {`];
+}
+/**
+ * emitSeqOp — 逐次直線化された 1 op の文列。skip 判定（parent 連鎖 / bindField）→ 実行
+ * （componentRef/map/cond）→ policy 解釈 → 結果ローカル格納（＋進行形 scope 書き足し）。
+ */
+function emitSeqOp(op, plan, ctx, hvars, aw, 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)}` : ""}) ──`);
+    // policy 検証は skip 判定より先（plan.ts preflightOp と同順 — UNKNOWN_POLICY は skip でも投げる）。
+    if (typeof meta.policy === "object") {
+        usage.planFailure = true;
+        lines.push(`  throw new PlanFailure("UNKNOWN_POLICY", ${JSON.stringify(`unknown policy kind: ${meta.policy.invalid}`)});`);
+        return; // 以降は到達しない（生成もしない）
+    }
+    const canSkip = meta.canSkip || meta.alwaysSkip;
+    if (canSkip)
+        lines.push(`  let ${local}: Value = null;`, `  let ${ctx.okFlag.get(id)} = false;`);
+    if (meta.alwaysSkip) {
+        lines.push(`  // parent '${plan.opsLiteral[i].parent}' runs later — preflight sees an unsettled parent: unconditional skip.`);
+        return;
+    }
+    // skip ガード（parent produced / bindField null-binding）。
+    const guards = [];
+    if (o.parent !== null) {
+        const pid = plan.opsLiteral[o.parent].id;
+        const pMeta = ctx.metas[o.parent];
+        const pLocal = ctx.local.get(pid);
+        if (pMeta.canSkip || pMeta.alwaysSkip)
+            guards.push(`${ctx.okFlag.get(pid)}`);
+        if (o.bindField !== undefined) {
+            const bv = `bv_${sanitize(id)}`;
+            // 親 result[bindField]（親が plain object のときのみ）。null/欠落なら skip（plan.ts preflightOp）。
+            const read = `${pLocal} !== null && typeof ${pLocal} === "object" && !Array.isArray(${pLocal}) ? (${pLocal} as Record<string, Value>)[${JSON.stringify(o.bindField)}] : undefined`;
+            if (guards.length > 0) {
+                lines.push(`  if (${guards[0]}) {`);
+                emitSeqOpExec(op, plan, ctx, hvars, aw, lines, "    ", bv, read);
+                lines.push(`  }`);
+                return;
+            }
+            emitSeqOpExec(op, plan, ctx, hvars, aw, lines, "  ", bv, read);
+            return;
+        }
+    }
+    if (guards.length > 0) {
+        lines.push(`  if (${guards[0]}) {`);
+        emitSeqOpExec(op, plan, ctx, hvars, aw, lines, "    ");
+        lines.push(`  }`);
+        return;
+    }
+    emitSeqOpExec(op, plan, ctx, hvars, aw, lines, "  ");
+}
+/** op 本体（bindField 判定含む）を indent 付きで emit。 */
+function emitSeqOpExec(op, plan, ctx, hvars, aw, lines, indent, bindVar, bindRead) {
+    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 inner = [];
+    const bodyIndent = bindVar ? indent + "  " : indent;
+    // 成功時の格納（ローカル + 進行形 scope）。
+    const store = (valueExpr, ind, target) => {
+        if (canSkip) {
+            target.push(`${ind}${local} = ${valueExpr};`, `${ind}${ctx.okFlag.get(id)} = true;`);
+        }
+        else {
+            target.push(`${ind}const ${local}: Value = ${valueExpr};`);
+        }
+        if (ctx.scopeVar)
+            target.push(`${ind}${ctx.scopeVar}[${JSON.stringify(id)}] = ${local};`);
+    };
+    if (op.kind === "cond") {
+        // cond は純 Expression（handler 非呼び出し・policy 解釈対象の error outcome も無い）。
+        const c = plan.component.body[i].cond;
+        const expr = emitExpr({ cond: [c.if, c.then, c.else] }, seqScopeExpr({ cond: [c.if, c.then, c.else] }, ctx));
+        store(expr, bodyIndent, inner);
+    }
+    else if (op.kind === "map") {
+        emitSeqMap(op, plan, ctx, hvars, aw, inner, bodyIndent, store);
+    }
+    else {
+        // componentRef: ports 構築（1 回）→ 解決済み handler 直呼び → policy 解釈。
+        const hv = hvars.get(op.component);
+        usage.behaviorFailure = true;
+        const savedPos = ctx.currentPos;
+        const portsExpr = op.ports.length === 0
+            ? "{}"
+            : `{\n${op.ports
+                .map((p) => {
+                const node = plan.component.body[i].ports[p.name];
+                return `${bodyIndent}  ${JSON.stringify(p.name)}: ${emitSeqExpr(node, ctx)},`;
+            })
+                .join("\n")}\n${bodyIndent}}`;
+        ctx.currentPos = savedPos;
+        inner.push(`${bodyIndent}if (!${hv}) throw new BehaviorFailure("UNKNOWN_COMPONENT", ${JSON.stringify(`component '${op.component}' has no handler (fail-closed)`)});`);
+        inner.push(`${bodyIndent}const ports_${sanitize(id)}: Record<string, Value> = ${portsExpr};`);
+        inner.push(`${bodyIndent}const o_${sanitize(id)} = ${aw}${hv}(ports_${sanitize(id)}, { nodeId: ${JSON.stringify(id)}, component: ${JSON.stringify(op.component)} });`);
+        if (meta.policy === "continue") {
+            const cont = policyLines(`o_${sanitize(id)}`, id, meta, bodyIndent, ["// continue policy: no Port produced — downstream skips"]);
+            inner.push(...cont);
+            store(`o_${sanitize(id)}.ok`, bodyIndent + "  ", inner);
+            inner.push(`${bodyIndent}}`);
+        }
+        else {
+            inner.push(...policyLines(`o_${sanitize(id)}`, id, meta, bodyIndent, []));
+            store(`o_${sanitize(id)}.ok`, bodyIndent, inner);
+        }
+    }
+    if (bindVar && bindRead) {
+        lines.push(`${indent}const ${bindVar} = ${bindRead};`);
+        lines.push(`${indent}if (${bindVar} !== undefined && ${bindVar} !== null) {`);
+        lines.push(...inner);
+        lines.push(`${indent}}`);
+    }
+    else {
+        lines.push(...inner);
+    }
+}
+/**
+ * emitSeqMap — map ノードの逐次直線展開。runBehavior の map 分岐と観測等価（要素反復・guard skip・
+ * per-element/batched handler・into zip-attach・Failure code/順序）だが、per-expression scope
+ * snapshot は無い: 要素 scope（mscope）は「進行形 scope のコピー + as 束縛」を**要素ごとに 1 回**
+ * だけ、しかも scope を読む residual 式が map 内にあるときだけ組む。
+ */
+function emitSeqMap(op, plan, ctx, hvars, aw, out, 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 hv = hvars.get(op.component);
+    const asKey = JSON.stringify(m.as);
+    usage.behaviorFailure = true;
+    // 全ローカルを node id で一意化する（同一逐次関数内に複数 map があると素の mi/el/mscope/ports/mk/mj/oel が
+    // 衝突するため — bc#75）。loop 本体は block-scope だが into-walk の mk は関数 body 直下に出るので特に必須。
+    const elVar = `el_${s}`;
+    const mscopeVar = `mscope_${s}`;
+    const portsVar = `ports_${s}`;
+    const miVar = `mi_${s}`;
+    const mjVar = `mj_${s}`;
+    const mkVar = `mk_${s}`;
+    const oelVar = `oel_${s}`;
+    // map 内で scope を読む residual 式があるときだけ mscope を組む（要素ごとに 1 回）。
+    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 ?? "input";
+    const over = `over_${s}`;
+    out.push(`${ind}const ${over} = ${emitSeqExpr(m.over, ctx)};`);
+    out.push(`${ind}if (!Array.isArray(${over})) throw new BehaviorFailure("MAP_OVER_NOT_ARRAY", ${JSON.stringify(`map '${id}': 'over' did not evaluate to an array`)});`);
+    const kept = `kept_${s}`;
+    out.push(`${ind}const ${kept}: number[] = [];`);
+    const mapCtx = { ...ctx, mapAs: { as: m.as, elVar, mscopeVar } };
+    const guardExpr = guardIR === undefined ? undefined : emitExpr(guardIR, isScopeFree(guardIR) ? "{}" : mscopeVar);
+    const portLines = (ind2) => {
+        if (op.ports.length === 0)
+            return [`${ind2}const ${portsVar}: Record<string, Value> = {};`];
+        return [
+            `${ind2}const ${portsVar}: Record<string, Value> = {`,
+            ...op.ports.map((p) => `${ind2}  ${JSON.stringify(p.name)}: ${emitSeqExpr(m.ports[p.name], mapCtx)},`),
+            `${ind2}};`,
+        ];
+    };
+    const mscopeLine = mapNeedsScope
+        ? [`${ind}  const ${mscopeVar}: Scope = { ...${baseScopeExpr}, [${asKey}]: ${elVar} };`]
+        : [];
+    const guardLines = guardExpr === undefined ? [] : [`${ind}  if (${guardExpr} !== true) continue;`];
+    const collected = `collected_${s}`;
+    const outcomeVar = `mo_${s}`;
+    const itemsVar = `items_${s}`;
+    const skipVar = `skip_${s}`;
+    // handler error outcome → policy 解釈（map ノードの policy）。continue はループごと打ち切って skip。
+    const errInterp = (ind2) => {
+        if (meta.policy === "continue") {
+            // continue: この op は未生成のまま — 生成側は skip フラグを立てず外へ抜ける。
+            return [`${ind2}if ("error" in ${outcomeVar}) { ${collected}.length = 0; ${skipVar} = true; break; }`];
+        }
+        return policyLines(outcomeVar, id, meta, ind2, []);
+    };
+    const contFlag = meta.policy === "continue";
+    if (contFlag)
+        out.push(`${ind}let ${skipVar} = false;`);
+    if (op.batched) {
+        out.push(`${ind}const ${itemsVar}: Value[] = [];`);
+        out.push(`${ind}for (let ${miVar} = 0; ${miVar} < (${over} as Value[]).length; ${miVar}++) {`);
+        out.push(`${ind}  const ${elVar} = (${over} as Value[])[${miVar}];`);
+        out.push(...mscopeLine, ...guardLines, ...portLines(`${ind}  `));
+        out.push(`${ind}  ${itemsVar}.push(${portsVar});`, `${ind}  ${kept}.push(${miVar});`, `${ind}}`);
+        out.push(`${ind}let ${collected}: Value[] = [];`);
+        out.push(`${ind}if (${itemsVar}.length > 0) {`);
+        out.push(`${ind}  if (!${hv}) throw new BehaviorFailure("UNKNOWN_COMPONENT", ${JSON.stringify(`component '${op.component}' has no handler (fail-closed)`)});`);
+        out.push(`${ind}  const ${outcomeVar} = ${aw}${hv}({ items: ${itemsVar} }, { nodeId: ${JSON.stringify(id)}, component: ${JSON.stringify(op.component)} });`);
+        const okLines = [
+            `${ind}  if (!("error" in ${outcomeVar})) {`,
+            `${ind}    if (!Array.isArray(${outcomeVar}.ok) || ${outcomeVar}.ok.length !== ${itemsVar}.length)`,
+            `${ind}      throw new BehaviorFailure("MAP_BATCH_RESULT_MISMATCH", \`map '${id}': batched handler must return a list aligned to items (want \${${itemsVar}.length}, got \${Array.isArray(${outcomeVar}.ok) ? ${outcomeVar}.ok.length : typeof ${outcomeVar}.ok})\`);`,
+            `${ind}    ${collected} = ${outcomeVar}.ok as Value[];`,
+            `${ind}  }`,
+        ];
+        if (contFlag) {
+            // continue 版: エラー時は break 済み — ここは ok のみ。
+            out.push(...errInterp(`${ind}  `));
+            out.push(...okLines);
+        }
+        else {
+            // fail/retry 版: policyLines が throw 済み — ok を素で読む。
+            out.push(...policyLines(outcomeVar, id, meta, `${ind}  `, []));
+            out.push(`${ind}  if (!Array.isArray(${outcomeVar}.ok) || ${outcomeVar}.ok.length !== ${itemsVar}.length)`, `${ind}    throw new BehaviorFailure("MAP_BATCH_RESULT_MISMATCH", \`map '${id}': batched handler must return a list aligned to items (want \${${itemsVar}.length}, got \${Array.isArray(${outcomeVar}.ok) ? ${outcomeVar}.ok.length : typeof ${outcomeVar}.ok})\`);`, `${ind}  ${collected} = ${outcomeVar}.ok as Value[];`);
+        }
+        out.push(`${ind}}`);
+    }
+    else {
+        out.push(`${ind}const ${collected}: Value[] = [];`);
+        out.push(`${ind}if (!${hv}) throw new BehaviorFailure("UNKNOWN_COMPONENT", ${JSON.stringify(`component '${op.component}' has no handler (fail-closed)`)});`);
+        out.push(`${ind}for (let ${miVar} = 0; ${miVar} < (${over} as Value[]).length; ${miVar}++) {`);
+        out.push(`${ind}  const ${elVar} = (${over} as Value[])[${miVar}];`);
+        out.push(...mscopeLine, ...guardLines, ...portLines(`${ind}  `));
+        out.push(`${ind}  const ${outcomeVar} = ${aw}${hv}(${portsVar}, { nodeId: ${JSON.stringify(id)}, component: ${JSON.stringify(op.component)}, bound: ${elVar} });`);
+        if (contFlag) {
+            out.push(`${ind}  if ("error" in ${outcomeVar}) { ${skipVar} = true; break; }`);
+            out.push(`${ind}  ${collected}.push(${outcomeVar}.ok);`, `${ind}  ${kept}.push(${miVar});`);
+        }
+        else {
+            out.push(...policyLines(outcomeVar, id, meta, `${ind}  `, []));
+            out.push(`${ind}  ${collected}.push(${outcomeVar}.ok);`, `${ind}  ${kept}.push(${miVar});`);
+        }
+        out.push(`${ind}}`);
+    }
+    const finish = [];
+    if (m.into === undefined) {
+        store(collected, contFlag ? `${ind}  ` : ind, finish);
+    }
+    else {
+        const aug = `aug_${s}`;
+        const ind2 = contFlag ? `${ind}  ` : ind;
+        finish.push(`${ind2}// map.into zip-attach (behavior.ts applyInto): over と同じ長さ・順序で guard 通過要素へ`, `${ind2}// ${JSON.stringify(m.into)} を書き戻す（skip 要素は無変更で pass-through、親不変=shallow copy）。`, `${ind2}const ${aug}: Value[] = [];`, `${ind2}let ${mkVar} = 0;`, `${ind2}for (let ${mjVar} = 0; ${mjVar} < (${over} as Value[]).length; ${mjVar}++) {`, `${ind2}  const ${oelVar} = (${over} as Value[])[${mjVar}];`, `${ind2}  if (${mkVar} < ${kept}.length && ${kept}[${mkVar}] === ${mjVar}) {`, `${ind2}    if (${oelVar} === null || typeof ${oelVar} !== "object" || Array.isArray(${oelVar}))`, `${ind2}      throw new BehaviorFailure("MAP_INTO_ELEMENT_NOT_OBJECT", \`map '${id}': 'into' requires object elements (element \${${mjVar}} is not an object)\`);`, `${ind2}    ${aug}.push({ ...(${oelVar} as Record<string, Value>), [${JSON.stringify(m.into)}]: ${collected}[${mkVar}] });`, `${ind2}    ${mkVar}++;`, `${ind2}  } else {`, `${ind2}    ${aug}.push(${oelVar});`, `${ind2}  }`, `${ind2}}`);
+        store(aug, ind2, finish);
+    }
+    if (contFlag) {
+        out.push(`${ind}if (!${skipVar}) {`);
+        out.push(...finish);
+        out.push(`${ind}}`);
+    }
+    else {
+        out.push(...finish);
+    }
+}
+/**
+ * emitSequentialFn — 逐次 plan の component を素の文列として綴じる（bc#75 の核）。
+ * RunPlan / ops テーブル / exec closure / per-op ID 探索 / per-expression scope snapshot は無い。
+ */
+function emitSequentialFn(plan, order, aw) {
+    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 catalogs = componentCatalogNames(plan);
+    if (catalogs.length > 0)
+        usage.handlerType = true;
+    const hvars = handlerVars(catalogs);
+    const fn = sanitize(plan.name);
+    const suffix = aw === "" ? "" : "_async";
+    const hType = aw === "" ? "Handler" : "AsyncHandler";
+    const ret = aw === "" ? "Value" : "Promise<Value>";
+    const params = catalogs.map((c) => `${hvars.get(c)}: ${hType} | undefined`).concat(`input: Scope`).join(", ");
+    const lines = [];
+    lines.push(`${aw === "" ? "function" : "async function"} run_${fn}${suffix}(${params}): ${ret} {`);
+    if (needScope) {
+        // 進行形 scope: input のプライベートコピー（bind 側で作成済み）へノード結果を書き足す。
+        // per-expression snapshot は無い — scope を読む residual 式だけがこのオブジェクトを受ける。
+        lines.push(`  const scope: Scope = input;`);
+    }
+    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, hvars, aw, lines);
+        if (typeof metas[opIdx].policy === "object")
+            unreachable = true;
+    }
+    if (!unreachable) {
+        // 未生成書き戻し（output の ref/coalesce が読めるように — writeUnproduced と同一）。
+        ctx.atOutput = true;
+        for (const i of order) {
+            const meta = metas[i];
+            if (!(meta.canSkip || meta.alwaysSkip))
+                continue;
+            const id = plan.opsLiteral[i].id;
+            const up = unproducedLit(plan.opsLiteral[i].relationKind);
+            lines.push(`  if (!${okFlag.get(id)}) {`);
+            lines.push(`    ${local.get(id)} = ${up};`);
+            if (needScope)
+                lines.push(`    scope[${JSON.stringify(id)}] = ${local.get(id)};`);
+            lines.push(`  }`);
+        }
+        lines.push(`  return ${emitSeqExpr(plan.component.output, ctx)};`);
+    }
+    lines.push(`}`);
+    return lines.join("\n");
+}
+// ══════════════════════════════════════════════════════════════════════════════════
+// RunPlan 経路（実並行 plan のみ — bounded 並行の意味論 SSoT を保持）
+// ══════════════════════════════════════════════════════════════════════════════════
 /** ops リテラル（runPlan に渡す OpSpec[] の TS リテラル）を綴じる。 */
 function emitOpsLiteral(plan) {
     const rows = plan.opsLiteral.map((o) => {
@@ -102,23 +571,17 @@ function emitMapPorts(op) {
         .join("\n")}\n          };`;
 }
 /**
- * emitMapArm — map ノードの直線展開（要素反復・guard skip・per-element/batched handler・into
- * zip-attach）。runBehavior の map 分岐（behavior.ts §map）を生成コードに直線展開する。op-log
- * 等価のため、handler は runBehavior と同じ ctx（非 batched は `{nodeId,component,bound}`、batched は
- * `{nodeId,component}`）・同じ ports 形で呼ぶ。guard は cond primitive（strict-bool SSoT）。into は
- * A0 `hydrateInto` primitive（zip-attach SSoT）。要素反復は宣言どおり逐次（並列単位は body ノード）。
+ * emitMapArm — map ノードの直線展開（RunPlan 経路）。runBehavior の map 分岐（behavior.ts §map）と
+ * 観測等価。op-log 等価のため、handler は runBehavior と同じ ctx・同じ ports 形で呼ぶ。
  */
-function emitMapArm(op, aw) {
-    const comp = JSON.stringify(op.component);
+function emitMapArm(op, aw, hv) {
     const nodeId = JSON.stringify(op.id);
+    const comp = JSON.stringify(op.component);
     const asKey = JSON.stringify(op.as);
     const guardCheck = op.guard === undefined ? "" : `\n          if (${op.guard} !== true) continue;`;
     const intoTail = op.into === undefined
         ? "        return { ok: collected };"
-        : `        // map.into zip-attach (behavior.ts applyInto): over と同じ長さ・順序で guard 通過要素へ
-        // ${JSON.stringify(op.into)} を書き戻す（skip 要素は無変更で pass-through、親不変=shallow copy）。
-        // Failure code は runBehavior と一致（非 object 要素は MAP_INTO_ELEMENT_NOT_OBJECT）。
-        {
+        : `        {
           const augmented: Value[] = [];
           let mk = 0;
           for (let mj = 0; mj < (over as Value[]).length; mj++) {
@@ -148,9 +611,8 @@ function emitMapArm(op, aw) {
         if (items.length === 0) {
           collected = [];
         } else {
-          const h = handlers[${comp}];
-          if (!h) throw new BehaviorFailure("UNKNOWN_COMPONENT", \`component '${op.component}' has no handler (fail-closed)\`);
-          const outcome = ${aw}h({ items }, { nodeId: ${nodeId}, component: ${comp} });
+          if (!${hv}) throw new BehaviorFailure("UNKNOWN_COMPONENT", \`component '${op.component}' has no handler (fail-closed)\`);
+          const outcome = ${aw}${hv}({ items }, { nodeId: ${nodeId}, component: ${comp} });
           if ("error" in outcome) return outcome;
           if (!Array.isArray(outcome.ok) || outcome.ok.length !== items.length)
             throw new BehaviorFailure("MAP_BATCH_RESULT_MISMATCH", \`map '${op.id}': batched handler must return a list aligned to items (want \${items.length}, got \${Array.isArray(outcome.ok) ? outcome.ok.length : typeof outcome.ok})\`);
@@ -158,20 +620,19 @@ function emitMapArm(op, aw) {
         }
 ${intoTail}`
         : `        const collected: Value[] = [];
-        const h = handlers[${comp}];
-        if (!h) throw new BehaviorFailure("UNKNOWN_COMPONENT", \`component '${op.component}' has no handler (fail-closed)\`);
+        if (!${hv}) throw new BehaviorFailure("UNKNOWN_COMPONENT", \`component '${op.component}' has no handler (fail-closed)\`);
         for (let mi = 0; mi < (over as Value[]).length; mi++) {
           const el = (over as Value[])[mi];
           const mscope = (): Scope => ({ ...scope(), [${asKey}]: el });
           void mscope;${guardCheck}
           ${emitMapPorts(op)}
-          const outcome = ${aw}h(ports, { nodeId: ${nodeId}, component: ${comp}, bound: el });
+          const outcome = ${aw}${hv}(ports, { nodeId: ${nodeId}, component: ${comp}, bound: el });
           if ("error" in outcome) return outcome;
           collected.push(outcome.ok);
           keptIdx.push(mi);
         }
 ${intoTail}`;
-    return `      if (i === ${op.index}) {
+    return `      {
         const over = ${op.over};
         if (!Array.isArray(over)) throw new BehaviorFailure("MAP_OVER_NOT_ARRAY", \`map '${op.id}': 'over' did not evaluate to an array\`);
         const keptIdx: number[] = [];
@@ -179,139 +640,244 @@ ${body}
       }`;
 }
 /**
- * 1ノードの exec 分岐本体（index で分岐 — nodeKind ディスパッチではない）。`aw` は handler 呼びの
- * await キーワード（同期経路は ""、非同期経路 bindAsync は "await "）。cond は handler を呼ばない
- * ので aw は無関係。
+ * 1ノードの exec 本体（RunPlan 経路 — 事前解決した per-op 関数として綴じる。ID 探索は無い）。
  */
-function emitExecArm(op, aw) {
+function emitExecFn(op, aw, hvars) {
     if (op.kind === "cond") {
-        // cond は純 Expression。scope を渡して1式評価（handler は呼ばない）。
-        return `      if (i === ${op.index}) return { ok: ${op.expr} };`;
+        return `      return { ok: ${op.expr} };`;
     }
     if (op.kind === "map")
-        return emitMapArm(op, aw);
-    // componentRef: 各 port を名前付き primitive 呼びで評価 → handler 注入呼び。
+        return emitMapArm(op, aw, hvars.get(op.component));
+    const hv = hvars.get(op.component);
     const portLines = op.ports.length === 0
         ? "        const ports: Record<string, Value> = {};"
         : `        const ports: Record<string, Value> = {\n${op.ports
             .map((p) => `          ${JSON.stringify(p.name)}: ${p.expr},`)
             .join("\n")}\n        };`;
-    return `      if (i === ${op.index}) {
+    return `      {
 ${portLines}
-        const h = handlers[${JSON.stringify(op.component)}];
-        if (!h) throw new BehaviorFailure("UNKNOWN_COMPONENT", \`component '${op.component}' has no handler (fail-closed)\`);
-        return ${aw}h(ports, { nodeId: ${JSON.stringify(op.id)}, component: ${JSON.stringify(op.component)} });
+        if (!${hv}) throw new BehaviorFailure("UNKNOWN_COMPONENT", \`component '${op.component}' has no handler (fail-closed)\`);
+        return ${aw}${hv}(ports, { nodeId: ${JSON.stringify(op.id)}, component: ${JSON.stringify(op.component)} });
       }`;
 }
 /**
- * emitComponentFn — 1 component の直線関数を綴じる。runBehavior の実行フロー（results 蓄積 +
- * baseScope + runPlan + writeUnproduced + output 評価）を **生成コードに直線展開**する
- * （汎用 exec/nodeKind/evalPorts は無い。各 exec 分岐は index で確定・ハードコード）。
+ * emitPlanDrivenFn — 実並行 plan（複数 op の stage）の component を RunPlan primitive で綴じる。
+ * bounded 並行・Skip 伝播・Policy Kind の意味論 SSoT は runPlan/runPlanAsync が保持する。
+ * per-op exec は事前解決した関数表（id → fn）で引く（線形 ID 探索は無い）。scope は並行確定に
+ * 備えて exec ごとのスナップ（runBehavior の baseScope と同一・決定的）。
  */
-function emitComponentFn(plan) {
-    const syncArms = plan.ops.map((o) => emitExecArm(o, "")).join("\n");
-    const asyncArms = plan.ops.map((o) => emitExecArm(o, "await ")).join("\n");
-    const planLiteral = plan.component.plan
-        ? emitDocLiteral(plan.component.plan, "ts", 1)
-        : "null";
+function emitPlanDrivenFn(plan, aw) {
+    usage.cgp = usage.cgp; // no-op（明示）
+    usage.behaviorFailure = true;
+    usage.unproducedValue = true;
+    usage.planTypes = true;
+    if (aw === "")
+        usage.runPlan = true;
+    else
+        usage.runPlanAsync = true;
+    const catalogs = componentCatalogNames(plan);
+    if (catalogs.length > 0)
+        usage.handlerType = true;
+    const hvars = handlerVars(catalogs);
+    const fn = sanitize(plan.name);
+    const suffix = aw === "" ? "" : "_async";
+    const hType = aw === "" ? "Handler" : "AsyncHandler";
+    const ret = aw === "" ? "Value" : "Promise<Value>";
+    const execT = aw === "" ? "Exec" : "AsyncExec";
+    const params = catalogs.map((c) => `${hvars.get(c)}: ${hType} | undefined`).concat(`input: Scope`).join(", ");
+    const planLiteral = plan.component.plan ? emitDocLiteral(plan.component.plan, "ts", 1) : "null";
     const output = emitExpr(plan.component.output, SCOPE);
     const relationKinds = plan.opsLiteral.map((o) => (o.relationKind === "connection" ? "connection" : "single"));
-    const relDecl = `const relationKinds: (RelationKind | undefined)[] = ${JSON.stringify(relationKinds)};`;
-    const sync = `function run_${sanitize(plan.name)}(handlers: Handlers, input: Scope): Value {
-  const ops: OpSpec[] = ${emitOpsLiteral(plan)};
-  const results: Record<string, Value> = {};
-  const scope = (): Scope => ({ ...input, ...results });
-  ${relDecl}
-  const exec: Exec = (op) => {
-    const i = ops.findIndex((o) => o.id === op.id);
-${syncArms}
-    throw new BehaviorFailure("UNKNOWN_NODE_KIND", \`op '\${op.id}' has no generated exec arm (fail-closed)\`);
-  };
-  const wrappedExec: Exec = (op, bound) => {
-    const outcome = exec(op, bound);
-    if ("ok" in outcome) results[op.id] = outcome.ok;
-    return outcome;
-  };
-  const run = runPlan(${planLiteral}, ops, wrappedExec);
-  run.states.forEach((st, i) => {
-    if (st.status === "skipped") results[ops[i].id] = unproducedValue(relationKinds[i]);
-  });
-  return ${output};
-}`;
-    // async 版: plan の stage 内独立 op を plan.concurrency で bounded 並列に dispatch する
-    // （runPlanAsync = A0 の bounded 並行 plan primitive を per-node thunk で直呼び）。並行を
-    // 潰さず runBehaviorAsync と同一の並列挙動（同一 emitted-op 多重集合 / 同一結果）を持つ。
-    // 逐次化（concurrency=1 へ改変）すると in-flight 並列が消え pin が壊れる（AC#2/#3 非空虚）。
-    const asyncFn = `async function run_${sanitize(plan.name)}_async(handlers: AsyncHandlers, input: Scope): Promise<Value> {
+    const fns = plan.ops
+        .map((o) => `    ${JSON.stringify(o.id)}: ${aw === "" ? "" : "async "}()${aw === "" ? ": ExecOutcome" : ": Promise<ExecOutcome>"} => {
+${emitExecFn(o, aw, hvars)}
+    },`)
+        .join("\n");
+    return `${aw === "" ? "function" : "async function"} run_${fn}${suffix}(${params}): ${ret} {
   const ops: OpSpec[] = ${emitOpsLiteral(plan)};
   const results: Record<string, Value> = {};
   const scope = (): Scope => ({ ...input, ...results });
-  ${relDecl}
-  const exec: AsyncExec = async (op) => {
-    const i = ops.findIndex((o) => o.id === op.id);
-${asyncArms}
-    throw new BehaviorFailure("UNKNOWN_NODE_KIND", \`op '\${op.id}' has no generated exec arm (fail-closed)\`);
+  const relationKinds: (RelationKind | undefined)[] = ${JSON.stringify(relationKinds)};
+  // per-op exec は事前解決した関数表で引く（線形 ID 探索は無い — bc#75）。
+  const execs: Record<string, ${aw === "" ? "() => ExecOutcome" : "() => Promise<ExecOutcome>"}> = {
+${fns}
   };
-  const wrappedExec: AsyncExec = async (op, bound) => {
-    const outcome = await exec(op, bound);
+  const exec: ${execT} = ${aw === "" ? "" : "async "}(op) => {
+    const f = execs[op.id];
+    if (!f) throw new BehaviorFailure("UNKNOWN_NODE_KIND", \`op '\${op.id}' has no generated exec arm (fail-closed)\`);
+    const outcome = ${aw}f();
     if ("ok" in outcome) results[op.id] = outcome.ok;
     return outcome;
   };
-  const run = await runPlanAsync(${planLiteral}, ops, wrappedExec);
+  const run = ${aw}${aw === "" ? "runPlan" : "runPlanAsync"}(${planLiteral}, ops, exec);
   run.states.forEach((st, i) => {
     if (st.status === "skipped") results[ops[i].id] = unproducedValue(relationKinds[i]);
   });
   return ${output};
 }`;
-    return `${sync}\n\n${asyncFn}`;
 }
-/** component 名を関数名に使える形へ（決定的・衝突は index で回避しない: 名前は一意 — DUPLICATE_COMPONENT で保証）。 */
-function sanitize(name) {
-    return name.replace(/[^A-Za-z0-9_$]/g, "_");
+// ══════════════════════════════════════════════════════════════════════════════════
+// module 綴じ
+// ══════════════════════════════════════════════════════════════════════════════════
+function emitComponentFns(plan) {
+    const order = sequentialOrder(plan.component);
+    if (order !== null) {
+        const sync = emitSequentialFn(plan, order, "");
+        const asyncFn = emitSequentialFn(plan, order, "await ");
+        return `${sync}\n\n${asyncFn}`;
+    }
+    const sync = emitPlanDrivenFn(plan, "");
+    const asyncFn = emitPlanDrivenFn(plan, "await ");
+    return `${sync}\n\n${asyncFn}`;
 }
 function emitComponent(plan, _ctx) {
-    return emitComponentFn(plan);
+    return emitComponentFns(plan);
+}
+/** bind 時 handler 解決の per-component wrapper（sync/async）。 */
+function emitBindWrappers(plan) {
+    const catalogs = componentCatalogNames(plan);
+    if (catalogs.length > 0)
+        usage.handlerType = true;
+    const hvars = handlerVars(catalogs);
+    const fn = sanitize(plan.name);
+    const resolveSync = catalogs.map((c) => `  const ${hvars.get(c)} = handlers[${JSON.stringify(c)}];`).join("\n");
+    const argsSync = catalogs.map((c) => hvars.get(c)).concat("{ ...input }").join(", ");
+    return `function bind_${fn}(handlers: Handlers): (input?: Scope) => Value {
+  // handler 解決は bind 時に 1 回（catalog 名 → 実装）。呼び出しは解決済み参照の直呼び。
+${resolveSync}
+  return (input: Scope = {}) => run_${fn}(${argsSync});
+}
+
+function bindAsync_${fn}(handlers: AsyncHandlers): (input?: Scope) => Promise<Value> {
+${catalogs.map((c) => `  const ${hvars.get(c)} = handlers[${JSON.stringify(c)}];`).join("\n")}
+  return (input: Scope = {}) => run_${fn}_async(${argsSync});
+}`;
+}
+/** 生成 module 内 native helper（静的配線 ref/concat の tail walk・型検査 — closure 無し）。 */
+function emitNativeHelpers() {
+    const parts = [];
+    if (usage.slBind || usage.slField || usage.slCat) {
+        usage.exprFailure = true;
+        parts.push(`// ── native static-wiring helpers (bc#75) — no scope snapshots, no closures ─────────
+// These reproduce expr-eval's ref/refOpt/concat semantics (same Failure codes) for the
+// statically-wired inline path; the semantics SSoT stays the ExprFailure taxonomy.
+function slTypeName(v: Value): string {
+  if (v === null) return "null";
+  if (typeof v === "bigint") return "int";
+  if (typeof v === "number") return "float";
+  if (Array.isArray(v)) return "arr";
+  return typeof v;
+}
+void slTypeName;`);
+    }
+    if (usage.slBind)
+        parts.push(`// slBind — scope 束縛 head の直読み（UNKNOWN_BINDING は evaluate と同一）。
+function slBind(scope: Scope, head: string): Value {
+  if (!Object.prototype.hasOwnProperty.call(scope, head))
+    throw new ExprFailure("UNKNOWN_BINDING", \`unknown binding: \${head}\`);
+  return scope[head];
+}`);
+    if (usage.slField)
+        parts.push(`// slField — 静的 path の field walk（NULL_REF / MISSING_PROP / TYPE_MISMATCH / refOpt null 伝播）。
+function slField(op: "ref" | "refOpt", cur: Value, path: readonly string[]): Value {
+  for (const seg of path) {
+    if (cur === null) {
+      if (op === "refOpt") return null;
+      throw new ExprFailure("NULL_REF", \`null intermediate at .\${seg}（?. を使う）\`);
+    }
+    if (typeof cur !== "object" || Array.isArray(cur))
+      throw new ExprFailure("TYPE_MISMATCH", \`cannot access .\${seg} on \${slTypeName(cur)}\`);
+    if (!Object.prototype.hasOwnProperty.call(cur, seg))
+      throw new ExprFailure("MISSING_PROP", \`missing property .\${seg}\`);
+    cur = (cur as Record<string, Value>)[seg];
+  }
+  return cur;
+}`);
+    if (usage.slCat)
+        parts.push(`// slCat — n-ary concat（引数位置で評価済みの値を受ける — closure も part 関数値も無い。
+// evaluate の concat と同じ「全評価 → string 検査」順・同じ TYPE_MISMATCH）。
+function slCat(...parts: Value[]): string {
+  for (const p of parts)
+    if (typeof p !== "string")
+      throw new ExprFailure("TYPE_MISMATCH", \`concat: string のみ（got \${slTypeName(p)}。数値の暗黙 toString は存在しない）\`);
+  return (parts as string[]).join("");
+}`);
+    return parts.join("\n\n");
 }
 function emitModule(plans, ctx) {
     const { fingerprint, specVersions, componentNames, runtimeImport } = ctx;
     const spec = runtimeImport;
     const names = componentNames.map((n) => JSON.stringify(n)).join(", ");
-    const irLiteral = emitDocLiteral(ctx.ir, "ts");
+    // buildComponentPlan（straightline.ts）は逐次経路が使わない op.expr を先に emit するため usage を
+    // 過大に立てる（例: cgp）。ここ（実 emit 直前）で reset し、実際に emit される emitComponent 内の
+    // 呼び出しだけが import/helper 要否を立てるようにする（bc#75: 全静的 component は cgp を使わない）。
+    resetUsage();
     const fns = plans.map((p) => emitComponent(p, ctx)).join("\n\n");
-    const dispatchArms = plans
-        .map((p) => `    if (name === ${JSON.stringify(p.name)}) return run_${sanitize(p.name)}(handlers, { ...input });`)
-        .join("\n");
-    const dispatchAsyncArms = plans
-        .map((p) => `    if (name === ${JSON.stringify(p.name)}) return run_${sanitize(p.name)}_async(handlers, { ...input });`)
+    const wrappers = plans.map((p) => emitBindWrappers(p)).join("\n\n");
+    const bindArms = plans.map((p) => `    ${JSON.stringify(p.name)}: bind_${sanitize(p.name)}(handlers),`).join("\n");
+    const bindAsyncArms = plans
+        .map((p) => `    ${JSON.stringify(p.name)}: bindAsync_${sanitize(p.name)}(handlers),`)
         .join("\n");
-    return `// GENERATED by behavior-contracts common generator (bc#37/#42, straight-line) — DO NOT EDIT.
+    const helpers = emitNativeHelpers();
+    const valueImports = ["SPEC_VERSIONS"];
+    if (usage.behaviorFailure)
+        valueImports.push("BehaviorFailure");
+    if (usage.planFailure)
+        valueImports.push("PlanFailure");
+    if (usage.exprFailure)
+        valueImports.push("ExprFailure");
+    if (usage.cgp)
+        valueImports.push(`codegenPrimitives as ${CGP}`);
+    if (usage.runPlan)
+        valueImports.push("runPlan");
+    if (usage.runPlanAsync)
+        valueImports.push("runPlanAsync");
+    if (usage.unproducedValue)
+        valueImports.push("unproducedValue");
+    // Handlers/AsyncHandlers は bind/bindAsync のシグネチャで常に使う。Handler/AsyncHandler（単数）は
+    // handler を呼ぶ component（componentRef/map）を持つ run_* だけが param 型に使う（bc#75: cond-only
+    // 逐次 component は handler param を取らないので unused import になる）。
+    const typeImports = ["Handlers", "AsyncHandlers", "Scope", "Value"];
+    if (usage.handlerType)
+        typeImports.push("Handler", "AsyncHandler");
+    if (usage.planTypes)
+        typeImports.push("AsyncExec", "Exec", "ExecOutcome", "OpSpec", "RelationKind");
+    typeImports.sort();
+    return `// GENERATED by behavior-contracts common generator (bc#37/#42/#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 a native function that drives the plan via the runPlan primitive and evaluates
-// every port + output through the A0 expression-operator primitives (#36) + injected handlers.
-// It does NOT go through runBehavior's tree-walk (no nodeKind dispatch / no evalPorts loop /
-// no generic exec). Scope: componentRef + cond + map (over/when/into/batched — bc#42 A3), with
-// simple Expression ports. bind() drives runPlan (same-value sequential fallback per plan.ts);
-// bindAsync() drives the runPlanAsync bounded-parallel primitive with per-node thunks so the
-// generated code preserves plan.concurrency (same parallel behavior as runBehaviorAsync — bc#42
-// AC#2). Handlers are ALWAYS injected at the boundary; they are never generated.
+// emitted as STATIC native code (bc#75). Strictly-sequential plans compile to plain
+// statements in dependency order — no RunPlan, no ops table, no per-op ID search, no
+// per-expression scope 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/runPlanAsync primitive (semantics SSoT),
+// and there the per-op exec is a pre-resolved function table. Fail-closed operator
+// semantics (overflow arithmetic, strict-bool short-circuit and/or/cond/coalesce, obj/arr
+// construction, checked literals) still route through the A0 expression-operator
+// primitives (#36) — the semantics SSoT stays single-sourced. Handlers are resolved ONCE
+// at bind() time and invoked through the resolved reference (UNKNOWN_COMPONENT stays
+// fail-closed at op execution). 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 (consumer-side fail-closed skew gate).
 // irFingerprint: ${fingerprint}
-import { SPEC_VERSIONS, fingerprintComponentGraph, BehaviorFailure, codegenPrimitives as ${CGP}, runPlan, runPlanAsync, unproducedValue } from ${JSON.stringify(spec)};
-import type { AsyncExec, AsyncHandlers, ComponentGraphIR, Exec, Handlers, OpSpec, RelationKind, Scope, Value } from ${JSON.stringify(spec)};
+import { ${valueImports.join(", ")} } from ${JSON.stringify(spec)};
+import type { ${typeImports.join(", ")} } from ${JSON.stringify(spec)};
 
 /** Spec versions baked at generation time (fail-closed constant comparison at load). */
 export const EXPECTED_SPEC_VERSIONS = { behavior: ${specVersions.behavior}, expression: ${specVersions.expression}, plan: ${specVersions.plan} } as const;
 
-/** FNV-1a 64 fingerprint of the source portable IR (canonicalJson discipline, #208). */
+/**
+ * FNV-1a 64 fingerprint of the source portable IR (canonicalJson discipline, #208),
+ * computed at GENERATION time. The IR itself is not embedded — consumers compare this
+ * constant against the fingerprint of the live IR they loaded (fail-closed skew gate).
+ */
 export const IR_FINGERPRINT = ${JSON.stringify(fingerprint)};
 
 /** Component names exposed by bind(), in IR declaration order. */
 export const COMPONENT_NAMES: readonly string[] = [${names}];
 
-/** The portable component-graph IR, embedded for the load-time fingerprint self-check only. */
-export const IR: ComponentGraphIR = ${irLiteral};
-
-// ── load-time fail-closed checks (#208 prepared-artifact discipline, checked ONCE) ─────
+// ── load-time fail-closed checks (#208 prepared-artifact discipline, checked ONCE).
+// IR-independent checks only (spec-version envelope pin) — no embedded IR to self-check. ──
 for (const [k, want] of Object.entries(EXPECTED_SPEC_VERSIONS)) {
   const got = (SPEC_VERSIONS as Record<string, number>)[k];
   if (got !== want)
@@ -319,49 +885,34 @@ for (const [k, want] of Object.entries(EXPECTED_SPEC_VERSIONS)) {
       \`behavior-contracts generated module: spec-version skew for '\${k}' (generated=\${want}, runtime=\${got}) — regenerate against this runtime (fail-closed)\`,
     );
 }
-if (fingerprintComponentGraph(IR) !== IR_FINGERPRINT)
-  throw new Error(
-    \`behavior-contracts generated module: IR fingerprint mismatch (baked=\${IR_FINGERPRINT}, embedded literal=\${fingerprintComponentGraph(IR)}) — the generated code was modified or corrupted (fail-closed)\`,
-  );
-
+${helpers ? `\n${helpers}\n` : ""}
 // ── straight-line component functions (no runBehavior tree-walk) ───────────────────
 ${fns}
 
+${wrappers}
+
 /**
  * bind — inject handlers (boundary injection; catalog name → implementation) and get one
- * callable per component. Each callable runs the straight-line function for that component
- * (plan via runPlan primitive + per-node primitive port eval + injected handler) — NOT
+ * callable per component. Handler resolution happens HERE, once; each callable runs the
+ * static straight-line function for that component through the resolved references — NOT
  * the runBehavior tree-walk. Observationally equivalent to the runBehavior path:
  * same values, same emitted op sequence, same Failure code/message.
  */
 export function bind(handlers: Handlers): Record<string, (input?: Scope) => Value> {
-  const bound: Record<string, (input?: Scope) => Value> = {};
-  for (const name of COMPONENT_NAMES) bound[name] = (input: Scope = {}) => dispatch(name, handlers, input);
-  return bound;
-}
-
-function dispatch(name: string, handlers: Handlers, input: Scope): Value {
-${dispatchArms}
-  throw new BehaviorFailure("UNKNOWN_ENTRY", \`component '\${name}' not found in this module (fail-closed)\`);
+  return {
+${bindArms}
+  };
 }
 
 /**
- * bindAsync — as bind, but each callable drives the plan via the runPlanAsync bounded-parallel
- * primitive with per-node thunks. Same-stage independent ops are dispatched up to
- * plan.concurrency in flight (async handlers awaited), preserving the exact parallel behavior of
- * the async ir path (same emitted-op multiset + same result). Map bodies iterate elements in
- * declaration order (the parallel unit is the body node, per §7). Observationally equivalent to
- * the async ir path.
+ * bindAsync — as bind, but async handlers are awaited. Components with a real-concurrency
+ * plan drive the runPlanAsync bounded-parallel primitive (same in-flight behavior as the
+ * async ir path); strictly-sequential components run as awaited straight statements.
  */
 export function bindAsync(handlers: AsyncHandlers): Record<string, (input?: Scope) => Promise<Value>> {
-  const bound: Record<string, (input?: Scope) => Promise<Value>> = {};
-  for (const name of COMPONENT_NAMES) bound[name] = (input: Scope = {}) => dispatchAsync(name, handlers, input);
-  return bound;
-}
-
-function dispatchAsync(name: string, handlers: AsyncHandlers, input: Scope): Promise<Value> {
-${dispatchAsyncArms}
-  throw new BehaviorFailure("UNKNOWN_ENTRY", \`component '\${name}' not found in this module (fail-closed)\`);
+  return {
+${bindAsyncArms}
+  };
 }
 `;
 }
@@ -370,15 +921,18 @@ const dialect = {
     mapScopeVar: MAP_SCOPE,
     emitComponent,
     emitModule,
+    beginModule() {
+        resetUsage();
+    },
 };
 /**
  * 公開再エクスポート（bc#46 B2 typed emitter が同じ TS dialect / scope 名を流用するため）。
  * typed 経路は runtime 本体をこの straight-line dialect で綴じ、byte 同一の runtime を保つ。
  */
 export const straightlineTsDialect = dialect;
-/** 生成コード内の scope 式（`scope()`）。typed emitter が同名で port/output を評価する。 */
+/** 生成コード内の scope 式（`scope()` — RunPlan 経路）。typed emitter が同名で port/output を評価する。 */
 export const TS_SCOPE = SCOPE;
-/** 生成コード内の map 要素 scope 式（`mscope()`）。 */
+/** 生成コード内の map 要素 scope 式（`mscope()` — RunPlan 経路）。 */
 export const TS_MAP_SCOPE = MAP_SCOPE;
 function emit(ctx) {
     return emitStraightlineModule(ctx, dialect, SCOPE);
@@ -394,4 +948,6 @@ export const typescriptStraightlineEmitter = {
     filenameHint: "behaviors.straightline.generated.ts",
     emit,
 };
+void buildComponentPlan;
+void 0;
 //# sourceMappingURL=emit-straightline-typescript.js.map