behavior-contracts 0.5.0 → 0.6.0

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

@@ -1,855 +0,0 @@
-import { emitDocLiteral, emitDocLiteralCompact } from "./literal.js";
-import { emitStraightlineModule, sequentialOrder, analyzeSequentialOps, classifyExpr, isScopeFree, componentNeedsScope, } from "./straightline.js";
-/** primitive namespace alias（生成コード内 — `behavior_contracts.primitives` を `cgp` で import）。 */
-const CGP = "cgp";
-/**
- * scope 式（生成コード内）。scope は「input + それまでの ok 結果」のその時点のスナップで
- * あり、run_behavior の base_scope() と同じく exec ごとに新規に組む。native/primitive 双方へ
- * `_scope()`（関数呼び）を渡す（呼び時点の results を読む — 決定的）。
- */
-const SCOPE = "_scope()";
-/**
- * map 本体（over/guard/ports）の要素 scope 式（生成コード内）。run_behavior の map と同じく
- * `{**base_scope(), as: el}` を per-element で組む（生成コードは map arm 内で `_mscope()` を
- * ローカル定義する）。
- */
-const MAP_SCOPE = "_mscope()";
-/**
- * bc: codegen は IR を出力してはならない（no-ir invariant）。
- * 非脱解釈の式（obj/arr/scalar/演算子被演算子）を IR リテラルとして埋め込み A0 primitive に
- * 実行時解釈させる＝インタプリタの松葉杖（＝癌）は撤去。ここに来る式はネイティブ脱解釈が必要（次タスク）。
- */
-function lit(node) {
-    throw new Error(`codegen no-ir invariant: refusing to emit IR literal for ${JSON.stringify(node).slice(0, 100)} — de-interpret this expression to native code (next task)`);
-}
-/** args 配列（比較・算術の二項/単項）を要素ごとに IR リテラルへ落として `, ` 連結。 */
-function argList(arg) {
-    return arg.map((a) => lit(a)).join(", ");
-}
-// A0 primitives.py の引数形に合わせた op → 呼び式の綴じ方（TS oracle と違い python の primitive は
-// 被演算子を **位置引数**で取る: add(a, b, scope) / cond(c, then, els, scope) / obj(fields, scope) …）。
-// 命名は docs/codegen-primitives.md（python 列）に一致。ref/refOpt/concat と単純リテラルはここに無い
-// （native 化するため emitExpr が直接 native コードを出す — 本 issue の脱解釈）。
-const OP_EMITTERS = {
-    // リテラルラッパ（int は i64 checked / float は NaN/Inf checked — native 化しない）
-    int: (arg, s) => `${CGP}.int_lit(${lit(arg)}, ${s})`,
-    float: (arg, s) => `${CGP}.float_lit(${lit(arg)}, ${s})`,
-    // 構築（fields/elements は未評価 IR）
-    obj: (arg, s) => `${CGP}.obj(${lit(arg)}, ${s})`,
-    arr: (arg, s) => `${CGP}.arr(${lit(arg)}, ${s})`,
-    // 数値（checked。二項は a,b / 単項は a）
-    add: (arg, s) => `${CGP}.add(${argList(arg)}, ${s})`,
-    sub: (arg, s) => `${CGP}.sub(${argList(arg)}, ${s})`,
-    mul: (arg, s) => `${CGP}.mul(${argList(arg)}, ${s})`,
-    neg: (arg, s) => `${CGP}.neg(${argList(arg)}, ${s})`,
-    div: (arg, s) => `${CGP}.div(${argList(arg)}, ${s})`,
-    mod: (arg, s) => `${CGP}.mod(${argList(arg)}, ${s})`,
-    // 比較（二項）
-    eq: (arg, s) => `${CGP}.eq(${argList(arg)}, ${s})`,
-    ne: (arg, s) => `${CGP}.ne(${argList(arg)}, ${s})`,
-    lt: (arg, s) => `${CGP}.lt(${argList(arg)}, ${s})`,
-    le: (arg, s) => `${CGP}.le(${argList(arg)}, ${s})`,
-    gt: (arg, s) => `${CGP}.gt(${argList(arg)}, ${s})`,
-    ge: (arg, s) => `${CGP}.ge(${argList(arg)}, ${s})`,
-    // bool/null（短絡: 被演算子は未評価 IR で渡す — primitive 内 evaluate が短絡）
-    and: (arg, s) => `${CGP}.and_(${argList(arg)}, ${s})`,
-    or: (arg, s) => `${CGP}.or_(${argList(arg)}, ${s})`,
-    not: (arg, s) => `${CGP}.not_(${argList(arg)}, ${s})`,
-    coalesce: (arg, s) => `${CGP}.coalesce(${argList(arg)}, ${s})`,
-    cond: (arg, s) => `${CGP}.cond(${argList(arg)}, ${s})`,
-    len: (arg, s) => `${CGP}.len_(${argList(arg)}, ${s})`,
-};
-/** ref/refOpt の path（string 配列）を python list リテラルへ。 */
-function pathLit(arg) {
-    return lit(arg);
-}
-/**
- * emitExpr — Expression IR ノードを python 式へ落とす（脱解釈: 単純式は native、意味論式は primitive）。
- *
- *   - `concat`                → native `_sl_concat([...])`（str-only / arity>=2 を native チェック）。
- *   - `ref` / `refOpt`        → native `_sl_ref(...)` / `_sl_ref_opt(...)`（path を native 走査）。
- *   - str/bool/None/int/float → native python リテラル（portability guard 済み → 安全域内で evaluate と同値）。
- *   - それ以外の演算子ノード  → A0 primitive（`cgp.*`。被演算子は未評価 IR リテラル＝短絡保存）。
- *   - 未知の形               → 到達しない（Portability Guard 通過済み）。防御的に primitive `eval_expr` へ。
- *
- * native 経路は `evaluate()` も `cgp.*` も呼ばない（AC#2/#7 の grep 証明の対象）。
- */
-function emitExpr(node, scopeVar) {
-    // スカラリテラル（native）。
-    if (node === null)
-        return "None";
-    if (typeof node === "boolean")
-        return node ? "True" : "False";
-    if (typeof node === "string")
-        return lit(node);
-    if (typeof node === "number")
-        return lit(node); // literal.ts が安全域を fail-closed 済み
-    if (typeof node === "object" && !Array.isArray(node)) {
-        const keys = Object.keys(node);
-        if (keys.length === 1) {
-            const op = keys[0];
-            const arg = node[op];
-            // ── 単純式の native 化（脱解釈）──────────────────────────────────────
-            if (op === "ref")
-                return `_sl_ref(${pathLit(arg)}, ${scopeVar})`;
-            if (op === "refOpt")
-                return `_sl_ref_opt(${pathLit(arg)}, ${scopeVar})`;
-            if (op === "concat") {
-                const parts = arg.map((p) => emitExpr(p, scopeVar));
-                return `_sl_concat([${parts.join(", ")}])`;
-            }
-            // ── 意味論式（overflow/短絡/fail-closed）は A0 primitive SSoT へ ─────────
-            const em = OP_EMITTERS[op];
-            if (em)
-                return em(arg, scopeVar);
-        }
-    }
-    // 配列裸出し等の不正形は Portability Guard で弾かれ到達しないが、防御的に SSoT へ委譲。
-    return `${CGP}.eval_expr(${lit(node)}, ${scopeVar})`;
-}
-// ── per-node exec 分岐 / component 関数 / module の綴じ方 ──────────────────────
-/** ops リテラル（run_plan に渡す OpSpec[] の python list リテラル）を綴じる。 */
-function emitOpsLiteral(plan) {
-    const rows = plan.opsLiteral.map((o) => {
-        const parts = [`"id": ${JSON.stringify(o.id)}`, `"parent": ${o.parent === null ? "None" : String(o.parent)}`];
-        if (o.bindField !== undefined)
-            parts.push(`"bindField": ${JSON.stringify(o.bindField)}`);
-        if (o.relationKind !== undefined)
-            parts.push(`"relationKind": ${JSON.stringify(o.relationKind)}`);
-        if (o.policy !== undefined)
-            parts.push(`"policy": ${JSON.stringify(o.policy)}`);
-        return `        {${parts.join(", ")}},`;
-    });
-    return `[\n${rows.join("\n")}\n    ]`;
-}
-/** map arm の要素 ports リテラル（要素 scope `_mscope()` で評価）。 */
-function emitMapPorts(op) {
-    if (op.ports.length === 0)
-        return "{}";
-    return `{\n${op.ports
-        .map((p) => `                ${JSON.stringify(p.name)}: ${p.expr},`)
-        .join("\n")}\n            }`;
-}
-/**
- * emitMapArm — map ノードの直線展開（要素反復・guard skip・per-element/batched handler・into
- * zip-attach）。run_behavior の map 分岐を生成 python へ直線展開する。op-log 等価のため handler は
- * run_behavior と同じ ctx（非 batched は bound 付き、batched は無し）・同じ ports 形で呼ぶ。guard は
- * cond primitive（strict-bool SSoT）で、into は A0 `cgp.hydrate_into`（zip-attach SSoT）で解決する。
- */
-function emitMapArm(op) {
-    const comp = JSON.stringify(op.component);
-    const nodeId = JSON.stringify(op.id);
-    const asKey = JSON.stringify(op.as);
-    const guardCheck = op.guard === undefined ? "" : `\n                if ${op.guard} is not True:\n                    continue`;
-    const intoTail = op.into === undefined
-        ? "            return {\"ok\": _collected}"
-        : `            # map.into zip-attach（behavior.py applyInto）: over と同じ長さ・順序で guard 通過要素へ
-            # 書き戻す（skip 要素は無変更、親不変）。Failure code は run_behavior と一致。
-            _augmented = []
-            _k = 0
-            for _mj, _oel in enumerate(_over):
-                if _k < len(_kept_idx) and _kept_idx[_k] == _mj:
-                    if not isinstance(_oel, dict):
-                        raise BehaviorFailure("MAP_INTO_ELEMENT_NOT_OBJECT", "map '${op.id}': 'into' requires object elements (element %d is not an object)" % _mj)
-                    _augmented.append({**_oel, ${JSON.stringify(op.into)}: _collected[_k]})
-                    _k += 1
-                else:
-                    _augmented.append(_oel)
-            return {"ok": _augmented}`;
-    const body = op.batched
-        ? `            _items = []
-            for _mi, _el in enumerate(_over):
-                def _mscope(_el=_el):
-                    return {**_scope(), ${asKey}: _el}${guardCheck}
-                _items.append(${emitMapPorts(op)})
-                _kept_idx.append(_mi)
-            if not _items:
-                _collected = []
-            else:
-                h = handlers.get(${comp})
-                if h is None:
-                    raise BehaviorFailure("UNKNOWN_COMPONENT", "component '${op.component}' has no handler (fail-closed)")
-                outcome = h({"items": _items}, {"nodeId": ${nodeId}, "component": ${comp}})
-                if "error" in outcome:
-                    return outcome
-                _r = outcome["ok"]
-                if not isinstance(_r, list) or len(_r) != len(_items):
-                    raise BehaviorFailure("MAP_BATCH_RESULT_MISMATCH", "map '${op.id}': batched handler must return a list aligned to items (want %d)" % len(_items))
-                _collected = _r
-${intoTail}`
-        : `            _collected = []
-            h = handlers.get(${comp})
-            if h is None:
-                raise BehaviorFailure("UNKNOWN_COMPONENT", "component '${op.component}' has no handler (fail-closed)")
-            for _mi, _el in enumerate(_over):
-                def _mscope(_el=_el):
-                    return {**_scope(), ${asKey}: _el}${guardCheck}
-                ports = ${emitMapPorts(op)}
-                outcome = h(ports, {"nodeId": ${nodeId}, "component": ${comp}, "bound": _el})
-                if "error" in outcome:
-                    return outcome
-                _collected.append(outcome["ok"])
-                _kept_idx.append(_mi)
-${intoTail}`;
-    return `        if i == ${op.index}:
-            _over = ${op.over}
-            if not isinstance(_over, list):
-                raise BehaviorFailure("MAP_OVER_NOT_ARRAY", "map '${op.id}': 'over' did not evaluate to an array")
-            _kept_idx = []
-${body}`;
-}
-/** 1ノードの exec 分岐本体（index で分岐 — nodeKind ディスパッチではない）。 */
-function emitExecArm(op) {
-    if (op.kind === "cond") {
-        // cond は純 Expression。scope を渡して1式評価（handler は呼ばない）。
-        return `        if i == ${op.index}:\n            return {"ok": ${op.expr}}`;
-    }
-    if (op.kind === "map")
-        return emitMapArm(op);
-    // componentRef: 各 port を名前付き native/primitive 呼びで評価 → handler 注入呼び。
-    const portLines = op.ports.length === 0
-        ? "            ports = {}"
-        : `            ports = {\n${op.ports
-            .map((p) => `                ${JSON.stringify(p.name)}: ${p.expr},`)
-            .join("\n")}\n            }`;
-    return `        if i == ${op.index}:
-${portLines}
-            h = handlers.get(${JSON.stringify(op.component)})
-            if h is None:
-                raise BehaviorFailure("UNKNOWN_COMPONENT", "component '${op.component}' has no handler (fail-closed)")
-            return h(ports, {"nodeId": ${JSON.stringify(op.id)}, "component": ${JSON.stringify(op.component)}})`;
-}
-/** dynamic 式に渡す scope 式（scope-free なら空 dict）。 */
-function pySeqScope(node, ctx) {
-    if (isScopeFree(node))
-        return "{}";
-    if (ctx.mapAs)
-        return ctx.mapAs.mscopeVar;
-    if (!ctx.scopeVar)
-        throw new Error("straight-line py: scope-reading expr in a scopeless component (analysis bug)");
-    return ctx.scopeVar;
-}
-/** 静的 ref の head を配線解決した python 式（ローカル直読み / input fallback / UNKNOWN_BINDING）。 */
-function pySeqRefHead(head, ctx) {
-    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 され得る: 未生成なら input の同名 key へ fall-through。
-            return `(${local} if ${ctx.okFlag.get(head)} else _sl_bind(input, ${JSON.stringify(head)}))`;
-        }
-    }
-    return `_sl_bind(input, ${JSON.stringify(head)})`;
-}
-/** 分類済み StaticExpr を python 式へ（逐次経路のネイティブ inline）。 */
-function pySeqStatic(e, ctx) {
-    switch (e.kind) {
-        case "str":
-            return lit(e.value);
-        case "bool":
-            return e.value ? "True" : "False";
-        case "null":
-            return "None";
-        case "ref": {
-            const head = pySeqRefHead(e.path[0], ctx);
-            if (e.path.length === 1)
-                return head;
-            const rest = e.path.slice(1).map((p) => JSON.stringify(p)).join(", ");
-            return `_sl_field(${JSON.stringify(e.opt ? "refOpt" : "ref")}, ${head}, [${rest}])`;
-        }
-        case "concat":
-            return `_sl_concat([${e.parts.map((p) => pySeqStatic(p, ctx)).join(", ")}])`;
-        case "dynamic":
-            return emitExpr(e.node, pySeqScope(e.node, ctx));
-    }
-}
-/** Expression IR → python 式（逐次経路）。 */
-function pySeqExpr(node, ctx) {
-    return pySeqStatic(classifyExpr(node), ctx);
-}
-/** node id 群 → 衝突しない決定的ローカル名。 */
-function allocLocals(prefix, ids) {
-    const out = new Map();
-    const taken = new Set();
-    ids.forEach((id, i) => {
-        let name = `${prefix}${sanitize(id)}`;
-        if (taken.has(name))
-            name = `${name}_${i}`;
-        taken.add(name);
-        out.set(id, name);
-    });
-    return out;
-}
-/** 未生成表現の python 式。 */
-function unproducedPy(relationKind) {
-    return `${CGP}.unproduced_value(${JSON.stringify(relationKind === "connection" ? "connection" : "single")})`;
-}
-/** policy 解釈（fail/retry → OP_FAILED、continue → skip）。plan.py と code/msg 一致。 */
-function pySeqPolicyRaise(errExpr, opId, meta, ind) {
-    if (meta.policy === "retry") {
-        return [
-            `${ind}raise PlanFailure("OP_FAILED", "operation '${opId}' failed under 'retry' policy (exhausted): %s" % (${errExpr},))`,
-        ];
-    }
-    return [`${ind}raise PlanFailure("OP_FAILED", "operation '${opId}' failed under 'fail' policy: %s" % (${errExpr},))`];
-}
-/** op 本体（ports 構築 + handler 呼び + policy 解釈 + 結果格納）を indent 付きで emit。 */
-function emitPySeqExec(op, plan, ctx, lines, ind) {
-    const i = op.index;
-    const meta = ctx.metas[i];
-    const o = plan.opsLiteral[i];
-    const id = o.id;
-    const local = ctx.local.get(id);
-    const canSkip = meta.canSkip || meta.alwaysSkip;
-    const store = (valueExpr, target, sind) => {
-        target.push(`${sind}${local} = ${valueExpr}`);
-        if (canSkip)
-            target.push(`${sind}${ctx.okFlag.get(id)} = True`);
-        if (ctx.scopeVar)
-            target.push(`${sind}${ctx.scopeVar}[${JSON.stringify(id)}] = ${local}`);
-    };
-    if (op.kind === "cond") {
-        const c = plan.component.body[i].cond;
-        const node = { cond: [c.if, c.then, c.else] };
-        store(emitExpr(node, pySeqScope(node, ctx)), lines, ind);
-        return;
-    }
-    if (op.kind === "map") {
-        emitPySeqMap(op, plan, ctx, lines, ind, store);
-        return;
-    }
-    // componentRef: ports 構築 → handler 呼び → policy 解釈。
-    const savedPos = ctx.currentPos;
-    const portsVar = `ports_${sanitize(id)}`;
-    if (op.ports.length === 0) {
-        lines.push(`${ind}${portsVar} = {}`);
-    }
-    else {
-        lines.push(`${ind}${portsVar} = {`);
-        for (const p of op.ports) {
-            const node = plan.component.body[i].ports[p.name];
-            lines.push(`${ind}    ${JSON.stringify(p.name)}: ${pySeqExpr(node, ctx)},`);
-        }
-        lines.push(`${ind}}`);
-    }
-    ctx.currentPos = savedPos;
-    const h = `h_${sanitize(id)}`;
-    const oc = `o_${sanitize(id)}`;
-    lines.push(`${ind}${h} = handlers.get(${JSON.stringify(op.component)})`);
-    lines.push(`${ind}if ${h} is None:`);
-    lines.push(`${ind}    raise BehaviorFailure("UNKNOWN_COMPONENT", "component '${op.component}' has no handler (fail-closed)")`);
-    lines.push(`${ind}${oc} = ${h}(${portsVar}, {"nodeId": ${JSON.stringify(id)}, "component": ${JSON.stringify(op.component)}})`);
-    if (meta.policy === "continue") {
-        lines.push(`${ind}if "error" not in ${oc}:`);
-        store(`${oc}["ok"]`, lines, `${ind}    `);
-    }
-    else {
-        lines.push(`${ind}if "error" in ${oc}:`);
-        lines.push(...pySeqPolicyRaise(`${oc}["error"]`, id, meta, `${ind}    `));
-        store(`${oc}["ok"]`, lines, ind);
-    }
-}
-/** emitPySeqMap — map ノードの逐次直線展開（python）。 */
-function emitPySeqMap(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 nodeId = JSON.stringify(op.id);
-    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 elVar = `_el_${s}`;
-    const mscopeVar = `_mscope_${s}`;
-    const overVar = `_over_${s}`;
-    const keptVar = `_kept_${s}`;
-    const collected = `_collected_${s}`;
-    const contFlag = meta.policy === "continue";
-    const skipVar = `_skip_${s}`;
-    const baseScopeExpr = ctx.scopeVar;
-    const mapCtx = { ...ctx, mapAs: { as: m.as, elVar, mscopeVar } };
-    lines.push(`${ind}${overVar} = ${pySeqExpr(m.over, ctx)}`);
-    lines.push(`${ind}if not isinstance(${overVar}, list):`);
-    lines.push(`${ind}    raise BehaviorFailure("MAP_OVER_NOT_ARRAY", "map '${id}': 'over' did not evaluate to an array")`);
-    lines.push(`${ind}${keptVar} = []`);
-    lines.push(`${ind}${collected} = []`);
-    if (contFlag)
-        lines.push(`${ind}${skipVar} = False`);
-    const mscopeLine = (ind2) => {
-        if (!mapNeedsScope)
-            return [];
-        const base = baseScopeExpr ?? "input";
-        return [`${ind2}${mscopeVar} = {**${base}, ${asKey}: ${elVar}}`];
-    };
-    const guardLine = (ind2) => {
-        if (guardIR === undefined)
-            return [];
-        return [`${ind2}if ${emitExpr(guardIR, isScopeFree(guardIR) ? "{}" : mscopeVar)} is not True:`, `${ind2}    continue`];
-    };
-    const portsExpr = (ind2) => {
-        if (op.ports.length === 0)
-            return "{}";
-        return `{\n${op.ports
-            .map((p) => `${ind2}    ${JSON.stringify(p.name)}: ${pySeqExpr(m.ports[p.name], mapCtx)},`)
-            .join("\n")}\n${ind2}}`;
-    };
-    const h = `_h_${s}`;
-    lines.push(`${ind}${h} = handlers.get(${comp})`);
-    lines.push(`${ind}if ${h} is None:`);
-    lines.push(`${ind}    raise BehaviorFailure("UNKNOWN_COMPONENT", "component '${op.component}' has no handler (fail-closed)")`);
-    if (op.batched) {
-        const items = `_items_${s}`;
-        lines.push(`${ind}${items} = []`);
-        lines.push(`${ind}for ${elVar}_i, ${elVar} in enumerate(${overVar}):`);
-        lines.push(...mscopeLine(`${ind}    `), ...guardLine(`${ind}    `));
-        lines.push(`${ind}    ${items}.append(${portsExpr(`${ind}    `)})`);
-        lines.push(`${ind}    ${keptVar}.append(${elVar}_i)`);
-        lines.push(`${ind}if ${items}:`);
-        const oc = `_mo_${s}`;
-        lines.push(`${ind}    ${oc} = ${h}({"items": ${items}}, {"nodeId": ${nodeId}, "component": ${comp}})`);
-        if (contFlag) {
-            lines.push(`${ind}    if "error" in ${oc}:`, `${ind}        ${skipVar} = True`, `${ind}    else:`);
-            lines.push(...batchOkPy(oc, collected, items, id, `${ind}        `));
-        }
-        else {
-            lines.push(`${ind}    if "error" in ${oc}:`);
-            lines.push(...pySeqPolicyRaise(`${oc}["error"]`, id, meta, `${ind}        `));
-            lines.push(...batchOkPy(oc, collected, items, id, `${ind}    `));
-        }
-    }
-    else {
-        lines.push(`${ind}for ${elVar}_i, ${elVar} in enumerate(${overVar}):`);
-        lines.push(...mscopeLine(`${ind}    `), ...guardLine(`${ind}    `));
-        const oc = `_mo_${s}`;
-        lines.push(`${ind}    ${oc} = ${h}(${portsExpr(`${ind}    `)}, {"nodeId": ${nodeId}, "component": ${comp}, "bound": ${elVar}})`);
-        if (contFlag) {
-            lines.push(`${ind}    if "error" in ${oc}:`, `${ind}        ${skipVar} = True`, `${ind}        break`);
-        }
-        else {
-            lines.push(`${ind}    if "error" in ${oc}:`);
-            lines.push(...pySeqPolicyRaise(`${oc}["error"]`, id, meta, `${ind}        `));
-        }
-        lines.push(`${ind}    ${collected}.append(${oc}["ok"])`, `${ind}    ${keptVar}.append(${elVar}_i)`);
-    }
-    const finish = [];
-    const fInd = contFlag ? `${ind}    ` : ind;
-    if (m.into === undefined) {
-        store(collected, finish, fInd);
-    }
-    else {
-        const aug = `_aug_${s}`;
-        finish.push(`${fInd}${aug} = []`);
-        finish.push(`${fInd}_mk_${s} = 0`);
-        finish.push(`${fInd}for _mj_${s}, _oel_${s} in enumerate(${overVar}):`);
-        finish.push(`${fInd}    if _mk_${s} < len(${keptVar}) and ${keptVar}[_mk_${s}] == _mj_${s}:`);
-        finish.push(`${fInd}        if not isinstance(_oel_${s}, dict):`);
-        finish.push(`${fInd}            raise BehaviorFailure("MAP_INTO_ELEMENT_NOT_OBJECT", "map '${id}': 'into' requires object elements (element %d is not an object)" % _mj_${s})`);
-        finish.push(`${fInd}        ${aug}.append({**_oel_${s}, ${JSON.stringify(m.into)}: ${collected}[_mk_${s}]})`);
-        finish.push(`${fInd}        _mk_${s} += 1`);
-        finish.push(`${fInd}    else:`);
-        finish.push(`${fInd}        ${aug}.append(_oel_${s})`);
-        store(aug, finish, fInd);
-    }
-    if (contFlag) {
-        lines.push(`${ind}if not ${skipVar}:`);
-        lines.push(...finish);
-    }
-    else {
-        lines.push(...finish);
-    }
-}
-/** batched handler の ok を collected へ（長さ整合検査つき）。 */
-function batchOkPy(oc, collected, items, id, ind) {
-    return [
-        `${ind}_r = ${oc}["ok"]`,
-        `${ind}if not isinstance(_r, list) or len(_r) != len(${items}):`,
-        `${ind}    raise BehaviorFailure("MAP_BATCH_RESULT_MISMATCH", "map '${id}': batched handler must return a list aligned to items (want %d)" % len(${items}))`,
-        `${ind}${collected} = _r`,
-    ];
-}
-/**
- * emitPySeqOp — 逐次直線化された 1 op の文列。policy 検証 → skip 判定（parent 連鎖 / bindField）→
- * 実行 → policy 解釈 → 結果ローカル格納（＋進行形 scope 書き足し）。
- */
-function emitPySeqOp(op, plan, ctx, lines) {
-    const i = op.index;
-    const meta = ctx.metas[i];
-    const o = plan.opsLiteral[i];
-    const id = o.id;
-    const local = ctx.local.get(id);
-    lines.push(`    # ── op '${id}' (${op.kind === "cond" ? "cond" : op.kind === "map" ? `map ${op.component}` : op.component}${o.policy ? `, policy ${JSON.stringify(o.policy)}` : ""}) ──`);
-    if (typeof meta.policy === "object") {
-        lines.push(`    raise PlanFailure("UNKNOWN_POLICY", ${JSON.stringify(`unknown policy kind: ${meta.policy.invalid}`)})`);
-        return;
-    }
-    const canSkip = meta.canSkip || meta.alwaysSkip;
-    if (canSkip)
-        lines.push(`    ${local} = None`, `    ${ctx.okFlag.get(id)} = False`);
-    if (meta.alwaysSkip) {
-        lines.push(`    # parent '${o.parent}' runs later — unconditional skip.`);
-        return;
-    }
-    const guards = [];
-    if (o.parent !== null) {
-        const pMeta = ctx.metas[o.parent];
-        if (pMeta.canSkip || pMeta.alwaysSkip)
-            guards.push(ctx.okFlag.get(plan.opsLiteral[o.parent].id));
-    }
-    if (o.bindField !== undefined && o.parent !== null) {
-        const pLocal = ctx.local.get(plan.opsLiteral[o.parent].id);
-        const bv = `_bv_${sanitize(id)}`;
-        const inner = [];
-        const ind = guards.length > 0 ? "        " : "    ";
-        inner.push(`${ind}if isinstance(${pLocal}, dict):`);
-        inner.push(`${ind}    ${bv} = ${pLocal}.get(${JSON.stringify(o.bindField)})`);
-        inner.push(`${ind}    if ${bv} is not None:`);
-        emitPySeqExec(op, plan, ctx, inner, `${ind}        `);
-        if (guards.length > 0) {
-            lines.push(`    if ${guards[0]}:`);
-            lines.push(...inner);
-        }
-        else {
-            lines.push(...inner);
-        }
-        return;
-    }
-    if (guards.length > 0) {
-        lines.push(`    if ${guards[0]}:`);
-        emitPySeqExec(op, plan, ctx, lines, "        ");
-        return;
-    }
-    emitPySeqExec(op, plan, ctx, lines, "    ");
-}
-/**
- * emitSequentialPyFn — 逐次 plan の component を素の文列として綴じる（bc#75 の核）。
- * run_plan / ops テーブル / _scope() snapshot / _exec closure / per-op ID 探索は無い。
- */
-function emitSequentialPyFn(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(`def run_${sanitize(plan.name)}(handlers, input):`);
-    if (needScope)
-        lines.push(`    scope = dict(input)`);
-    let unreachable = false;
-    for (const k of order.keys()) {
-        const opIdx = order[k];
-        ctx.currentPos = k;
-        if (unreachable)
-            break;
-        emitPySeqOp(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(`    if not ${okFlag.get(id)}:`);
-            lines.push(`        ${local.get(id)} = ${unproducedPy(plan.opsLiteral[i].relationKind)}`);
-            if (needScope)
-                lines.push(`        scope[${JSON.stringify(id)}] = ${local.get(id)}`);
-        }
-        lines.push(`    return ${pySeqExpr(plan.component.output, ctx)}`);
-    }
-    // 空関数体防止（unreachable かつ ops 空はあり得ないが、pass を保険で）。
-    if (lines.length === (needScope ? 2 : 1))
-        lines.push(`    pass`);
-    return lines.join("\n");
-}
-/**
- * emitPlanDrivenPyFn — 実並行 plan（複数 op の stage）の component を run_plan primitive で綴じる。
- * run_behavior の実行フロー（results 蓄積 + _scope + run_plan + 未生成書き戻し + output 評価）を
- * 生成コードに直線展開する。_scope snapshot は実並行の決定性のためこの経路だけが組む（bc#75）。
- */
-function emitComponentFn(plan) {
-    const arms = plan.ops.map(emitExecArm).join("\n");
-    const planLiteral = plan.component.plan ? emitDocLiteral(plan.component.plan, "py", 1) : "None";
-    const output = emitExpr(plan.component.output, SCOPE);
-    const relationKinds = plan.opsLiteral.map((o) => (o.relationKind === "connection" ? "connection" : "single"));
-    const relLit = "[" + relationKinds.map((r) => JSON.stringify(r)).join(", ") + "]";
-    return `def run_${sanitize(plan.name)}(handlers, input):
-    ops = ${emitOpsLiteral(plan)}
-    results = {}
-
-    def _scope():
-        return {**input, **results}
-
-    relation_kinds = ${relLit}
-
-    def _exec(op, _bound):
-        i = _op_index(ops, op["id"])
-${arms}
-        raise BehaviorFailure("UNKNOWN_NODE_KIND", "op '%s' has no generated exec arm (fail-closed)" % op["id"])
-
-    def _wrapped_exec(op, bound):
-        outcome = _exec(op, bound)
-        if "ok" in outcome:
-            results[op["id"]] = outcome["ok"]
-        return outcome
-
-    run = ${CGP}.run_plan(${planLiteral}, ops, _wrapped_exec)
-    for _i, _st in enumerate(run["states"]):
-        if _st is not None and _st.get("status") == "skipped":
-            results[ops[_i]["id"]] = ${CGP}.unproduced_value(relation_kinds[_i])
-    return ${output}`;
-}
-/** component 名を関数名に使える形へ（決定的。名前一意は DUPLICATE_COMPONENT で保証）。 */
-function sanitize(name) {
-    return name.replace(/[^A-Za-z0-9_]/g, "_");
-}
-function emitComponent(plan, _ctx) {
-    const order = sequentialOrder(plan.component);
-    if (order !== null)
-        return emitSequentialPyFn(plan, order);
-    planDrivenNeeded = true;
-    return emitComponentFn(plan);
-}
-/** RunPlan 経路（run_plan / _op_index / _wrapped_exec）が要るか（構造的トラッキング）。 */
-let planDrivenNeeded = false;
-function emitModule(plans, ctx) {
-    const { fingerprint, specVersions, componentNames, runtimeImport } = ctx;
-    const names = componentNames.map((n) => JSON.stringify(n)).join(", ");
-    const namesTuple = componentNames.length === 1 ? `(${names},)` : `(${names})`;
-    planDrivenNeeded = false; // 実 emit で確定させる（buildComponentPlan の先行 emit に依らない）。
-    const fns = plans.map((p) => emitComponent(p, ctx)).join("\n\n\n");
-    // _op_index（線形 op-id 探索）は RunPlan 経路だけが使う。逐次のみのモジュールには emit しない
-    // （bc#75 anti-sham gate: 逐次生成コードに線形探索の残渣を残さない）。
-    const opIndexHelper = planDrivenNeeded
-        ? `
-
-def _op_index(ops, op_id):
-    for i, o in enumerate(ops):
-        if o["id"] == op_id:
-            return i
-    return -1`
-        : "";
-    const dispatchArms = plans
-        .map((p) => `    if name == ${JSON.stringify(p.name)}:\n        return run_${sanitize(p.name)}(handlers, dict(input))`)
-        .join("\n");
-    return `# GENERATED by behavior-contracts common generator (bc#40, 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#40 A2): each
-# component is emitted as a native python function that drives the plan via the run_plan
-# primitive and evaluates every port + output either NATIVELY (concat -> python string
-# concat; ref/refOpt -> native scope/field access) or through the A0 expression-operator
-# primitives (#36) for overflow / short-circuit / fail-closed operators + injected handlers.
-# It does NOT go through run_behavior's tree-walk (no nodeKind dispatch / no eval_ports loop
-# / no generic exec). Scope: componentRef + cond + map (over/when/into/batched — bc#42 A3);
-# into is zip-attached inline (native, MAP_INTO_ELEMENT_NOT_OBJECT fail-closed). plan.concurrency is preserved: the
-# run_plan primitive dispatches same-stage independent ops up to plan.concurrency in flight
-# (ThreadPoolExecutor), matching run_behavior's parallel behavior (bc#42 AC#2). Handlers are
-# ALWAYS injected at the boundary.
-# The portable IR is NOT embedded: this module carries only IR_FINGERPRINT +
-# COMPONENT_NAMES, so interpreting the IR here is physically impossible. The fail-closed
-# skew gate lives on the consumer side: compare IR_FINGERPRINT against the fingerprint of
-# the live IR the consumer loaded.
-# irFingerprint: ${fingerprint}
-from ${runtimeImport} import SPEC_VERSIONS, BehaviorFailure, ExprFailure, PlanFailure, primitives as ${CGP}
-
-# Spec versions baked at generation time (fail-closed constant comparison at load).
-EXPECTED_SPEC_VERSIONS = {"behavior": ${specVersions.behavior}, "expression": ${specVersions.expression}, "plan": ${specVersions.plan}}
-
-# FNV-1a 64 fingerprint of the source portable IR (canonical_json discipline, #208),
-# computed at GENERATION time. The IR itself is not embedded — consumers compare this
-# constant against the fingerprint of the live IR they loaded (fail-closed skew gate).
-IR_FINGERPRINT = ${JSON.stringify(fingerprint)}
-
-# Component names exposed by bind(), in IR declaration order.
-COMPONENT_NAMES = ${namesTuple}
-
-
-def _check_generated_module():
-    # 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 _k, _want in EXPECTED_SPEC_VERSIONS.items():
-        _got = SPEC_VERSIONS.get(_k)
-        if _got != _want:
-            raise RuntimeError(
-                "behavior-contracts generated module: spec-version skew for '%s' "
-                "(generated=%s, runtime=%s) — regenerate against this runtime (fail-closed)"
-                % (_k, _want, _got)
-            )
-
-
-_check_generated_module()
-
-_MISSING = object()
-
-
-# ── native-ized simple-expression helpers (de-interpretation — NO evaluate tree-walk) ──
-# These statically unroll ref/refOpt/concat into native python, reproducing expr_eval.py's
-# fail-closed semantics EXACTLY (same Failure codes via ExprFailure — the semantics SSoT is
-# still one class). This is the Phase-B de-interpretation win: no recursive evaluate dispatch
-# and no per-node operator lookup for pure ref/concat ports.
-def _sl_ref(path, scope):
-    head = path[0]
-    if head not in scope:
-        raise ExprFailure("UNKNOWN_BINDING", "unknown binding: %s" % head)
-    cur = scope[head]
-    for seg in path[1:]:
-        if cur is None:
-            raise ExprFailure("NULL_REF", "null intermediate at .%s（?. を使う）" % seg)
-        if not isinstance(cur, dict):
-            raise ExprFailure("TYPE_MISMATCH", "cannot access .%s on %s" % (seg, _type_name(cur)))
-        got = cur.get(seg, _MISSING)
-        if got is _MISSING:
-            raise ExprFailure("MISSING_PROP", "missing property .%s" % seg)
-        cur = got
-    return cur
-
-
-def _sl_ref_opt(path, scope):
-    head = path[0]
-    if head not in scope:
-        raise ExprFailure("UNKNOWN_BINDING", "unknown binding: %s" % head)
-    cur = scope[head]
-    for seg in path[1:]:
-        if cur is None:
-            return None  # ?. null propagation
-        if not isinstance(cur, dict):
-            raise ExprFailure("TYPE_MISMATCH", "cannot access .%s on %s" % (seg, _type_name(cur)))
-        got = cur.get(seg, _MISSING)
-        if got is _MISSING:
-            raise ExprFailure("MISSING_PROP", "missing property .%s" % seg)
-        cur = got
-    return cur
-
-
-def _sl_concat(parts):
-    # n-ary (min 2). string-only (TYPE_MISMATCH otherwise) — matches expr_eval.py concat.
-    if len(parts) < 2:
-        raise ExprFailure("INVALID_NODE", "concat expects >= 2 args, got %d" % len(parts))
-    for p in parts:
-        if not isinstance(p, str):
-            raise ExprFailure("TYPE_MISMATCH", "concat: string のみ（got %s）" % _type_name(p))
-    return "".join(parts)
-
-
-def _type_name(v):
-    # expr_eval.py _type_name: JS-flavored type names for parity of messages.
-    if v is None:
-        return "null"
-    if isinstance(v, bool):
-        return "boolean"
-    if isinstance(v, str):
-        return "string"
-    if isinstance(v, (int, float)):
-        return "number"
-    if isinstance(v, list):
-        return "array"
-    return "object"
-${opIndexHelper}
-
-
-# ── sequential-path static-wiring helpers (bc#75) — no scope snapshots ─────
-# _sl_bind reads a scope-bound head directly; _sl_field walks a static path over an
-# already-resolved head local (the head is a local read, not a scope walk). Same
-# ExprFailure codes as expr_eval.py.
-def _sl_bind(scope, head):
-    if head not in scope:
-        raise ExprFailure("UNKNOWN_BINDING", "unknown binding: %s" % head)
-    return scope[head]
-
-
-def _sl_field(op, cur, path):
-    for seg in path:
-        if cur is None:
-            if op == "refOpt":
-                return None
-            raise ExprFailure("NULL_REF", "null intermediate at .%s（?. を使う）" % seg)
-        if not isinstance(cur, dict):
-            raise ExprFailure("TYPE_MISMATCH", "cannot access .%s on %s" % (seg, _type_name(cur)))
-        got = cur.get(seg, _MISSING)
-        if got is _MISSING:
-            raise ExprFailure("MISSING_PROP", "missing property .%s" % seg)
-        cur = got
-    return cur
-
-
-# ── straight-line component functions (no run_behavior tree-walk) ───────────────────
-${fns}
-
-
-def bind(handlers):
-    """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 run_plan primitive + per-node native/primitive port eval + injected handler) —
-    NOT the run_behavior tree-walk. Observationally equivalent to the run_behavior path:
-    same values, same emitted op sequence, same Failure code/message."""
-
-    def _make(name):
-        def _call(input=None):
-            return _dispatch(name, handlers, dict(input or {}))
-
-        return _call
-
-    return {name: _make(name) for name in COMPONENT_NAMES}
-
-
-def _dispatch(name, handlers, input):
-${dispatchArms}
-    raise BehaviorFailure("UNKNOWN_ENTRY", "component '%s' not found in this module (fail-closed)" % name)
-`;
-}
-const dialect = {
-    emitExpr,
-    mapScopeVar: MAP_SCOPE,
-    emitComponent,
-    emitModule,
-};
-function emit(_ctx) {
-    // bc no-ir invariant: python の straight-line codegen は **未サポート**。これは IR を埋め込み
-    // インタプリタに委譲していた初期プロトタイプで、実 consumer 経路ではない（python ランタイムは
-    // `ir`/interpret exec surface を使う）。fake/半 native な codegen を出す代わりに loud に拒否する。
-    // 本物の脱解釈 codegen は rust/go/ts のみ。機構は将来の native 化に備えて配線ごと残す（void 参照）。
-    void [dialect, emitStraightlineModule, SCOPE];
-    throw new Error("straight-line codegen is not supported for python (bc no-ir: not de-interpreted) — " +
-        "use the ir/interpret exec surface, or generate rust/go/ts codegen");
-}
-/**
- * pythonStraightlineEmitter — 言語識別子 `"python-straightline"` の emitter plugin。
- * 既存の `python`（リテラル焼き込み・endpoint 3-literal → run_behavior）と併存する additive な
- * 第2モード（単純式を native 化し `evaluate` 解釈を消す脱解釈経路 — typed-codegen.md §4.1）。
- */
-export const pythonStraightlineEmitter = {
-    language: "python-straightline",
-    fileExtension: ".py",
-    defaultRuntimeImport: "behavior_contracts",
-    filenameHint: "behaviors.straightline.generated.py",
-    emit,
-};
-//# sourceMappingURL=emit-straightline-python.js.map