behavior-contracts 0.2.0 → 0.2.1

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

@@ -0,0 +1,823 @@
+import { GeneratorFailure } from "./core.js";
+import { buildTypePlan, deriveTypeRef, findDecl, } from "./typed.js";
+import { rustStraightlineEmitter, rustStraightlineInternals } 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 で outType を持つもの）を index 化。
+    const typedNodes = new Map();
+    for (const n of comp.body) {
+        const ot = n.outType;
+        if (ot !== undefined && "component" in n) {
+            typedNodes.set(n.id, deriveTypeRef(ot, plan));
+        }
+    }
+    // 各 typed node の struct cell 宣言（Option<T> を RefCell で。marshal 後に Some(struct) を書き込む）。
+    const cellDecls = [...typedNodes.entries()]
+        .map(([id, ref]) => `    let ${typedCell(id)}: RefCell<${renderTypeRef(ref)}> = RefCell::new(Default::default());`)
+        .join("\n");
+    const arms = cplan.ops.map((op) => emitTypedExecArm(op, typedNodes, plan)).join("\n");
+    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>(
+    handlers: &mut H,
+    input: &[(String, Value)],
+) -> Result<Value, BehaviorError> {
+    let ops: Vec<OpSpec> = ${opsLiteral};
+    // port_scope exposes ONLY the input params (a genuine boundary Value). No node-result Value
+    // scope is built: typed node results live in the struct cells below, read via struct fields.
+    let port_scope = || -> Vec<(String, Value)> { input.to_vec() };
+    let _ = &port_scope;
+${cellDecls ? cellDecls + "\n" : ""}    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, typedNodes, plan) {
+    if (op.kind !== "componentRef") {
+        // struct-native exec は typed corpus（componentRef のみ）に閉じる。map/cond typed は follow-up（#60）。
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust-typed struct-native exec: node kind '${op.kind}' is not supported in a typed component yet (typed corpus is componentRef-only; map/cond typed de-box is deferred to a follow-up). Do not silently fall back to a Value-building path.`);
+    }
+    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 結果を outType struct へ marshal して cell へ格納（de-box 境界）。
+    let materialize;
+    if (ref === undefined) {
+        // outType 無し node（typed component だが個々の node には注記が無い）: 結果は使われない（output が
+        // input/他 node 由来）。struct 化する型が無いので何もしない（Value を results へ入れることもしない）。
+        materialize = `                let _ = &v;`;
+    }
+    else if (ref.kind === "named") {
+        materialize = `                match marshal_${ref.name}(v) {
+                    Ok(st) => { *${typedCell(op.id)}.borrow_mut() = st; }
+                    Err(e) => {
+                        *err_cell = Some(e);
+                        return ExecOutcome::Error("aborted".to_string());
+                    }
+                }`;
+    }
+    else {
+        // scalar/arr/opt outType node: インライン材化 block で具体 typed 値へ（de-box、named でない）。
+        // 材化式は `?` を使わず（closure が Result を返さない）BehaviorError を err_cell へ写す match 展開にする。
+        materialize = `                match materialize_node_${typedCell(op.id)}(v) {
+                    Ok(tv) => { *${typedCell(op.id)}.borrow_mut() = tv; }
+                    Err(e) => {
+                        *err_cell = Some(e);
+                        return ExecOutcome::Error("aborted".to_string());
+                    }
+                }`;
+    }
+    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);
+            }`;
+}
+/**
+ * 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");
+}
+// ── 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 対象）・helper・untyped component の run_* と arm は byte 不変。
+ */
+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 を付す。
+        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)]\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・IR リテラルは byte 不変。
+    const straightlineCode = rustStraightlineEmitter.emit(ctx);
+    if (!hasAnyTypeAnnotation(ctx))
+        return straightlineCode;
+    const patched = injectTypedDispatch(straightlineCode, 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 から集める。
+    const nodeMaterializers = [];
+    for (const comp of ctx.ir.components) {
+        if (!isTypedComponent(comp))
+            continue;
+        const typedNodes = new Map();
+        for (const n of comp.body) {
+            const ot = n.outType;
+            if (ot !== undefined && "component" in n)
+                typedNodes.set(n.id, deriveTypeRef(ot, plan));
+        }
+        const nm = emitNodeMaterializers(comp, typedNodes, plan);
+        if (nm)
+            nodeMaterializers.push(nm);
+    }
+    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,
+        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");
+    // 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,
+};
+//# sourceMappingURL=emit-straightline-typed-rust.js.map