behavior-contracts 0.5.0 → 0.7.0

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

@@ -1,1155 +0,0 @@
-import { GeneratorFailure } from "./core.js";
-import { buildTypePlan, deriveTypeRef, findDecl, } from "./typed.js";
-import { rustStraightlineEmitter, rustStraightlineInternals, setRustForceRunPlanImports } from "./emit-straightline-rust.js";
-import { buildComponentPlan } from "./straightline.js";
-/** primitive namespace（straight-line と共有）。 */
-const P = rustStraightlineInternals.P;
-/** struct-native exec の port scope 式（input params のみ — node-result Value scope は組まない）。 */
-const PORT_SCOPE = "port_scope()";
-// ── Rust typed materializer（TypedMaterializer seam の Rust 具体化 — 拡張 hook 実装）────
-/** 可搬スカラ → Rust の具体型名（de-box 後の struct field 型）。int=i64 / float=f64 で区別。 */
-function rustScalar(scalar) {
-    switch (scalar) {
-        case "string":
-            return "String";
-        case "int":
-            return "i64";
-        case "float":
-            return "f64";
-        case "bool":
-            return "bool";
-        case "null":
-            // null 単独型は Rust に無いので Value（Null のみ格納）。opt でラップされて現れるのが通常。
-            return "Value";
-    }
-}
-/** TypeRef を Rust の具体型名へ（named→struct 名、arr→Vec、opt→Option、scalar→具体型）。 */
-function renderTypeRef(ref) {
-    switch (ref.kind) {
-        case "scalar":
-            return rustScalar(ref.scalar);
-        case "opt":
-            // nullable は Rust の Option で表す（None = null）。
-            return `Option<${renderTypeRef(ref.inner)}>`;
-        case "arr":
-            return `Vec<${renderTypeRef(ref.elem)}>`;
-        case "named":
-            return ref.name;
-    }
-}
-/** wire field 名 → Rust の struct field 名（決定的・安全化）。元名は struct コメント/marshaller で保持。 */
-function rustFieldName(wire) {
-    // 非識別子文字は `_`。先頭が数字なら `f_` を前置。予約語衝突は `r#` で回避（raw identifier）。
-    let safe = wire.replace(/[^A-Za-z0-9_]/g, "_");
-    if (/^[0-9]/.test(safe))
-        safe = `f_${safe}`;
-    if (safe.length === 0)
-        safe = "f_";
-    if (RUST_KEYWORDS.has(safe))
-        return `r#${safe}`;
-    return safe;
-}
-/** field 名衝突を避けるための Rust 予約語（raw identifier 化する）。 */
-const RUST_KEYWORDS = new Set([
-    "as", "break", "const", "continue", "crate", "dyn", "else", "enum", "extern", "false", "fn",
-    "for", "if", "impl", "in", "let", "loop", "match", "mod", "move", "mut", "pub", "ref", "return",
-    "self", "Self", "static", "struct", "super", "trait", "true", "type", "unsafe", "use", "where",
-    "while", "async", "await", "abstract", "become", "box", "do", "final", "macro", "override",
-    "priv", "typeof", "unsized", "virtual", "yield", "try", "union",
-]);
-/** string を Rust 文字列リテラルへ。 */
-function rustStrLit(s) {
-    return JSON.stringify(s);
-}
-/** 単一 char を Rust の char リテラルへ（`'x'`）。特殊文字はエスケープ。 */
-function rustCharLit(ch) {
-    if (ch === "'")
-        return "'\\''";
-    if (ch === "\\")
-        return "'\\\\'";
-    if (ch === "\n")
-        return "'\\n'";
-    if (ch === "\r")
-        return "'\\r'";
-    if (ch === "\t")
-        return "'\\t'";
-    // 制御文字/非 ASCII 印字外は \u{..} エスケープ、その他はそのまま（Rust の char リテラルは Unicode スカラ値）。
-    const cp = ch.codePointAt(0);
-    if (cp < 0x20 || cp === 0x7f)
-        return `'\\u{${cp.toString(16)}}'`;
-    return `'${ch}'`;
-}
-/**
- * TypeRef が Rust の `Default` を導出可能か（null 単独型は `Value` に落ち Default 非実装 → false）。
- * scalar(non-null)/opt/arr は常に Default 導出可、named は各 field が導出可なら導出可、arr/opt はラップ先に依存。
- */
-function isDefaultable(ref, plan) {
-    switch (ref.kind) {
-        case "scalar":
-            return ref.scalar !== "null"; // null → Value（Default 非実装）
-        case "opt":
-            return true; // Option<T> は常に None default
-        case "arr":
-            return true; // Vec<T> は常に空 default
-        case "named": {
-            const decl = findDecl(plan, ref.name);
-            return decl ? decl.fields.every((f) => isDefaultable(f.type, plan)) : false;
-        }
-    }
-}
-/** 型プランの named obj を Rust struct 宣言へ（decls 順＝決定的）。field は宣言順。 */
-function emitTypeDecls(plan) {
-    if (plan.decls.length === 0)
-        return "";
-    return plan.decls
-        .map((d) => {
-        const fields = d.fields
-            .map((f) => `    ${rustFieldName(f.name)}: ${renderTypeRef(f.type)}, // ${JSON.stringify(f.name)}`)
-            .join("\n");
-        // Clone: struct field 直参照で output に clone するため。Default: cell の初期値（RefCell::new）用。
-        // 全 field が Default 導出可能なら `#[derive(Default)]`（clippy::derivable_impls 対応）。null 単独型
-        // （Value・Default 非実装）を持つ struct だけは手書き Default を emitDefaults() で綴じる（そこでは
-        // 導出不能なので derivable_impls は発火しない）。生成 struct は output で全 field が読まれるとは限らない → dead_code 許容。
-        const derives = isDefaultable({ kind: "named", name: d.name }, plan) ? "Clone, Default" : "Clone";
-        return `#[derive(${derives})]\n#[allow(dead_code)]\nstruct ${d.name} {\n${fields}\n}`;
-    })
-        .join("\n\n");
-}
-/**
- * emitMarshallers — 各 named struct の raw→typed marshaller（§4.4）。動的 `&Value`（`Value::Obj` 期待）を
- * 受け、各 field を typed に読み出して具体 struct を組む。generic Value 走査を exec 経路から除去する de-box の実体。
- * field 型ごとに再帰: named→marshal_T*、arr→要素ループ、opt→null 分岐、scalar→型 match。
- */
-function emitMarshallers(plan) {
-    if (plan.decls.length === 0)
-        return "";
-    return plan.decls.map((d) => emitOneMarshaller(d, plan)).join("\n\n");
-}
-function emitOneMarshaller(d, plan) {
-    const lines = [];
-    // 型プランは全 struct に marshaller を emit するが、named struct が exec で 1 度も handler 結果として
-    // 現れない vector（例: outputType 専用の合成 struct）では未使用になり得る → dead_code 許容（生成ツールキット）。
-    lines.push(`#[allow(dead_code)]`);
-    lines.push(`fn marshal_${d.name}(raw: &Value) -> Result<${d.name}, BehaviorError> {`);
-    lines.push(`    let pairs = match raw {`);
-    lines.push(`        Value::Obj(p) => p,`);
-    lines.push(`        other => return Err(marshal_type_error(${rustStrLit(`typed marshal ${d.name}: expected obj, got `)}, other.type_name())),`);
-    lines.push(`    };`);
-    const fieldInits = [];
-    for (const f of d.fields) {
-        const fieldVar = `field_${rustFieldName(f.name).replace(/^r#/, "")}`;
-        const keyLit = rustStrLit(f.name);
-        lines.push(`    let ${fieldVar} = {`);
-        lines.push(`        let fv = match pairs.iter().find(|(k, _)| k == ${keyLit}) {`);
-        lines.push(`            Some((_, v)) => v,`);
-        lines.push(`            None => return Err(marshal_missing_prop(${rustStrLit(`typed marshal ${d.name}: missing property .`)}, ${keyLit})),`);
-        lines.push(`        };`);
-        lines.push(indentBlock(emitFieldMaterialize("fv", f.type, plan), 2));
-        lines.push(`    };`);
-        fieldInits.push(`        ${rustFieldName(f.name)}: ${fieldVar},`);
-    }
-    lines.push(`    Ok(${d.name} {`);
-    lines.push(...fieldInits);
-    lines.push(`    })`);
-    lines.push(`}`);
-    return lines.join("\n");
-}
-/** テキストブロックを indent 段（4 space/段）だけ字下げする。 */
-function indentBlock(block, levels) {
-    const pad = "    ".repeat(levels);
-    return block
-        .split("\n")
-        .map((l) => (l.length === 0 ? l : pad + l))
-        .join("\n");
-}
-/**
- * emitFieldMaterialize — `src` (`&Value` 式) を型 `ref` の具体 typed 値へ materialize する Rust **式**を返す
- * （末尾式・値を返す block）。scalar は型 match、named は marshal_T* 呼び（`?`）、arr は要素ループ、
- * opt は null 分岐（Option）。すべて具体 Rust 型で組む（de-box）。fail は marshaller helper（BehaviorError）。
- */
-function emitFieldMaterialize(src, ref, plan) {
-    switch (ref.kind) {
-        case "scalar": {
-            if (ref.scalar === "null") {
-                // null 単独型は Value のまま保持（clone）。
-                return `${src}.clone()`;
-            }
-            const variant = ref.scalar === "int" ? "Int" : ref.scalar === "float" ? "Float" : ref.scalar === "bool" ? "Bool" : "Str";
-            // Str は clone（所有 String）、その他は Copy。
-            const bind = ref.scalar === "string" ? "s.clone()" : "*s";
-            return [
-                `match ${src} {`,
-                `    Value::${variant}(s) => ${bind},`,
-                `    other => return Err(marshal_type_error(${rustStrLit(`typed marshal: expected ${ref.scalar}, got `)}, other.type_name())),`,
-                `}`,
-            ].join("\n");
-        }
-        case "named": {
-            return `marshal_${ref.name}(${src})?`;
-        }
-        case "arr": {
-            const elemTy = renderTypeRef(ref.elem);
-            const inner = emitFieldMaterialize("elem_raw", ref.elem, plan);
-            return [
-                `match ${src} {`,
-                `    Value::Arr(items) => {`,
-                `        let mut out: Vec<${elemTy}> = Vec::with_capacity(items.len());`,
-                `        for elem_raw in items.iter() {`,
-                `            let elem_out = ${indentBlock(inner, 3).trimStart()};`,
-                `            out.push(elem_out);`,
-                `        }`,
-                `        out`,
-                `    }`,
-                `    other => return Err(marshal_type_error(${rustStrLit("typed marshal: expected arr, got ")}, other.type_name())),`,
-                `}`,
-            ].join("\n");
-        }
-        case "opt": {
-            const inner = emitFieldMaterialize("inner_raw", ref.inner, plan);
-            return [
-                `match ${src} {`,
-                `    Value::Null => None,`,
-                `    inner_raw => {`,
-                `        let inner_out = ${indentBlock(inner, 2).trimStart()};`,
-                `        Some(inner_out)`,
-                `    }`,
-                `}`,
-            ].join("\n");
-        }
-    }
-}
-/**
- * materializeExpr — raw な `&Value` 式 `rawExpr` を型 `ref` の具体 typed 値へ変換する **単一式**（exec 経路の
- * de-box）。named→`marshal_T*(...)?`、scalar/arr/opt→インライン材化 block。呼び側が typed ローカルへ束ねる。
- * これが seam の runtime-materialization hook の Rust 実装本体（go の同型 hook）。
- */
-function materializeExpr(rawExpr, ref, plan) {
-    // 参照式（`&x`）を受ける前提に統一するため、marshaller/材化 block はいずれも `&Value` を読む。
-    if (ref.kind === "named")
-        return `marshal_${ref.name}(${rawExpr})?`;
-    // scalar/arr/opt は emitFieldMaterialize の block を使う（式として評価される）。
-    return `{ let __src = ${rawExpr}; ${emitFieldMaterialize("__src", ref, plan).replace(/\n/g, " ")} }`;
-}
-/**
- * typedFieldAccess — typed base 式 `baseExpr`（型 `baseRef`）に field path を **struct field 直参照**で辿る。
- * map/obj_get lookup ではなく `.field` 連結（＝de-box されている証拠）。辿り着いた TypeRef も返す。
- */
-function typedFieldAccess(baseExpr, baseRef, fields, plan) {
-    let expr = baseExpr;
-    let ref = baseRef;
-    for (const f of fields) {
-        if (ref.kind !== "named") {
-            throw new Error(`typed rust: field access '.${f}' on non-struct TypeRef ${JSON.stringify(ref)}`);
-        }
-        const decl = findDecl(plan, ref.name);
-        const fld = decl?.fields.find((x) => x.name === f);
-        if (!fld)
-            throw new Error(`typed rust: field '${f}' not found on struct ${ref.name}`);
-        expr = `${expr}.${rustFieldName(f)}`; // struct field 直参照（map lookup でない）
-        ref = fld.type;
-    }
-    return { expr, ref };
-}
-/**
- * serializeTyped — 具体 typed 値式を canonical 直列化用の動的 Value へ戻す式（観測等価 pin）。exec は
- * typed のまま進み、component 境界でだけ Value 化して golden と突き合わせる。named→ser_T*、scalar→Value::variant、
- * arr→要素 ser の map collect、opt→None/Some 分岐。式一発で返す。`typedExpr` は所有値（by-value）想定。
- */
-function serializeTyped(typedExpr, ref, plan) {
-    switch (ref.kind) {
-        case "named":
-            return `ser_${ref.name}(${typedExpr})`;
-        case "scalar": {
-            switch (ref.scalar) {
-                case "string":
-                    return `Value::Str(${typedExpr})`;
-                case "int":
-                    return `Value::Int(${typedExpr})`;
-                case "float":
-                    return `Value::Float(${typedExpr})`;
-                case "bool":
-                    return `Value::Bool(${typedExpr})`;
-                case "null":
-                    // null 単独型は Value をそのまま（clone 済みで保持）。
-                    return `${typedExpr}`;
-            }
-            break;
-        }
-        case "arr": {
-            const elemTy = renderTypeRef(ref.elem);
-            return `Value::Arr(${typedExpr}.into_iter().map(|e: ${elemTy}| ${serializeTyped("e", ref.elem, plan)}).collect())`;
-        }
-        case "opt":
-            return `match ${typedExpr} { Some(inner) => ${serializeTyped("inner", ref.inner, plan)}, None => Value::Null }`;
-    }
-    throw new Error(`typed rust: serializeTyped fell through for ${JSON.stringify(ref)}`);
-}
-export const rustTypedMaterializer = {
-    emitTypeDecls,
-    renderTypeRef,
-    emitMarshallers,
-    materializeExpr,
-    typedFieldAccess,
-    serializeTyped,
-};
-// ── serializer helper（named struct → Value）を型プランから emit ────────────────────
-/** 各 named struct を canonical Value（Obj, field は宣言順）へ戻す `ser_T*` を emit（by-value consume）。 */
-function emitSerializers(plan) {
-    return plan.decls
-        .map((d) => {
-        const sets = d.fields
-            .map((f) => `        (${rustStrLit(f.name)}.to_string(), ${serializeTyped(`v.${rustFieldName(f.name)}`, f.type, plan)}),`)
-            .join("\n");
-        // 型プランは全 struct に serializer を emit するが、output が named struct を丸ごと返さない vector では
-        // 未使用になり得る（scalar output 等） → dead_code 許容（生成ツールキット）。
-        return `#[allow(dead_code)]\nfn ser_${d.name}(v: ${d.name}) -> Value {\n    Value::Obj(vec![\n${sets}\n    ])\n}`;
-    })
-        .join("\n\n");
-}
-// ── struct-native runner（実 exec 経路 — 実 de-box）─────────────────────────────────
-/** 生成コード内の typed ローカル cell 名（materialize 済み struct を RefCell で保持）。 */
-function typedCell(nodeId) {
-    return `cell_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
-}
-/** `ref` の path 配列（Expression IR）を取り出す。単純 ref ノードでなければ undefined。 */
-function refPathOf(node) {
-    if (node === null || typeof node !== "object" || Array.isArray(node))
-        return undefined;
-    const keys = Object.keys(node);
-    if (keys.length !== 1 || keys[0] !== "ref")
-        return undefined;
-    const path = node.ref;
-    if (!Array.isArray(path) || !path.every((p) => typeof p === "string"))
-        return undefined;
-    return path;
-}
-/**
- * emitTypedValue — output（Φ 合流式）IR を、期待型 `expected` の **具体 Rust typed 値**式へ再帰 lower し、
- * `{ expr, ref }` を返す。これが AC の「exec が具体 struct を保持」の実体（go と同型）:
- *   - `{ref:[typedNode, …fields]}` → typed struct field 直参照（typedFieldAccess — map lookup でない。struct は clone）。
- *   - `{ref:[input/非 typed node]}` → 型付け不能な生 Value。expected があれば materialize（de-box）。
- *   - `{obj:{…}}` → 具体 struct literal（expected が named のとき各 field を期待型で lower）。
- *   - `{arr:[…]}` → 具体 Vec literal（要素は要素型で lower）。
- *   - scalar literal → 具体 Rust 値。
- *   - concat → de-box された typed 値で native String 連結（意味論保存）。他演算子は LOUD fail-closed。
- */
-function emitTypedValue(node, expected, typedNodes, plan) {
-    const path = refPathOf(node);
-    if (path && path.length >= 1) {
-        const head = path[0];
-        if (typedNodes.has(head)) {
-            // typed node への参照: cell から struct を借りて field 直参照で辿る（de-box された struct access）。
-            const baseRef = typedNodes.get(head);
-            // struct を所有値として取り出す（cell.borrow().clone()）。field access は clone 済みの struct に対して行う。
-            // bare な Copy スカラ node（int/float/bool、以降の field path 無し）は `.clone()` が clippy::clone_on_copy
-            // を踏むので deref-copy（`*cell.borrow()`）で取り出す（意味論同値、clippy-clean — bc#49 B3）。
-            const isBareCopyScalar = path.length === 1 &&
-                baseRef.kind === "scalar" &&
-                (baseRef.scalar === "int" || baseRef.scalar === "float" || baseRef.scalar === "bool");
-            const base = isBareCopyScalar
-                ? `*${typedCell(head)}.borrow()`
-                : `${typedCell(head)}.borrow().clone()`;
-            const { expr, ref } = typedFieldAccess(base, baseRef, path.slice(1), plan);
-            return { expr, ref };
-        }
-        // input param 参照（非 typed node）: input Value を局所的に読み、expected へ materialize（de-box）。
-        // 動的 Value tree の再構築ではなく input 境界値の 1 leaf 読み（許容される局所変換）。
-        if (expected)
-            return { expr: materializeExpr(`&${inputRead(path)}`, expected, plan), ref: expected };
-        return { expr: inputRead(path), ref: undefined };
-    }
-    if (node !== null && typeof node === "object" && !Array.isArray(node)) {
-        const keys = Object.keys(node);
-        if (keys.length === 1 && keys[0] === "obj" && expected && expected.kind === "named") {
-            // 具体 struct literal を組む（de-box した output assembly）。
-            const decl = findDecl(plan, expected.name);
-            const fields = node.obj;
-            const inits = decl.fields.map((f) => {
-                const sub = emitTypedValue(fields[f.name], f.type, typedNodes, plan);
-                return `${rustFieldName(f.name)}: ${sub.expr}`;
-            });
-            return { expr: `${expected.name} { ${inits.join(", ")} }`, ref: expected };
-        }
-        if (keys.length === 1 && keys[0] === "arr" && expected && expected.kind === "arr") {
-            const elems = node.arr;
-            const elemTy = renderTypeRef(expected.elem);
-            const items = elems.map((e) => emitTypedValue(e, expected.elem, typedNodes, plan).expr);
-            return { expr: `{ let v: Vec<${elemTy}> = vec![${items.join(", ")}]; v }`, ref: expected };
-        }
-        // concat 演算子: operand を **de-box された typed 値**（typed field access なら concrete String）で
-        // 読み、native String 連結する（rust-straightline の concat_native と同じ native 化パターン — 意味論保存）。
-        if (keys.length === 1 && keys[0] === "concat" && expected && expected.kind === "scalar" && expected.scalar === "string") {
-            const parts = node.concat;
-            // 各 part を push_str へ渡す `&str` 式に落とす。bare 文字列リテラルは `"..."`（str slice）を直接渡し
-            // （clippy::unnecessary_to_owned 回避 — `&("x".to_string())` にしない）、それ以外（field access で得た
-            // concrete String など）は `&(expr)` で借用する。いずれも native String 連結（意味論保存）。
-            const pushes = parts.map((p) => {
-                if (typeof p === "string") {
-                    // 1 文字リテラルは push(char)（clippy::single_char_add_str 回避）、それ以外は push_str(str slice)。
-                    const chars = [...p];
-                    if (chars.length === 1)
-                        return `__s.push(${rustCharLit(chars[0])});`;
-                    return `__s.push_str(${rustStrLit(p)});`;
-                }
-                const sub = emitTypedValue(p, { kind: "scalar", scalar: "string" }, typedNodes, plan);
-                return `__s.push_str(&(${sub.expr}));`;
-            });
-            return {
-                expr: `{ let mut __s = String::new(); ${pushes.join(" ")} __s }`,
-                ref: expected,
-            };
-        }
-        // その他単一キー = 別演算子（add/eq/…）: struct-native exec では動的 Value output tree を組まない方針
-        // ゆえ LOUD fail-closed（bc typed corpus には output 位置の非 concat 演算子が無い。go と一致）。
-        if (keys.length === 1) {
-            throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust-typed struct-native output: operator '${keys[0]}' at the output position is not supported in the struct-native de-box path yet (typed corpus covers only ref / obj / arr / concat outputs). Do not fall back to building the dynamic Value output tree.`);
-        }
-    }
-    // scalar literal（typed operand として現れる bare リテラル）: 具体 Rust スカラ。
-    if (expected && expected.kind === "scalar") {
-        return { expr: litScalar(node, expected.scalar), ref: expected };
-    }
-    return { expr: litScalarUnknown(node), ref: undefined };
-}
-/** input/非 typed node の scope 読み（動的 Value 式）。input params のみを持つ port_scope() から 1 leaf。 */
-function inputRead(path) {
-    return `input_ref(&[${path.map(rustStrLit).join(", ")}], &${PORT_SCOPE})`;
-}
-/** 期待スカラの Rust リテラル（string/int/float/bool/null）。 */
-function litScalar(node, scalar) {
-    if (scalar === "string" && typeof node === "string")
-        return `${rustStrLit(node)}.to_string()`;
-    if (scalar === "bool" && typeof node === "boolean")
-        return node ? "true" : "false";
-    if (scalar === "int") {
-        if (node !== null && typeof node === "object" && typeof node.int === "string")
-            return `${node.int}i64`;
-        if (typeof node === "number")
-            return `${node}i64`;
-    }
-    if (scalar === "float") {
-        if (node !== null && typeof node === "object" && typeof node.float === "number")
-            return `${node.float}f64`;
-        if (typeof node === "number")
-            return `${node}f64`;
-    }
-    if (scalar === "null")
-        return "Value::Null";
-    throw new Error(`typed rust: scalar literal ${JSON.stringify(node)} does not match expected ${scalar}`);
-}
-function litScalarUnknown(node) {
-    if (node === null)
-        return "Value::Null";
-    if (typeof node === "boolean")
-        return node ? "Value::Bool(true)" : "Value::Bool(false)";
-    if (typeof node === "string")
-        return `Value::Str(${rustStrLit(node)}.to_string())`;
-    return "Value::Null";
-}
-/**
- * emitTypedRunner — 1 typed component の **struct-native exec**（bc#47 rework: LAYERED でなく実 de-box）。
- *
- * plan/handler-dispatch の SSoT は再利用する（`run_plan` primitive + `handlers.exec_ctx`。意味論は二重実装
- * しない）。ただし exec closure は、handler 結果（生 Value mock；graphddb #60 では raw）を **その場で
- * outType struct へ marshal**（raw→typed 境界）し、struct を typed cell（RefCell）へ格納する。生 Value を
- * results Vec へ入れることは**しない**。port 式は input params だけを持つ port_scope() で評価する。component
- * `output` は typed struct への **struct field 直参照** ＋ struct/Vec literal で組み、最終 return 境界で **1 回だけ**
- * Value へ serialize する（動的 Value output tree は組まない）。overflow/短絡 operator は A0 primitive SSoT のまま。
- *
- * map/cond を含む typed component は struct-native exec のスコープ外（LOUD fail-closed。graphddb #60 / follow-up）。
- */
-function emitTypedRunner(comp, plan) {
-    const fn = rustStraightlineInternals.sanitize(comp.name);
-    // struct-native scope を組むため、port 式は port_scope()（input params のみ）で emit する。
-    const cplan = buildComponentPlan(comp, rustStraightlineInternals.dialect, PORT_SCOPE);
-    // typed node（componentRef / map / cond で outType を持つもの）を index 化。map の node 結果型は
-    // {arr:elemType}（collected/augmented list）、cond は選択枝の合流型。いずれも struct 空間で保持する。
-    const typedNodes = collectTypedNodes(comp, plan);
-    // 各 typed node の struct cell 宣言（RefCell で。marshal 後に struct を書き込む）。
-    const cellDecls = [...typedNodes.entries()]
-        .map(([id, ref]) => `    let ${typedCell(id)}: RefCell<${renderTypeRef(ref)}> = RefCell::new(Default::default());`)
-        .join("\n");
-    // #74: a child/relation node port may reference a PARENT typed node's field
-    // (e.g. GSI1PK = "USER#" + ref(["root","userId"])). port_scope must expose the accumulated typed
-    // node results (the struct-space analogue of the straight-line base_scope), serialized from the
-    // struct cells on demand — otherwise the ref hits UNKNOWN_BINDING and the key binds empty,
-    // diverging from run_behavior. Node results stay in the cells (no persistent dynamic Value scope);
-    // a produced-flag (Cell<bool>) gates serialization so only ancestors that already ran are exposed.
-    // run_plan visits parents before children, so a node's ref only reads an already-produced ancestor.
-    const producedCell = (id) => `__produced_${id.replace(/[^A-Za-z0-9_]/g, "_")}`;
-    const producedDecls = [...typedNodes.keys()]
-        .map((id) => `    let ${producedCell(id)}: std::cell::Cell<bool> = std::cell::Cell::new(false);`)
-        .join("\n");
-    const portScopeNodeInjections = [...typedNodes.entries()]
-        .map(([id, ref]) => {
-        // Own the cell's struct/scalar the same way the output assembly reads it (clone for
-        // struct/arr/opt/string; deref-copy for Copy scalars to stay clippy-clean), then serialize.
-        const isBareCopyScalar = ref.kind === "scalar" && (ref.scalar === "int" || ref.scalar === "float" || ref.scalar === "bool");
-        const owned = isBareCopyScalar ? `*${typedCell(id)}.borrow()` : `${typedCell(id)}.borrow().clone()`;
-        const ser = serializeTyped(owned, ref, plan);
-        return `            if ${producedCell(id)}.get() {\n                s.push((${rustStrLit(id)}.to_string(), ${ser}));\n            }`;
-    })
-        .join("\n");
-    const arms = cplan.ops.map((op) => emitTypedExecArm(op, comp.name, typedNodes, plan, producedCell)).join("\n");
-    // handler を 1 度も呼ばない typed component（cond のみ等）では `handlers` を `_handlers` に（unused-variables
-    // 回避）。componentRef と map（要素/batched handler）は handler を呼ぶ。
-    const usesHandlers = cplan.ops.some((o) => o.kind === "componentRef" || o.kind === "map");
-    const handlerParam = usesHandlers ? "handlers" : "_handlers";
-    const planExpr = comp.plan
-        ? rustStraightlineInternals.emitPlanLiteral(comp.plan)
-        : "None";
-    // output を struct で組み立てて 1 回だけ serialize（動的 Value output tree は組まない）。
-    const outRef = comp.outputType !== undefined ? deriveTypeRef(comp.outputType, plan) : undefined;
-    const out = emitTypedValue(comp.output, outRef, typedNodes, plan);
-    const outRefFinal = out.ref ?? outRef;
-    const serialized = outRefFinal ? serializeTyped("__typed_out", outRefFinal, plan) : "__typed_out";
-    const opsLiteral = rustStraightlineInternals.emitOpsLiteral(cplan);
-    return `// run_typed_${fn} — STRUCT-NATIVE exec (bc#48 de-box): the plan is driven by the run_plan
-// primitive (plan SSoT) with per-node exec arms that marshal the handler result DIRECTLY into the
-// node's outType struct at the boundary and store the STRUCT in a typed cell (RefCell<T*>) — the
-// dynamic Value node-result scope (Vec<(String, Value)> results) and the Value output tree are
-// NEVER built. Downstream ref/field access reads the structs (.field, not obj_get); the output is
-// assembled as a struct and serialized to a Value ONLY at the final return boundary.
-// Called by Bind for '${comp.name}'. (bc handlers return a Value mock = the raw->typed boundary; in
-// graphddb #60 the handler returns raw and the same marshal-at-boundary keeps it struct-native.)
-fn run_typed_${fn}<H: ComponentExec>(
-    ${handlerParam}: &mut H,
-    input: &[(String, Value)],
-) -> Result<Value, BehaviorError> {
-    let ops: Vec<OpSpec> = ${opsLiteral};
-${cellDecls ? cellDecls + "\n" : ""}${producedDecls ? producedDecls + "\n" : ""}    // port_scope = input params + accumulated PRODUCED typed node results (serialized from the struct
-    // cells — the struct-space analogue of the straight-line base_scope). #74: this lets a child/relation
-    // node port ref a parent typed node's field. Node results live in the cells above; they are
-    // serialized into this ephemeral boundary Value on demand (no persistent dynamic node-result scope).
-    let port_scope = || -> Vec<(String, Value)> {
-        let mut s = input.to_vec();
-${portScopeNodeInjections ? portScopeNodeInjections + "\n" : ""}        s
-    };
-    let _ = &port_scope;
-    let mut pending_err: Option<BehaviorError> = None;
-
-    let run = {
-        let err_cell = &mut pending_err;
-        let exec = |op: &OpSpec, _bound: Option<&Value>| -> ExecOutcome {
-            if err_cell.is_some() {
-                return ExecOutcome::Error("aborted".to_string());
-            }
-            let i = match ops.iter().position(|o| o.id == op.id) {
-                Some(i) => i,
-                None => {
-                    *err_cell = Some(no_typed_exec_arm(&op.id));
-                    return ExecOutcome::Error("aborted".to_string());
-                }
-            };
-            let _ = i;
-${arms}
-            *err_cell = Some(no_typed_exec_arm(&op.id));
-            ExecOutcome::Error("aborted".to_string())
-        };
-        run_plan(${planExpr}, &ops, exec)
-    };
-
-    // exec 内で立てた BehaviorError は run_plan が返す合成 OP_FAILED に優先する。
-    if let Some(e) = pending_err {
-        return Err(e);
-    }
-    let _run = run?;
-
-    // output assembly: struct field 直参照 ＋ struct/Vec literal（動的 Value output tree は組まない）。
-    let __typed_out = ${out.expr};
-    Ok(${serialized})
-}`;
-}
-/**
- * emitTypedExecArm — 1 ノードの struct-native exec 分岐。componentRef: ports を native/primitive で評価
- * （port_scope 読み）→ handlers.exec_ctx → 結果を **outType struct へ marshal**（raw→typed 境界）→ cell に
- * 格納。map/cond は struct-native では未対応（typed corpus は componentRef のみ）— fail-closed。
- */
-function emitTypedExecArm(op, compName, typedNodes, plan, producedCell) {
-    if (op.kind === "map")
-        return emitTypedMapArm(op, compName, typedNodes, plan, producedCell);
-    if (op.kind === "cond")
-        return emitTypedCondArm(op, compName, typedNodes, plan, producedCell);
-    const portRows = op.ports.length === 0
-        ? "                Ok(Vec::new())"
-        : `                Ok(vec![\n${op.ports
-            .map((pt) => `                    (${rustStrLit(pt.name)}.to_string(), (${pt.expr})?),`)
-            .join("\n")}\n                ])`;
-    const ref = typedNodes.get(op.id);
-    // 結果 materialization: handler 結果（&v）を outType struct へ marshal して cell へ格納（de-box 境界）。
-    const materialize = emitStoreTypedNodeRust(op.id, "v", ref, 4, producedCell);
-    return `            if i == ${op.index} {
-                let eval_ports = || -> Result<Vec<(String, Value)>, behavior_contracts::ExprFailure> {
-${portRows}
-                };
-                let ports = match eval_ports() {
-                    Ok(p) => p,
-                    Err(e) => {
-                        *err_cell = Some(e.into());
-                        return ExecOutcome::Error("aborted".to_string());
-                    }
-                };
-                let outcome = match handlers.exec_ctx(${rustStrLit(op.id)}, ${rustStrLit(op.component)}, &ports, None) {
-                    Some(o) => o,
-                    None => {
-                        *err_cell = Some(unknown_component(${rustStrLit(op.component)}));
-                        return ExecOutcome::Error("aborted".to_string());
-                    }
-                };
-                let v = match &outcome {
-                    ExecOutcome::Ok(v) => v,
-                    ExecOutcome::Error(_) => return outcome,
-                };
-${materialize}
-                return ExecOutcome::Ok(Value::Null);
-            }`;
-}
-/**
- * collectTypedNodes — component の body ノードで outType を持つもの（componentRef / map / cond）を
- * id → 結果 TypeRef に index 化する（#66: map/cond も struct 空間で結果を保持）。
- */
-function collectTypedNodes(comp, plan) {
-    const typedNodes = new Map();
-    for (const n of comp.body) {
-        const ot = n.outType;
-        if (ot !== undefined)
-            typedNodes.set(n.id, deriveTypeRef(ot, plan));
-    }
-    return typedNodes;
-}
-/**
- * emitStoreTypedNodeRust — raw な `&Value` 式（`srcExpr`）を node の outType（`ref`）へ **fail-closed**
- * de-box し、typed cell（RefCell<T>）へ格納する Rust match block を返す（indent = 4-space 段）。named→
- * marshal_T*、scalar/arr/opt→materialize_node_*、注記無し→捨てる。componentRef / cond の結果格納で共有。
- * これらは `?` を使わず（closure が Result を返さない）BehaviorError を err_cell へ写す。`nodeIdForFn` は
- * materialize_node_* の名前生成に使う node id（cond/componentRef とも op.id）。
- */
-function emitStoreTypedNodeRust(nodeId, srcExpr, ref, indent, producedCell) {
-    const pad = "    ".repeat(indent);
-    if (ref === undefined) {
-        return `${pad}let _ = ${srcExpr};`;
-    }
-    const call = ref.kind === "named" ? `marshal_${ref.name}(${srcExpr})` : `materialize_node_${typedCell(nodeId)}(${srcExpr})`;
-    // #74: flag the node produced so a later port_scope() (from a child node's port eval) serializes it.
-    const prod = producedCell ? ` ${producedCell(nodeId)}.set(true);` : "";
-    return `${pad}match ${call} {
-${pad}    Ok(tv) => { *${typedCell(nodeId)}.borrow_mut() = tv;${prod} }
-${pad}    Err(e) => {
-${pad}        *err_cell = Some(e);
-${pad}        return ExecOutcome::Error("aborted".to_string());
-${pad}    }
-${pad}}`;
-}
-/**
- * emitTypedCondArm — typed cond の struct-native exec（#66）。cond は純 Expression（handler 非呼び）。
- * `{cond:[if,then,else]}` を primitive（primitives::cond。短絡・strict-bool の意味論 SSoT）で 1 式評価し、
- * 選択枝の raw Value を outType struct へ **その場で marshal**（de-box 境界）して cell へ格納する。動的 Value
- * node-result scope は組まない（両枝は同じ outType へ材化される）。
- */
-function emitTypedCondArm(op, _compName, typedNodes, _plan, producedCell) {
-    const ref = typedNodes.get(op.id);
-    const store = emitStoreTypedNodeRust(op.id, "&cond_raw", ref, 4, producedCell);
-    return `            if i == ${op.index} {
-                let cond_raw: Value = match ${op.expr} {
-                    Ok(v) => v,
-                    Err(e) => {
-                        *err_cell = Some(e.into());
-                        return ExecOutcome::Error("aborted".to_string());
-                    }
-                };
-${store}
-                return ExecOutcome::Ok(Value::Null);
-            }`;
-}
-/**
- * emitTypedMapArm — typed map の struct-native exec（#66）。node 結果型は {arr:elemType}（`outType`）。要素を
- * 反復し、guard（primitives::cond・strict-bool SSoT）で skip、per-element ports を要素 scope（mscope = input
- * params + `as`→要素値）で native/primitive 評価、handler を呼び、その **raw 結果を要素 struct へ marshal**
- * （de-box 境界）して `Vec<elemStruct>` を組み、cell へ格納する（動的 Value collected list は作らない）。batched
- * は guard 通過全要素 ports を 1 回の handler 呼びへ。into は over 要素へ handler 結果を zip-attach した augment
- * 済み Value を **要素 struct へ marshal**（over 要素=入力境界 Value・into 値=handler raw の局所合流→marshal で
- * de-box。動的 output tree は組まない）。plan.concurrency は外側の run_plan primitive が保存する（map=1 op）。
- */
-function emitTypedMapArm(op, compName, typedNodes, _plan, producedCell) {
-    const ref = typedNodes.get(op.id);
-    if (ref === undefined || ref.kind !== "arr") {
-        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust-typed struct-native map: node '${op.id}' has no {arr:elemType} outType (got ${ref ? JSON.stringify(ref.kind) : "no outType"}). A typed map must annotate its result element type to de-box into a native Vec<T>; otherwise regenerate as untyped straight-line. Do not fall back to a dynamic Value collected list.`);
-    }
-    // #66 hardening: a typed map combining `when` (guard) AND `into` yields
-    // HETEROGENEOUS elements (skipped elements lack the `into` field) that cannot
-    // de-box into a single Vec<T>. Reject loudly at generation time rather than
-    // emitting a module that only fail-closes (MISSING_PROP) at runtime on a skip.
-    if (op.guard !== undefined && op.into !== undefined) {
-        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust-typed struct-native map: node '${op.id}' combines 'when' (guard) and 'into', which produces heterogeneous elements (skipped elements lack the 'into' field) that cannot de-box into a single Vec<T>. Regenerate this map as untyped straight-line, or split guard and into. Do not emit a struct-native map that fail-closes only at runtime.`);
-    }
-    const elemRef = ref.elem;
-    const elemTy = renderTypeRef(elemRef);
-    const comp = rustStrLit(op.component);
-    const nodeId = rustStrLit(op.id);
-    const asKey = rustStrLit(op.as);
-    const elemMat = mapElemMaterializerNameRust(compName, op.id);
-    // mscope: input params（port_scope）に `as`→要素値 を足す（node-result Value scope は組まない）。
-    const mscope = `                    let mscope = || -> Vec<(String, Value)> {
-                        let mut s = ${PORT_SCOPE};
-                        s.push((${asKey}.to_string(), el.clone()));
-                        s
-                    };
-                    let _ = &mscope;`;
-    const guardBlock = op.guard === undefined
-        ? ""
-        : `
-                let gkeep = {
-${mscope}
-                    match ${op.guard} {
-                        Ok(v) => matches!(v, Value::Bool(true)),
-                        Err(e) => {
-                            *err_cell = Some(e.into());
-                            return ExecOutcome::Error("aborted".to_string());
-                        }
-                    }
-                };
-                if !gkeep {
-                    continue;
-                }`;
-    const portRows = op.ports.length === 0
-        ? "Ok(Vec::new())"
-        : `Ok(vec![\n${op.ports
-            .map((pt) => `                        (${rustStrLit(pt.name)}.to_string(), (${pt.expr})?),`)
-            .join("\n")}\n                    ])`;
-    const portEval = `
-                let eval_ports = || -> Result<Vec<(String, Value)>, behavior_contracts::ExprFailure> {
-${mscope}
-                    ${portRows}
-                };
-                let ports = match eval_ports() {
-                    Ok(p) => p,
-                    Err(e) => {
-                        *err_cell = Some(e.into());
-                        return ExecOutcome::Error("aborted".to_string());
-                    }
-                };`;
-    // guard 通過要素の handler raw 結果を貯める（into でも collected でも per-element raw）。
-    const collectLoop = op.batched
-        ? `            let mut items: Vec<Value> = Vec::new();
-            for (mi, el) in over_arr.iter().enumerate() {${guardBlock}${portEval}
-                items.push(Value::Obj(ports));
-                kept_idx.push(mi);
-            }
-            let elem_raws: Vec<Value> = if items.is_empty() {
-                Vec::new()
-            } else {
-                let want = items.len();
-                let batch_ports = vec![("items".to_string(), Value::Arr(items))];
-                match handlers.exec_ctx(${nodeId}, ${comp}, &batch_ports, None) {
-                    None => {
-                        *err_cell = Some(unknown_component(${comp}));
-                        return ExecOutcome::Error("aborted".to_string());
-                    }
-                    Some(ExecOutcome::Error(e)) => return ExecOutcome::Error(e),
-                    Some(ExecOutcome::Ok(v)) => match v {
-                        Value::Arr(r) if r.len() == want => r,
-                        _ => {
-                            *err_cell = Some(behavior_contracts::BehaviorError::new(
-                                "MAP_BATCH_RESULT_MISMATCH",
-                                format!("map '${op.id}': batched handler must return a list aligned to items (want {want})"),
-                            ));
-                            return ExecOutcome::Error("aborted".to_string());
-                        }
-                    },
-                }
-            };`
-        : `            let mut elem_raws: Vec<Value> = Vec::with_capacity(over_arr.len());
-            for (mi, el) in over_arr.iter().enumerate() {${guardBlock}${portEval}
-                match handlers.exec_ctx(${nodeId}, ${comp}, &ports, Some(el)) {
-                    None => {
-                        *err_cell = Some(unknown_component(${comp}));
-                        return ExecOutcome::Error("aborted".to_string());
-                    }
-                    Some(ExecOutcome::Error(e)) => return ExecOutcome::Error(e),
-                    Some(ExecOutcome::Ok(v)) => elem_raws.push(v),
-                }
-                kept_idx.push(mi);
-            }`;
-    // 要素 struct へ **fail-closed** de-box して Vec<elemStruct> を組み、cell へ格納（動的 Value list は作らない）。
-    const buildTyped = op.into === undefined
-        ? `            let mut typed: Vec<${elemTy}> = Vec::with_capacity(elem_raws.len());
-            for er in elem_raws.iter() {
-                match ${elemMat}(er) {
-                    Ok(tv) => typed.push(tv),
-                    Err(e) => {
-                        *err_cell = Some(e);
-                        return ExecOutcome::Error("aborted".to_string());
-                    }
-                }
-            }
-            *${typedCell(op.id)}.borrow_mut() = typed;
-            ${producedCell(op.id)}.set(true);`
-        : `            let mut typed: Vec<${elemTy}> = Vec::with_capacity(over_arr.len());
-            let mut mk = 0usize;
-            for (mj, oel) in over_arr.iter().enumerate() {
-                let elem_val: Value = if mk < kept_idx.len() && kept_idx[mk] == mj {
-                    let merged = match oel {
-                        Value::Obj(pairs) => {
-                            let mut next: Vec<(String, Value)> = pairs.clone();
-                            if let Some(slot) = next.iter_mut().find(|(kk, _)| kk == ${rustStrLit(op.into ?? "")}) {
-                                slot.1 = elem_raws[mk].clone();
-                            } else {
-                                next.push((${rustStrLit(op.into ?? "")}.to_string(), elem_raws[mk].clone()));
-                            }
-                            Value::Obj(next)
-                        }
-                        _ => {
-                            *err_cell = Some(behavior_contracts::BehaviorError::new(
-                                "MAP_INTO_ELEMENT_NOT_OBJECT",
-                                format!("map '${op.id}': 'into' requires object elements (element {mj} is not an object)"),
-                            ));
-                            return ExecOutcome::Error("aborted".to_string());
-                        }
-                    };
-                    mk += 1;
-                    merged
-                } else {
-                    oel.clone()
-                };
-                match ${elemMat}(&elem_val) {
-                    Ok(tv) => typed.push(tv),
-                    Err(e) => {
-                        *err_cell = Some(e);
-                        return ExecOutcome::Error("aborted".to_string());
-                    }
-                }
-            }
-            *${typedCell(op.id)}.borrow_mut() = typed;
-            ${producedCell(op.id)}.set(true);`;
-    return `            if i == ${op.index} {
-            let over_arr: Vec<Value> = match ${op.over} {
-                Ok(Value::Arr(a)) => a,
-                Ok(_) => {
-                    *err_cell = Some(behavior_contracts::BehaviorError::new(
-                        "MAP_OVER_NOT_ARRAY",
-                        "map '${op.id}': 'over' did not evaluate to an array".to_string(),
-                    ));
-                    return ExecOutcome::Error("aborted".to_string());
-                }
-                Err(e) => {
-                    *err_cell = Some(e.into());
-                    return ExecOutcome::Error("aborted".to_string());
-                }
-            };
-            let mut kept_idx: Vec<usize> = Vec::new();
-${collectLoop}
-${buildTyped}
-                return ExecOutcome::Ok(Value::Null);
-            }`;
-}
-/** typed map の要素 fail-closed 材化関数名（component 名で namespace・rust）。 */
-function mapElemMaterializerNameRust(compName, nodeId) {
-    return `materialize_map_elem_${rustStraightlineInternals.sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
-}
-/**
- * emitNodeMaterializers — scalar/arr/opt を outType に持つ typed **node** 用の材化関数
- * `materialize_node_cell_*(&Value) -> Result<T, BehaviorError>` を emit する（named node は marshal_T* を
- * 直接使うので不要）。exec arm から `?` なしで呼べる名前付き関数へ切り出す（closure 制約回避 + de-box）。
- */
-function emitNodeMaterializers(comp, typedNodes, plan) {
-    const parts = [];
-    for (const [id, ref] of typedNodes.entries()) {
-        if (ref.kind === "named")
-            continue;
-        const ty = renderTypeRef(ref);
-        const body = emitFieldMaterialize("raw", ref, plan);
-        parts.push(`#[allow(dead_code)]\nfn materialize_node_${typedCell(id)}(raw: &Value) -> Result<${ty}, BehaviorError> {\n    Ok(${indentBlock(body, 1).trimStart()})\n}`);
-    }
-    return parts.join("\n\n");
-}
-/**
- * emitMapElemMaterializersRust — typed map node（outType {arr:elemType}）の要素 fail-closed 材化関数
- * `materialize_map_elem_<comp>_<id>(raw: &Value) -> Result<elemT, BehaviorError>` を emit する（#66）。
- * emitFieldMaterialize を再利用し、marshaller と同型の TYPE_MISMATCH/MISSING_PROP で loud reject する。
- */
-function emitMapElemMaterializersRust(comp, plan) {
-    const parts = [];
-    for (const n of comp.body) {
-        if (!("map" in n))
-            continue;
-        const ot = n.outType;
-        if (ot === undefined)
-            continue;
-        const ref = deriveTypeRef(ot, plan);
-        if (ref.kind !== "arr")
-            continue;
-        const elemRef = ref.elem;
-        const ty = renderTypeRef(elemRef);
-        const fn = mapElemMaterializerNameRust(comp.name, n.id);
-        // named 要素は marshal_T*(raw) を直接返す（clippy::needless_question_mark 回避）。それ以外は
-        // materialize block を Ok(...) で包む（emitFieldMaterialize は末尾式・error は内部 return）。
-        const inner = elemRef.kind === "named"
-            ? `marshal_${elemRef.name}(raw)`
-            : `Ok(${indentBlock(emitFieldMaterialize("raw", elemRef, plan), 1).trimStart()})`;
-        parts.push(`#[allow(dead_code)]\nfn ${fn}(raw: &Value) -> Result<${ty}, BehaviorError> {\n    ${inner}\n}`);
-    }
-    return parts.join("\n\n");
-}
-// ── module 綴じ（straight-line 本体を流用 ＋ typed 層）──────────────────────────────
-function hasAnyTypeAnnotation(ctx) {
-    for (const comp of ctx.ir.components) {
-        if (comp.outputType !== undefined)
-            return true;
-        for (const n of comp.body)
-            if (n.outType !== undefined)
-                return true;
-    }
-    return false;
-}
-/** typed component（run_typed_* 経路で駆動するもの）か。 */
-function isTypedComponent(comp) {
-    if (comp.outputType !== undefined)
-        return true;
-    return comp.body.some((n) => n.outType !== undefined);
-}
-/** marshaller helper（BehaviorError 生成）。生成モジュールに 1 度だけ emit。 */
-function emitMarshalHelpers() {
-    return `// marshaller helpers — de-box failures map to BehaviorError (fail-closed, TYPE_MISMATCH / MISSING_PROP).
-// (Some are unused in modules whose typed corpus never hits that failure shape — generated toolkit.)
-#[allow(dead_code)]
-fn marshal_type_error(prefix: &str, got: &str) -> BehaviorError {
-    BehaviorError::new("TYPE_MISMATCH", format!("{prefix}{got}"))
-}
-
-#[allow(dead_code)]
-fn marshal_missing_prop(prefix: &str, key: &str) -> BehaviorError {
-    BehaviorError::new("MISSING_PROP", format!("{prefix}{key}"))
-}
-
-// input_ref — reads a single leaf from the input params Value (a genuine boundary read, NOT a
-// reconstruction of a dynamic Value node-result tree). Used only when an output directly references
-// an input param (rare in the bc typed corpus). Best-effort: the type plan guarantees the shape.
-#[allow(dead_code)]
-fn input_ref(path: &[&str], scope: &[(String, Value)]) -> Value {
-    if path.is_empty() {
-        return Value::Null;
-    }
-    let mut cur = match scope.iter().find(|(k, _)| k == path[0]) {
-        Some((_, v)) => v.clone(),
-        None => return Value::Null,
-    };
-    for seg in &path[1..] {
-        match cur.obj_get(seg) {
-            Some(v) => cur = v.clone(),
-            None => return Value::Null,
-        }
-    }
-    cur
-}
-
-fn no_typed_exec_arm(id: &str) -> BehaviorError {
-    BehaviorError::new("UNKNOWN_NODE_KIND", format!("op '{id}' has no generated typed exec arm (fail-closed)"))
-}`;
-}
-/** Default 導出不能な named struct（null 単独型 Value field を持つもの）だけ手書き Default を emit。 */
-function emitDefaults(plan) {
-    return plan.decls
-        .filter((d) => !isDefaultable({ kind: "named", name: d.name }, plan))
-        .map((d) => {
-        const fields = d.fields
-            .map((f) => `            ${rustFieldName(f.name)}: ${defaultExpr(f.type)},`)
-            .join("\n");
-        return `impl Default for ${d.name} {\n    fn default() -> Self {\n        ${d.name} {\n${fields}\n        }\n    }\n}`;
-    })
-        .join("\n\n");
-}
-/** TypeRef の Rust default 値式（Default::default() を持たない Value 型に対応するため明示）。 */
-function defaultExpr(ref) {
-    switch (ref.kind) {
-        case "scalar":
-            switch (ref.scalar) {
-                case "string":
-                    return "String::new()";
-                case "int":
-                    return "0i64";
-                case "float":
-                    return "0f64";
-                case "bool":
-                    return "false";
-                case "null":
-                    return "Value::Null";
-            }
-            break;
-        case "opt":
-            return "None";
-        case "arr":
-            return "Vec::new()";
-        case "named":
-            return `${ref.name}::default()`;
-    }
-    throw new Error(`typed rust: defaultExpr fell through for ${JSON.stringify(ref)}`);
-}
-/**
- * injectTypedDispatch — rust-straightline 本体を typed-aware にする（typed IR 専用の書き換え。untyped IR は
- * この関数を通らない＝byte-identical 後方互換）。2 点だけ触る:
- *   1. `Bound::call` の `match name` で **typed component の arm を run_typed_* へ差し替える**（run_* 呼びを
- *      run_typed_* 呼びに置換 — 重複 arm を作らない＝unreachable_patterns 回避）。
- *   2. 差し替えで unreachable になる straight-line `fn run_<typed>` に `#[allow(dead_code)]` を付す（byte 上は
- *      定義のまま・struct-native 経路が SSoT。dead_code lint 回避）。
- * 定数（IR_FINGERPRINT/COMPONENT_NAMES）・helper・untyped component の run_* と arm は byte 不変
- * （可搬 IR は straight-line 本体ごと埋め込まない）。
- */
-function injectTypedDispatch(code, ctx) {
-    let out = code;
-    for (const c of ctx.ir.components) {
-        if (!isTypedComponent(c))
-            continue;
-        const fn = rustStraightlineInternals.sanitize(c.name);
-        // (1) dispatch arm 差し替え（run_<fn> → run_typed_<fn>。1 度だけ）。
-        const arm = `${rustStrLit(c.name)} => run_${fn}(&mut self.handlers, input),`;
-        const typedArm = `${rustStrLit(c.name)} => run_typed_${fn}(&mut self.handlers, input),`;
-        if (!out.includes(arm)) {
-            throw new Error(`rust-typed emit: could not find the straight-line dispatch arm for typed component '${c.name}'`);
-        }
-        out = out.replace(arm, typedArm);
-        // (2) 差し替えで dead になる straight-line 定義に allow を付す。dead な本体（typed dispatch が SSoT に
-        //     なるので実行されない）に対し dead_code だけでなく、body 内で発火し得る lint（未使用 handler・
-        //     map の static-string format! など。#66 で map/cond typed component も dead 化するため）も抑止する。
-        const def = `fn run_${fn}<H: ComponentExec>(`;
-        if (!out.includes(def)) {
-            throw new Error(`rust-typed emit: could not find the straight-line fn definition for typed component '${c.name}'`);
-        }
-        out = out.replace(def, `#[allow(dead_code, unused_variables, clippy::useless_format)]\n${def}`);
-    }
-    return out;
-}
-function emit(ctx) {
-    // rust-straightline のモジュール全文を同梱する（untyped component の run_*/bind = A2 SSoT。byte 不変で
-    // 後方互換）。typed component は **struct-native な run_typed_* へ差し替える**（Bound::call の dispatch
-    // 先頭に typed 相談を注入）。straight-line 本体・run_*・helper・定数は byte 不変（IR は非埋め込み）。
-    const typed = hasAnyTypeAnnotation(ctx);
-    if (!typed)
-        return rustStraightlineEmitter.emit(ctx);
-    const plan = buildTypePlan(ctx.ir);
-    const decls = rustTypedMaterializer.emitTypeDecls(plan);
-    const defaults = emitDefaults(plan);
-    const marshallers = rustTypedMaterializer.emitMarshallers(plan);
-    const serializers = emitSerializers(plan);
-    const marshalHelpers = emitMarshalHelpers();
-    // node 材化関数（scalar/arr/opt outType node 用）を全 typed component から集める（#66: cond も対象。
-    // map は要素材化 materialize_map_elem_* が別途担うので除外）。
-    const nodeMaterializers = [];
-    for (const comp of ctx.ir.components) {
-        if (!isTypedComponent(comp))
-            continue;
-        const typedNodes = new Map();
-        for (const n of comp.body) {
-            if ("map" in n)
-                continue;
-            const ot = n.outType;
-            if (ot !== undefined)
-                typedNodes.set(n.id, deriveTypeRef(ot, plan));
-        }
-        const nm = emitNodeMaterializers(comp, typedNodes, plan);
-        if (nm)
-            nodeMaterializers.push(nm);
-    }
-    // typed map の要素 fail-closed 材化関数（#66）。
-    const mapElemMaterializers = [];
-    for (const comp of ctx.ir.components) {
-        if (!isTypedComponent(comp))
-            continue;
-        const me = emitMapElemMaterializersRust(comp, plan);
-        if (me)
-            mapElemMaterializers.push(me);
-    }
-    const runners = ctx.ir.components
-        .filter((c) => isTypedComponent(c))
-        .map((c) => emitTypedRunner(c, plan))
-        .join("\n\n");
-    const banner = `// ── typed layer (bc#48 / Layer B2 — Rust REAL de-box, STRUCT-NATIVE exec) ────────────
-// Unlike the TS oracle (type erasure, no runtime de-box), the Rust typed layer executes typed
-// components in STRUCT space (the largest de-box win): run_typed_* drives the plan with the
-// run_plan primitive (plan SSoT) and per-node exec arms that marshal the handler result DIRECTLY
-// into the node's outType struct at the boundary (raw->typed) and store the STRUCT in a typed cell
-// (RefCell<T*>). The dynamic Value node-result scope (Vec<(String, Value)> results) and the Value
-// output tree are NEVER built. ref/field access reads the structs (.field, not obj_get); the output
-// is assembled as a struct and serialized to a Value ONLY at the final return boundary.
-// Bind routes typed components here; untyped components/IR stay byte-identical to rust-straightline.
-use std::cell::RefCell;`;
-    const sections = [
-        banner,
-        decls || undefined,
-        defaults || undefined,
-        marshalHelpers,
-        marshallers
-            ? `// raw -> typed marshallers (§4.4): de-box a dynamic Value into a concrete struct, field by field.\n${marshallers}`
-            : undefined,
-        nodeMaterializers.length
-            ? `// scalar/arr/opt node materializers: concrete de-box for typed nodes whose outType is not a named obj.\n${nodeMaterializers.join("\n\n")}`
-            : undefined,
-        mapElemMaterializers.length
-            ? `// typed map element materializers (#66): FAIL-CLOSED de-box of each map element into the Vec<T> element type.\n${mapElemMaterializers.join("\n\n")}`
-            : undefined,
-        serializers
-            ? `// typed -> Value serializers (final return boundary only): canonical observation for the equivalence pin.\n${serializers}`
-            : undefined,
-        `// struct-native typed runners: the REAL de-box exec path (called by Bind for typed components).\n${runners}`,
-    ];
-    const typedBody = sections.filter((s) => !!s).join("\n\n");
-    // typed body が実際に参照する RunPlan-path import を scan で確定し、base straight-line モジュールに
-    // それだけを force する（bc#75: 逐次 base は run_plan/OpSpec/RelationKind/json! を落とすが、struct-native
-    // typed runner は参照する）。typed body は我々の生成した rust なので token scan は安全（過剰 import は
-    // clippy unused で落ちるため granular に絞る）。
-    const req = {
-        runPlan: /\brun_plan\(|\bOpSpec\b|ExecOutcome\b/.test(typedBody),
-        relationKind: /\bRelationKind\b/.test(typedBody),
-        json: /\bjson!\(/.test(typedBody),
-    };
-    setRustForceRunPlanImports(req);
-    const straightlineCode = rustStraightlineEmitter.emit(ctx);
-    setRustForceRunPlanImports(null);
-    const patched = injectTypedDispatch(straightlineCode, ctx);
-    // straight-line 本体は改行で終わる。1 空行を挟んで typed 層、末尾は改行 1 つ。
-    return `${patched.replace(/\n+$/, "\n")}\n${typedBody}\n`;
-}
-/**
- * rustTypedEmitter — 言語識別子 `rust-typed` の emitter plugin（bc#48 B2, 実 de-box）。
- * rust-straightline 本体（byte 同一）＋ typed 層（struct/marshaller/serializer/struct-native runner）。
- * `outType` 無し IR は rust-straightline と byte-identical（後方互換）。
- */
-export const rustTypedEmitter = {
-    language: "rust-typed",
-    fileExtension: ".rs",
-    defaultRuntimeImport: "behavior_contracts",
-    filenameHint: "behaviors_typed_generated.rs",
-    emit,
-};
-/**
- * rustTypedInternals — shared Rust typed-emit helpers the RAW-ABI emitter (bc#76,
- * emit-raw-abi-rust.ts) reuses so boxed and raw paths keep one implementation of the
- * type-plan/naming/serializer discipline (only the marshaller data plane and the handler
- * dispatch differ between them).
- */
-export const rustTypedInternals = {
-    sanitize: rustStraightlineInternals.sanitize,
-    rustFieldName,
-    rustStrLit,
-    renderTypeRef,
-    rustScalar,
-    typedCell,
-    typedFieldAccess,
-    isTypedComponent,
-    hasAnyTypeAnnotation,
-    collectTypedNodes,
-    emitTypeDecls,
-    emitDefaults,
-    emitSerializers,
-    emitMarshallers,
-    emitMarshalHelpers,
-    materializeExpr,
-    serializeTyped,
-    emitTypedValue,
-    indentBlock,
-    emitOpsLiteral: rustStraightlineInternals.emitOpsLiteral,
-    emitPlanLiteral: rustStraightlineInternals.emitPlanLiteral,
-    rustStraightlineEmitter,
-    rustStraightlineInternals,
-    setRustForceRunPlanImports,
-};
-//# sourceMappingURL=emit-straightline-typed-rust.js.map