behavior-contracts 0.2.0 → 0.2.1

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

@@ -0,0 +1,828 @@
+import { emitStraightlineModule } from "./straightline.js";
+import { buildTypePlan, deriveTypeRef, findDecl, } from "./typed.js";
+import { goStraightlineEmitter, goStraightlineInternals } from "./emit-straightline-go.js";
+import { buildComponentPlan } from "./straightline.js";
+import { GeneratorFailure } from "./core.js";
+/** runtime package alias（生成コード内）— straight-line と同じ `dslcontracts`。 */
+const PKG = "dslcontracts";
+// ── Go typed materializer（TypedMaterializer seam の Go 具体化 — 拡張 hook 実装）────
+/** 可搬スカラ → Go の具体型名（de-box 後の struct field 型）。int/float は int64/float64 で区別。 */
+function goScalar(scalar) {
+    switch (scalar) {
+        case "string":
+            return "string";
+        case "int":
+            return "int64";
+        case "float":
+            return "float64";
+        case "bool":
+            return "bool";
+        case "null":
+            // null 単独型は Go に無いので Value（nil のみ格納）。opt でラップされて現れるのが通常。
+            return `${PKG}.Value`;
+    }
+}
+/** TypeRef を Go の具体型名へ（named→struct 名、arr→slice、opt→ポインタ、scalar→具体型）。 */
+function renderTypeRef(ref) {
+    switch (ref.kind) {
+        case "scalar":
+            return goScalar(ref.scalar);
+        case "opt":
+            // nullable は Go ポインタで表す（nil = null）。scalar/struct いずれも `*T`。
+            return `*${renderTypeRef(ref.inner)}`;
+        case "arr":
+            return `[]${renderTypeRef(ref.elem)}`;
+        case "named":
+            return ref.name;
+    }
+}
+/** 型プランの named obj を Go struct 宣言へ（decls 順＝決定的）。field は宣言順・export 名。gofmt と同じ
+ * 列アラインで綴じる（field 名列・型列を最大幅に揃える — 生成物が gofmt clean になるよう）。 */
+function emitTypeDecls(plan) {
+    if (plan.decls.length === 0)
+        return "";
+    return plan.decls
+        .map((d) => {
+        const names = d.fields.map((f) => goFieldName(f.name));
+        const types = d.fields.map((f) => renderTypeRef(f.type));
+        const nameW = Math.max(0, ...names.map((n) => n.length));
+        const typeW = Math.max(0, ...types.map((t) => t.length));
+        const fields = d.fields
+            .map((f, i) => `\t${names[i].padEnd(nameW)} ${types[i].padEnd(typeW)} // ${JSON.stringify(f.name)}`)
+            .join("\n");
+        return `type ${d.name} struct {\n${fields}\n}`;
+    })
+        .join("\n\n");
+}
+/** wire field 名 → Go の export struct field 名（決定的・一意）。元名は struct コメント/marshaller で保持。 */
+function goFieldName(wire) {
+    // 先頭を大文字化して export（Go の struct field 参照可視性）。非識別子文字は `_`。衝突は元名一意で回避
+    // されないので、決定的に元名を base64url なしの安全化＋先頭大文字で綴じ、marshaller が wire キーで対応づける。
+    const safe = wire.replace(/[^A-Za-z0-9_]/g, "_");
+    const head = safe.charAt(0);
+    const capitalized = /[a-z]/.test(head) ? head.toUpperCase() + safe.slice(1) : "F_" + safe;
+    return capitalized;
+}
+/**
+ * emitMarshallers — 各 named struct の raw→typed marshaller（§4.4）。動的 Value（`*Obj` 期待）を受け、
+ * 各 field を typed に読み出して具体 struct を組む。generic Value 走査を exec 経路から除去する de-box の実体。
+ * field 型ごとに再帰: named→marshal_T*、arr→要素ループ、opt→null 分岐、scalar→型 assert。
+ */
+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 = [];
+    lines.push(`func marshal_${d.name}(raw ${PKG}.Value) (${d.name}, error) {`);
+    lines.push(`\tvar out ${d.name}`);
+    lines.push(`\to, ok := raw.(*${PKG}.Obj)`);
+    lines.push(`\tif !ok {`);
+    lines.push(`\t\treturn out, ${PKG}.NewExprFailure("TYPE_MISMATCH", "typed marshal ${d.name}: expected obj, got "+${PKG}.TypeName(raw))`);
+    lines.push(`\t}`);
+    for (const f of d.fields) {
+        const goName = goFieldName(f.name);
+        const keyLit = JSON.stringify(f.name);
+        lines.push(`\t{`);
+        lines.push(`\t\tfv, present := o.Get(${keyLit})`);
+        lines.push(`\t\tif !present {`);
+        lines.push(`\t\t\treturn out, ${PKG}.NewExprFailure("MISSING_PROP", "typed marshal ${d.name}: missing property ."+${keyLit})`);
+        lines.push(`\t\t}`);
+        lines.push(emitFieldMaterialize(`out.${goName}`, "fv", f.type, plan, 2));
+        lines.push(`\t}`);
+    }
+    lines.push(`\treturn out, nil`);
+    lines.push(`}`);
+    return lines.join("\n");
+}
+/**
+ * emitFieldMaterialize — `target` (typed lvalue) に `src` (Value 式) を型 `ref` で materialize して代入する
+ * Go 文ブロックを返す（indent = タブ数）。scalar は型 assert、named は marshal_T* 呼び、arr は要素ループ、
+ * opt は null 分岐（ポインタ）。すべて具体 Go 型で組む（de-box）。fail は expr.go と同じ Failure code。
+ */
+function emitFieldMaterialize(target, src, ref, plan, indent) {
+    const t = "\t".repeat(indent);
+    switch (ref.kind) {
+        case "scalar": {
+            if (ref.scalar === "null") {
+                return `${t}${target} = ${src}`;
+            }
+            const gt = goScalar(ref.scalar);
+            const assertType = ref.scalar === "int" ? "int64" : ref.scalar === "float" ? "float64" : gt;
+            return [
+                `${t}sv, sok := ${src}.(${assertType})`,
+                `${t}if !sok {`,
+                `${t}\treturn out, ${PKG}.NewExprFailure("TYPE_MISMATCH", "typed marshal: expected ${ref.scalar}, got "+${PKG}.TypeName(${src}))`,
+                `${t}}`,
+                `${t}${target} = sv`,
+            ].join("\n");
+        }
+        case "named": {
+            return [
+                `${t}mv, merr := marshal_${ref.name}(${src})`,
+                `${t}if merr != nil {`,
+                `${t}\treturn out, merr`,
+                `${t}}`,
+                `${t}${target} = mv`,
+            ].join("\n");
+        }
+        case "arr": {
+            const elemGo = renderTypeRef(ref.elem);
+            const inner = emitFieldMaterialize("elemOut", "elemRaw", ref.elem, plan, indent + 1);
+            return [
+                `${t}arr, aok := ${src}.([]${PKG}.Value)`,
+                `${t}if !aok {`,
+                `${t}\treturn out, ${PKG}.NewExprFailure("TYPE_MISMATCH", "typed marshal: expected arr, got "+${PKG}.TypeName(${src}))`,
+                `${t}}`,
+                `${t}slice := make([]${elemGo}, 0, len(arr))`,
+                `${t}for _, elemRaw := range arr {`,
+                `${t}\tvar elemOut ${elemGo}`,
+                inner,
+                `${t}\tslice = append(slice, elemOut)`,
+                `${t}}`,
+                `${t}${target} = slice`,
+            ].join("\n");
+        }
+        case "opt": {
+            const innerGo = renderTypeRef(ref.inner);
+            const inner = emitFieldMaterialize("optOut", src, ref.inner, plan, indent + 1);
+            return [
+                `${t}if ${src} == nil {`,
+                `${t}\t${target} = nil`,
+                `${t}} else {`,
+                `${t}\tvar optOut ${innerGo}`,
+                inner,
+                `${t}\t${target} = &optOut`,
+                `${t}}`,
+            ].join("\n");
+        }
+    }
+}
+/**
+ * materializeExpr — raw な Value 式 `rawExpr` を型 `ref` の具体 typed 値へ変換する **単一式**（exec 経路の
+ * de-box）。named→`mustMarshal_T*`（marshaller 経由で具体 struct へ）、scalar→型 assert helper、arr/opt→
+ * 具体 slice/pointer helper。呼び側（typed view の output assembly / node materialize）が typed ローカルへ束ねる。
+ * これが seam の runtime-materialization hook の Go 実装本体（rust #48 は同型の hook を返す）。
+ */
+function materializeExpr(rawExpr, ref, _plan) {
+    switch (ref.kind) {
+        case "named":
+            return `mustMarshal_${ref.name}(${rawExpr})`;
+        case "scalar":
+            return `mustScalar_${ref.scalar}(${rawExpr})`;
+        case "arr":
+            return `mustArr_${arrHelperKey(ref)}(${rawExpr})`;
+        case "opt":
+            return `mustOpt_${arrHelperKey(ref)}(${rawExpr})`;
+    }
+}
+/**
+ * typedFieldAccess — typed base 式 `baseExpr`（型 `baseRef`）に field path を **struct field 直参照**で辿る。
+ * map lookup ではなく `.FieldName` 連結（＝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 go: 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 go: field '${f}' not found on struct ${ref.name}`);
+        expr = `${expr}.${goFieldName(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、arr→要素 ser ループ helper、opt→null 分岐 helper。式一発で返せるよう helper を通す。
+ */
+function serializeTyped(typedExpr, ref, _plan) {
+    switch (ref.kind) {
+        case "named":
+            return `ser_${ref.name}(${typedExpr})`;
+        case "scalar":
+            // 具体スカラは Value に代入可能（string/int64/float64/bool は Value=interface{}）。
+            return `${PKG}.Value(${typedExpr})`;
+        case "arr":
+            return `serArr(${typedExpr}, func(e ${renderTypeRef(ref.elem)}) ${PKG}.Value { return ${serializeTyped("e", ref.elem, _plan)} })`;
+        case "opt":
+            return `serOpt(${typedExpr} == nil, func() ${PKG}.Value { return ${serializeTypedOptInner(ref.inner, typedExpr, _plan)} })`;
+    }
+}
+/** opt の非 nil 分岐: `*ptr` を deref して inner を serialize。 */
+function serializeTypedOptInner(inner, ptrExpr, plan) {
+    return serializeTyped(`(*${ptrExpr})`, inner, plan);
+}
+export const goTypedMaterializer = {
+    emitTypeDecls,
+    renderTypeRef,
+    emitMarshallers,
+    materializeExpr,
+    typedFieldAccess,
+    serializeTyped,
+};
+// ── serializer helper（named struct → Value）を型プランから emit ────────────────────
+/** 各 named struct を canonical Value（*Obj, field は宣言順）へ戻す `ser_T*` ＋ 汎用 arr/opt helper を emit。 */
+function emitSerializers(plan) {
+    const perStruct = plan.decls.map((d) => {
+        const sets = d.fields
+            .map((f) => {
+            const val = serializeTyped(`v.${goFieldName(f.name)}`, f.type, plan);
+            return `\to.Set(${JSON.stringify(f.name)}, ${val})`;
+        })
+            .join("\n");
+        return `func ser_${d.name}(v ${d.name}) ${PKG}.Value {\n\to := ${PKG}.NewObj()\n${sets}\n\treturn o\n}`;
+    });
+    // 汎用 arr/opt serialize helper（型パラメタで要素 serializer を受ける）。
+    const generic = `func serArr[T any](xs []T, ser func(T) ${PKG}.Value) ${PKG}.Value {
+\tout := make([]${PKG}.Value, 0, len(xs))
+\tfor _, x := range xs {
+\t\tout = append(out, ser(x))
+\t}
+\treturn out
+}
+
+func serOpt(isNil bool, ser func() ${PKG}.Value) ${PKG}.Value {
+\tif isNil {
+\t\treturn nil
+\t}
+\treturn ser()
+}`;
+    return perStruct.length === 0 ? generic : `${generic}\n\n${perStruct.join("\n\n")}`;
+}
+// ── typed view 関数（実 exec 経路 — 実 de-box）─────────────────────────────────────
+/** component 名 → Go 関数名（straight-line と同規律）。 */
+function sanitize(name) {
+    return name.replace(/[^A-Za-z0-9_]/g, "_");
+}
+/** 生成コード内の typed ローカル変数名（materialize 済み struct）。 */
+function typedLocal(nodeId) {
+    return `t_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
+}
+/**
+ * nodeMaterializerName — scalar/arr/opt を outType に持つ typed node の **fail-closed** 材化関数名。
+ * component 名で namespace して module 全体で一意にする（node id は component 間で衝突しうる）。
+ */
+function nodeMaterializerName(compName, nodeId) {
+    return `materializeNode_${sanitize(compName)}_${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` の **具体 Go typed 値**式へ再帰 lower し、
+ * `{ expr, ref }` を返す。これが AC2 の「exec が具体 struct を保持」の実体:
+ *   - `{ref:[typedNode, …fields]}` → typed struct field 直参照（typedFieldAccess — map lookup でない）。
+ *   - `{ref:[input/非 typed node]}` → 型付け不能な生 Value。expected があれば materialize（de-box）。
+ *   - `{obj:{…}}` → 具体 struct literal（expected が named のとき各 field を期待型で lower）。
+ *   - `{arr:[…]}` → 具体 slice literal（要素は要素型で lower）。
+ *   - scalar literal → 具体 Go 値。
+ *   - 演算子（concat/…）→ straight-line 生値を expected へ materialize（意味論は SSoT が持つ）。
+ */
+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 への参照: struct field 直参照で辿る（de-box された struct access）。
+            const baseRef = typedNodes.get(head);
+            const { expr, ref } = typedFieldAccess(typedLocal(head), baseRef, path.slice(1), plan);
+            return { expr, ref };
+        }
+        // input param 参照（非 typed node）: input Value（portScope）を局所的に読み、expected へ materialize
+        // （de-box）。これは動的 Value tree の再構築ではなく input 境界値の 1 leaf 読み（許容される局所変換）。
+        // bc typed corpus の output は input を直参照しないので通常到達しないが、健全に処理する。
+        if (expected)
+            return { expr: materializeExpr(scopeRead(path), expected, plan), ref: expected };
+        return { expr: scopeRead(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 `${goFieldName(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 items = elems.map((e) => emitTypedValue(e, expected.elem, typedNodes, plan).expr);
+            return { expr: `[]${renderTypeRef(expected.elem)}{${items.join(", ")}}`, ref: expected };
+        }
+        // concat 演算子: operand を **de-box された typed 値**（typed field access なら concrete string）で
+        // 読み、native string 連結する（go-straightline の slConcat と同じ native 化パターン — 意味論保存）。
+        // これで scalar-output-via-typed-field-access vector も **具体 struct field を経由した de-box** になる。
+        if (keys.length === 1 && keys[0] === "concat" && expected && expected.kind === "scalar" && expected.scalar === "string") {
+            const parts = node.concat;
+            const partExprs = parts.map((p) => {
+                const sub = emitTypedValue(p, { kind: "scalar", scalar: "string" }, typedNodes, plan);
+                return sub.expr;
+            });
+            return { expr: partExprs.join(" + "), ref: expected };
+        }
+        // その他単一キー = 別演算子（add/eq/…）: struct-native exec では動的 Value output tree を組まない方針
+        // ゆえ、A0 primitive SSoT を呼ぶ経路（operand の局所 Value 化）を要する。bc typed corpus には output
+        // 位置の非 concat 演算子が無いので、ここは **LOUD fail-closed**（silent な Value フォールバックを禁ずる
+        // 監査指示に従う）。graphddb #60 / follow-up で primitive-at-boundary 経路を足す。
+        if (keys.length === 1) {
+            throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go-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 リテラル "!"）: 具体 Go スカラ。
+    if (expected && expected.kind === "scalar") {
+        return { expr: litScalar(node, expected.scalar), ref: expected };
+    }
+    return { expr: litScalarUnknown(node), ref: undefined };
+}
+/** input/非 typed node の scope 読み（動的 Value 式）。slRef 相当のネスト walk を helper で。 */
+function scopeRead(path) {
+    // portScope() = input params only（node 結果 *Obj scope は struct-native では存在しない）。
+    return `mustInputRef([]string{${path.map((p) => JSON.stringify(p)).join(", ")}}, portScope())`;
+}
+/** 期待スカラの Go リテラル（string/int/float/bool/null）。 */
+function litScalar(node, scalar) {
+    if (scalar === "string" && typeof node === "string")
+        return JSON.stringify(node);
+    if (scalar === "bool" && typeof node === "boolean")
+        return node ? "true" : "false";
+    if (scalar === "int") {
+        if (node !== null && typeof node === "object" && typeof node.int === "string")
+            return `int64(${node.int})`;
+        if (typeof node === "number")
+            return `int64(${node})`;
+    }
+    if (scalar === "float") {
+        if (node !== null && typeof node === "object" && typeof node.float === "number")
+            return `float64(${node.float})`;
+        if (typeof node === "number")
+            return `float64(${node})`;
+    }
+    if (scalar === "null")
+        return "nil";
+    // 型が食い違う literal は fail-closed（型プランと不整合）。
+    throw new Error(`typed go: scalar literal ${JSON.stringify(node)} does not match expected ${scalar}`);
+}
+function litScalarUnknown(node) {
+    if (node === null)
+        return "nil";
+    if (typeof node === "boolean")
+        return node ? "true" : "false";
+    if (typeof node === "string")
+        return JSON.stringify(node);
+    return "nil";
+}
+const PORT_SCOPE = "portScope()";
+/**
+ * emitTypedRunner — 1 typed component の **struct-native exec**（bc#47 rework: LAYERED でなく実 de-box）。
+ *
+ * 監査で不合格だった旧設計（Value-building `run_*` ＋ `scopeCapture` で全ノードの生 Value を `*Obj` に
+ * 蓄え、さらに straight-line が `PrimObj(...)` で動的 Value output tree を組み、その後 struct へ変換）を
+ * 廃し、**結果を最初から struct 空間で持つ** exec を生成する:
+ *
+ *   - plan/handler-dispatch の SSoT は再利用する（`RunPlan` primitive + `ExecHandler`。意味論は二重実装
+ *     しない）。ただし RunPlan の exec thunk は、handler 結果（生 Value mock；graphddb #60 では raw）を
+ *     **その場で outType struct へ marshal**（raw→typed 境界）し、struct を typed scope へ格納する。
+ *     生 Value を `*Obj` results scope へ入れることは**しない**。
+ *   - port 式は従来どおり native/primitive（`slRef`/`slConcat`/`Prim*`）で評価するが、読む scope は
+ *     **input params だけを持つ portScope()**（bc の port は input のみ参照。上流 typed node を参照する
+ *     port が来た場合はその struct を局所的に Value 化して読む＝operand の局所変換のみ・許容）。
+ *   - component `output` は typed node struct への **struct field 直参照** ＋ struct/slice literal で
+ *     組み、最終 return 境界で **1 回だけ** Value へ serialize する（動的 Value output tree は組まない）。
+ *   - overflow/短絡 operator は A0 primitive SSoT のまま（意味論非再実装）。ここで struct 空間へ移すのは
+ *     **結果 materialization（handler 結果・scope・output）だけ**。
+ *
+ * map を含む typed component は struct-native exec のスコープ外（LOUD fail-closed。graphddb #60 / follow-up）。
+ */
+function emitTypedRunner(comp, plan) {
+    const fn = sanitize(comp.name);
+    // struct-native scope を組むため、port 式は portScope()（input params のみ）で emit する。
+    const cplan = buildComponentPlan(comp, goStraightlineInternals.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 ローカル宣言（zero 値・producedフラグ）。RunPlan の exec が marshal して埋める。
+    const decls = [...typedNodes.entries()]
+        .map(([id, ref]) => `\tvar ${typedLocal(id)} ${renderTypeRef(ref)}`)
+        .join("\n");
+    const arms = cplan.ops.map((op) => emitTypedExecArm(op, comp.name, typedNodes, plan)).join("\n");
+    const planLiteral = comp.plan
+        ? goStraightlineInternals.emitBehaviorPlanLiteral(comp.plan)
+        : `(*${PKG}.ExecutionPlanSpec)(nil)`;
+    // 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";
+    return `// run_typed_${fn} — STRUCT-NATIVE exec (bc#47 de-box): the plan is driven by the RunPlan primitive
+// (plan SSoT) with per-node thunks that marshal the handler result DIRECTLY into the node's outType
+// struct at the boundary and store the STRUCT in a typed scope — the dynamic Value node-result scope
+// and the PrimObj(...) output tree are NEVER built. Downstream ref/field access reads the structs;
+// 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.)
+func run_typed_${fn}(handlers ${PKG}.ComponentExec, input *${PKG}.Obj) (${PKG}.Value, error) {
+\tops := ${goStraightlineInternals.emitOpsLiteral(cplan)}
+\tif input == nil {
+\t\tinput = ${PKG}.NewObj()
+\t}
+\t// portScope exposes ONLY the input params (a genuine boundary Value). No node-result *Obj scope is
+\t// built: typed node results live in the struct locals below, read via struct field references.
+\tportScope := func() *${PKG}.Obj {
+\t\ts := ${PKG}.NewObj()
+\t\tfor _, k := range input.Keys {
+\t\t\ts.Set(k, input.Vals[k])
+\t\t}
+\t\treturn s
+\t}
+\t_ = portScope
+${decls ? decls + "\n" : ""}\tvar scopeMu sync.Mutex
+\t_ = scopeMu.Unlock
+\texecErrs := make([]error, len(ops))
+\tabort := func(idx int, err error) ${PKG}.ExecOutcome {
+\t\texecErrs[idx] = err
+\t\treturn ${PKG}.ErrOutcome("aborted")
+\t}
+\texec := func(op ${PKG}.OpSpec, _ ${PKG}.Value) ${PKG}.ExecOutcome {
+\t\tidx := -1
+\t\tfor k := range ops {
+\t\t\tif ops[k].ID == op.ID {
+\t\t\t\tidx = k
+\t\t\t\tbreak
+\t\t\t}
+\t\t}
+\t\ti := idx
+${arms}
+\t\treturn abort(idx, ${PKG}.NewBehaviorFailure("UNKNOWN_NODE_KIND", "op '"+op.ID+"' has no generated typed exec arm (fail-closed)"))
+\t}
+\tplan := ${planLiteral}
+\trun, err := ${PKG}.RunPlan(plan, ops, exec)
+\tif firstErr := ${PKG}.FirstExecErrInVisitOrder(execErrs, plan, len(ops), err); firstErr != nil {
+\t\treturn nil, firstErr
+\t}
+\tif err != nil {
+\t\treturn nil, err
+\t}
+\t_ = run
+\t__typed_out := ${out.expr}
+\t_ = __typed_out
+\treturn ${serialized}, nil
+}`;
+}
+/**
+ * emitTypedExecArm — 1 ノードの struct-native exec 分岐。componentRef: ports を native/primitive で評価
+ * （portScope 読み）→ ExecHandler → 結果を **outType struct へ marshal**（raw→typed 境界）→ struct scope に
+ * 格納。map/cond は struct-native では未対応（typed corpus は componentRef のみ）— fail-closed。
+ */
+function emitTypedExecArm(op, compName, typedNodes, plan) {
+    if (op.kind !== "componentRef") {
+        // struct-native exec は typed corpus（componentRef のみ）に閉じる。map/cond typed は follow-up（#60）。
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go-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 gp = goStraightlineInternals.goPortVar;
+    const portEvals = op.ports
+        .map((p) => `\t\t\t${gp(p.name)}, err := ${p.expr}
+\t\t\tif err != nil {
+\t\t\t\treturn abort(idx, err)
+\t\t\t}
+\t\t\tports.Set(${JSON.stringify(p.name)}, ${gp(p.name)})`)
+        .join("\n");
+    const body = op.ports.length === 0 ? "" : `\n${portEvals}`;
+    const ref = typedNodes.get(op.id);
+    // 結果 materialization: handler 結果を outType struct へ marshal して struct scope へ格納（de-box 境界）。
+    // outType 無しの typed component node（純 output-typed）は struct にせず、struct 空間の観点では格納不要。
+    let materialize;
+    if (ref === undefined) {
+        // outType 無し node（typed component だが個々の node には注記が無い）: 結果は使われない（output が
+        // input/他 node 由来）。struct 化する型が無いので何もしない（Value を scope へ入れることもしない）。
+        materialize = "\t\t\t_ = outcome.Ok";
+    }
+    else if (ref.kind === "named") {
+        materialize = `\t\t\tst, merr := marshal_${ref.name}(outcome.Ok)
+\t\t\tif merr != nil {
+\t\t\t\treturn abort(idx, merr)
+\t\t\t}
+\t\t\tscopeMu.Lock()
+\t\t\t${typedLocal(op.id)} = st
+\t\t\tscopeMu.Unlock()`;
+    }
+    else {
+        // scalar/arr/opt outType node: **fail-closed** 材化関数で具体 typed 値へ（marshal と同型の de-box）。
+        // 旧実装は must*（型 assert を捨てて zero 値へ silent coerce）だったが、handler が outType 非適合の
+        // 値を返した場合に沈黙で潰れる（TYPE_MISMATCH を握り潰す）ため fail-closed に差し替えた（bc#49 B3）。
+        // materializeNode_* は emitFieldMaterialize と同じ TYPE_MISMATCH/MISSING_PROP を返す。
+        const mfn = nodeMaterializerName(compName, op.id);
+        materialize = `\t\t\ttv, merr := ${mfn}(outcome.Ok)
+\t\t\tif merr != nil {
+\t\t\t\treturn abort(idx, merr)
+\t\t\t}
+\t\t\tscopeMu.Lock()
+\t\t\t${typedLocal(op.id)} = tv
+\t\t\tscopeMu.Unlock()`;
+    }
+    return `\t\tif i == ${op.index} {
+\t\t\tports := ${PKG}.NewObj()${body}
+\t\t\toutcome, resolved := ${PKG}.ExecHandler(handlers, ${JSON.stringify(op.id)}, ${JSON.stringify(op.component)}, ports, nil)
+\t\t\tif !resolved {
+\t\t\t\treturn abort(idx, ${PKG}.NewBehaviorFailure("UNKNOWN_COMPONENT", "component '${op.component}' has no handler (fail-closed)"))
+\t\t\t}
+\t\t\tif outcome.IsError {
+\t\t\t\treturn outcome
+\t\t\t}
+${materialize}
+\t\t\treturn ${PKG}.OkOutcome(nil)
+\t\t}`;
+}
+/** arr/opt helper 名の決定的キー（要素型で一意化）。 */
+function arrHelperKey(ref) {
+    const flat = (r) => {
+        switch (r.kind) {
+            case "scalar":
+                return r.scalar;
+            case "named":
+                return r.name;
+            case "arr":
+                return `arr_${flat(r.elem)}`;
+            case "opt":
+                return `opt_${flat(r.inner)}`;
+        }
+    };
+    return flat(ref);
+}
+// ── module 綴じ（straight-line 本体を scope 露出版で流用 ＋ 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（typedView 経路で駆動するもの）か。 */
+function isTypedComponent(comp) {
+    if (comp.outputType !== undefined)
+        return true;
+    return comp.body.some((n) => n.outType !== undefined);
+}
+/** must 系 helper（struct-native exec の scalar/arr/opt/named de-box を単一式で使う）を emit。 */
+function emitMustHelpers(plan) {
+    const parts = [];
+    // mustInputRef — output が input param を直参照する稀な場合に、input Value（portScope）から 1 leaf を
+    // 読む（動的 Value tree の再構築ではなく境界値の局所読み）。エラーは型プランが保証するので best-effort。
+    parts.push(`func mustInputRef(path []string, scope *${PKG}.Obj) ${PKG}.Value {
+\tif len(path) == 0 {
+\t\treturn nil
+\t}
+\tcur, ok := scope.Get(path[0])
+\tif !ok {
+\t\treturn nil
+\t}
+\tfor _, seg := range path[1:] {
+\t\to, isObj := cur.(*${PKG}.Obj)
+\t\tif !isObj {
+\t\t\treturn nil
+\t\t}
+\t\tnext, present := o.Get(seg)
+\t\tif !present {
+\t\t\treturn nil
+\t\t}
+\t\tcur = next
+\t}
+\treturn cur
+}`);
+    // scalar must helper（型 assert → 具体 Go 値。失敗は panic せず sentinel; 実際には型プランが保証）。
+    for (const scalar of ["string", "int", "float", "bool", "null"]) {
+        if (scalar === "null") {
+            parts.push(`func mustScalar_null(v ${PKG}.Value) ${PKG}.Value { return v }`);
+            continue;
+        }
+        const gt = goScalar(scalar);
+        const at = scalar === "int" ? "int64" : scalar === "float" ? "float64" : gt;
+        parts.push(`func mustScalar_${scalar}(v ${PKG}.Value) ${gt} {
+\ts, _ := v.(${at})
+\treturn s
+}`);
+    }
+    // named must-marshal（単一式で使う: err は typed view の named node materialize が別途チェックするので
+    // ここでは best-effort。exec 経路の de-box は marshal_T* が担う）。
+    for (const d of plan.decls) {
+        parts.push(`func mustMarshal_${d.name}(v ${PKG}.Value) ${d.name} {
+\tout, _ := marshal_${d.name}(v)
+\treturn out
+}`);
+    }
+    return parts.join("\n\n");
+}
+/**
+ * emitArrOptNodeHelpers — arr/opt を outType に持つ **node**（named でない node）用の materialize helper
+ * `mustArr_*` / `mustOpt_*` を、IR に現れる arr/opt node outType 集合から決定的に emit する。要素/inner が
+ * named なら marshaller を、scalar なら型 assert を、ネスト arr/opt なら再帰 helper を呼ぶ（具体 slice/ptr へ de-box）。
+ */
+function emitArrOptNodeHelpers(ctx, plan) {
+    const seen = new Set();
+    const parts = [];
+    const need = (ref) => {
+        const key = arrHelperKey(ref);
+        if (ref.kind === "arr") {
+            // 要素が arr/opt なら先に要素 helper を用意する（ネスト de-box）。
+            if (ref.elem.kind === "arr" || ref.elem.kind === "opt")
+                need(ref.elem);
+            if (seen.has(`arr_${key}`))
+                return;
+            seen.add(`arr_${key}`);
+            const elemGo = renderTypeRef(ref.elem);
+            parts.push(`func mustArr_${key}(v ${PKG}.Value) []${elemGo} {
+\tarr, _ := v.([]${PKG}.Value)
+\tout := make([]${elemGo}, 0, len(arr))
+\tfor _, e := range arr {
+\t\tout = append(out, ${elemMaterializeExpr(ref.elem)})
+\t}
+\treturn out
+}`);
+        }
+        else if (ref.kind === "opt") {
+            if (ref.inner.kind === "arr" || ref.inner.kind === "opt")
+                need(ref.inner);
+            if (seen.has(`opt_${key}`))
+                return;
+            seen.add(`opt_${key}`);
+            const innerGo = renderTypeRef(ref.inner);
+            parts.push(`func mustOpt_${key}(v ${PKG}.Value) *${innerGo} {
+\tif v == nil {
+\t\treturn nil
+\t}
+\tinner := ${elemMaterializeExpr(ref.inner, "v")}
+\treturn &inner
+}`);
+        }
+    };
+    for (const comp of ctx.ir.components) {
+        for (const n of comp.body) {
+            const ot = n.outType;
+            if (ot === undefined || !("component" in n))
+                continue;
+            const ref = deriveTypeRef(ot, plan);
+            if (ref.kind === "arr" || ref.kind === "opt")
+                need(ref);
+        }
+    }
+    return parts.join("\n\n");
+}
+/**
+ * emitNodeMaterializers — scalar/arr/opt を outType に持つ typed **node** 用の **fail-closed** 材化関数
+ * `materializeNode_<comp>_<id>(raw Value) (T, error)` を emit する（named node は marshal_T* を直接使うので不要）。
+ * emitFieldMaterialize を再利用し、marshaller と同型の TYPE_MISMATCH/MISSING_PROP で loud reject する
+ * （handler が outType 非適合の値を返しても silent-coerce しない — bc#49 B3 の fail-closed 修正の実体）。
+ */
+function emitNodeMaterializers(comp, typedNodes, plan) {
+    const parts = [];
+    for (const [id, ref] of typedNodes.entries()) {
+        if (ref.kind === "named")
+            continue; // named は marshal_T* が担う
+        const ty = renderTypeRef(ref);
+        const fn = nodeMaterializerName(comp.name, id);
+        const body = emitFieldMaterialize("out", "raw", ref, plan, 1);
+        parts.push(`func ${fn}(raw ${PKG}.Value) (${ty}, error) {\n\tvar out ${ty}\n${body}\n\treturn out, nil\n}`);
+    }
+    return parts.join("\n\n");
+}
+/** arr/opt 要素の materialize 式（named→mustMarshal, scalar→mustScalar, arr/opt→ネスト helper）。 */
+function elemMaterializeExpr(ref, varName = "e") {
+    switch (ref.kind) {
+        case "named":
+            return `mustMarshal_${ref.name}(${varName})`;
+        case "scalar":
+            return `mustScalar_${ref.scalar}(${varName})`;
+        case "arr":
+        case "opt":
+            return `mustArr_${arrHelperKey(ref)}(${varName})`.replace("mustArr_", ref.kind === "opt" ? "mustOpt_" : "mustArr_");
+    }
+}
+function emit(ctx) {
+    // go-straightline のモジュール全文を同梱する（untyped component の run_*/Bind = A2 SSoT。byte 不変で
+    // 後方互換）。typed component は **struct-native な run_typed_* へ差し替える**（Value-building run_* も
+    // scopeCapture も使わない — 監査 rework）。dispatch の先頭に typedDispatch 相談を注入する。
+    const straightlineCode = goStraightlineEmitter.emit(ctx);
+    if (!hasAnyTypeAnnotation(ctx))
+        return straightlineCode;
+    const patchedStraightline = injectTypedDispatch(straightlineCode);
+    const plan = buildTypePlan(ctx.ir);
+    const decls = goTypedMaterializer.emitTypeDecls(plan);
+    const marshallers = goTypedMaterializer.emitMarshallers(plan);
+    const serializers = emitSerializers(plan);
+    const mustHelpers = emitMustHelpers(plan);
+    const arrOptNodeHelpers = emitArrOptNodeHelpers(ctx, plan);
+    // fail-closed な scalar/arr/opt node 材化関数（bc#49 B3 — exec 経路の silent-coerce 修正）。
+    const nodeMaterializers = ctx.ir.components
+        .filter((c) => isTypedComponent(c))
+        .map((c) => {
+        const typedNodes = new Map();
+        for (const n of c.body) {
+            const ot = n.outType;
+            if (ot !== undefined && "component" in n)
+                typedNodes.set(n.id, deriveTypeRef(ot, plan));
+        }
+        return emitNodeMaterializers(c, typedNodes, plan);
+    })
+        .filter((s) => s.length > 0)
+        .join("\n\n");
+    const runners = ctx.ir.components
+        .filter((c) => isTypedComponent(c))
+        .map((c) => emitTypedRunner(c, plan))
+        .join("\n\n");
+    const typedDispatch = emitTypedDispatch(ctx);
+    // gofmt-clean のため、非空セクションだけを 1 空行区切りで綴じる（空セクションで二重空行を出さない）。
+    const banner = `// ── typed layer (bc#47 / Layer B2 — Go REAL de-box, STRUCT-NATIVE exec) ─────────────
+// Unlike the TS oracle (type erasure, no runtime de-box), the Go typed layer executes typed
+// components in STRUCT space: run_typed_* drives the plan with the RunPlan primitive (plan SSoT)
+// and per-node thunks that marshal the handler result DIRECTLY into the node's outType struct at
+// the boundary (raw->typed) and store the STRUCT in a typed scope. The dynamic Value node-result
+// *Obj scope and the PrimObj(...) output tree are NEVER built. ref/field access reads the structs;
+// 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 go-straightline.`;
+    const sections = [
+        banner,
+        decls || undefined,
+        marshallers ? `// raw -> typed marshallers (§4.4): de-box a dynamic Value into a concrete struct, field by field.\n${marshallers}` : undefined,
+        `// typed -> Value serializers (final return boundary only): canonical observation for the equivalence pin.\n${serializers}`,
+        `// must-form helpers used inside the single-expression struct materialization / output assembly.\n${mustHelpers}`,
+        arrOptNodeHelpers ? `// arr/opt node de-box helpers (concrete slice/pointer materialization).\n${arrOptNodeHelpers}` : undefined,
+        nodeMaterializers ? `// scalar/arr/opt node materializers: FAIL-CLOSED de-box (TYPE_MISMATCH/MISSING_PROP) for typed nodes whose outType is not a named obj.\n${nodeMaterializers}` : undefined,
+        `// struct-native typed runners: the REAL de-box exec path (called by Bind for typed components).\n${runners}`,
+        typedDispatch,
+    ];
+    const typedBody = sections.filter((s) => !!s).join("\n\n");
+    // straight-line 本体は `}\n` で終わる。空行 1 つを挟んで typed 層、末尾は改行 1 つ（gofmt）。
+    return `${patchedStraightline.replace(/\n+$/, "\n")}\n${typedBody}\n`;
+}
+/**
+ * injectTypedDispatch — go-straightline の `func dispatch(...)` 本体先頭に typedDispatch 相談を挿入する。
+ * typed component は struct-native de-box 経路へ、未 typed は straight-line の run_* へフォールバックする。
+ * dispatch 本体だけを触り、IR リテラル（fingerprint 対象）・run_*・helper は byte 不変（後方互換の骨組みは保つ）。
+ */
+function injectTypedDispatch(code) {
+    const marker = `func dispatch(name string, handlers ${PKG}.ComponentExec, input *${PKG}.Obj) (${PKG}.Value, error) {\n`;
+    const at = code.indexOf(marker);
+    if (at < 0)
+        throw new Error("go-typed emit: could not find the straight-line dispatch function to make typed-aware");
+    const insertAt = at + marker.length;
+    const inject = `\tif v, err, handled := typedDispatch(name, handlers, input); handled {\n\t\treturn v, err\n\t}\n`;
+    return code.slice(0, insertAt) + inject + code.slice(insertAt);
+}
+/** typed dispatch: Bind が typed component を struct-native run_typed_* で駆動する（実 de-box）。 */
+function emitTypedDispatch(ctx) {
+    const arms = ctx.ir.components
+        .filter((c) => isTypedComponent(c))
+        .map((c) => {
+        const fn = sanitize(c.name);
+        return `\tif name == ${JSON.stringify(c.name)} {
+\t\tv, err := run_typed_${fn}(handlers, input)
+\t\treturn v, err, true
+\t}`;
+    })
+        .join("\n");
+    return `// typedDispatch is consulted by Bind BEFORE the straight-line dispatch: typed components run through
+// the struct-native de-boxed runner; untyped components fall through to the straight-line path unchanged.
+func typedDispatch(name string, handlers ${PKG}.ComponentExec, input *${PKG}.Obj) (${PKG}.Value, error, bool) {
+${arms}
+\treturn nil, nil, false
+}`;
+}
+/**
+ * goTypedEmitter — 言語識別子 `go-typed` の emitter plugin（bc#47 B2, 実 de-box）。
+ * go-straightline 本体（byte 同一）＋ typed 層（struct/marshaller/serializer/typedView）。
+ * `outType` 無し IR は go-straightline と byte-identical（後方互換）。
+ */
+export const goTypedEmitter = {
+    language: "go-typed",
+    fileExtension: ".go",
+    defaultRuntimeImport: "github.com/foo-ogawa/behavior-contracts/go",
+    filenameHint: "behaviors.typed.generated.go",
+    emit,
+};
+//# sourceMappingURL=emit-straightline-typed-go.js.map