behavior-contracts 0.5.0 → 0.7.0

package/dist/generator/{emit-straightline-typed-go.d.ts → emit-shared-go-typed.d.ts}

@@ -1,5 +1,7 @@
 /**
- * emit-straightline-typed-go.ts — Go typed 直線 emitter（bc#47 / Layer B2, 実 de-box）。
+ * emit-shared-go-typed.ts — Go typed 共有 emit エンジン（旧 emit-straightline-typed-go.ts, bc#47 / Layer B2）。
+ * #90/#99 で go-typed emitter plugin surface は撤去。この module は native(go) が消費する共有 typed
+ * ヘルパ（goTypedInternals: typedFieldAccess/materializeExpr/emitMarshallers/emitTypeDecls/serializeTyped 等）のみ。
  *
  * typed-codegen.md §4.3/§4.4 の Go 具体化。**最初のコンパイル言語の typed emitter**であり、B2-ts で
  * decls-only だった {@link TypedMaterializer} seam を **runtime-materialization 対応に拡張（co-design）**
@@ -27,9 +29,9 @@
  * `outType`/`outputType` が IR のどこにも無ければ typed 層は emit されず、出力は `go-straightline` と
  * byte-identical（後方互換 pin）。
  */
-import type { EmitContext, EmitterPlugin } from "./core.js";
-import { type TypePlan, type TypeRef, type TypedMaterializer } from "./typed.js";
-import { setGoForceRunPlanHelpers } from "./emit-straightline-go.js";
+import type { EmitContext } from "./core.js";
+import { type TypePlan, type TypeRef } from "./typed.js";
+import { setGoForceRunPlanHelpers } from "./emit-shared-go.js";
 import type { Component } from "../behavior.js";
 /** 可搬スカラ → Go の具体型名（de-box 後の struct field 型）。int/float は int64/float64 で区別。 */
 declare function goScalar(scalar: "string" | "int" | "float" | "bool" | "null"): string;
@@ -67,7 +69,6 @@ declare function typedFieldAccess(baseExpr: string, baseRef: TypeRef, fields: st
  * そのまま Value、arr→要素 ser ループ helper、opt→null 分岐 helper。式一発で返せるよう helper を通す。
  */
 declare function serializeTyped(typedExpr: string, ref: TypeRef, _plan: TypePlan): string;
-export declare const goTypedMaterializer: TypedMaterializer;
 /** 各 named struct を canonical Value（*Obj, field は宣言順）へ戻す `ser_T*` ＋ 汎用 arr/opt helper を emit。 */
 declare function emitSerializers(plan: TypePlan): string;
 /** component 名 → Go 関数名（straight-line と同規律）。 */
@@ -107,16 +108,10 @@ declare function emitMustHelpers(plan: TypePlan): string;
  */
 declare function emitArrOptNodeHelpers(ctx: EmitContext, plan: TypePlan): string;
 /**
- * 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 declare const goTypedEmitter: EmitterPlugin;
-/**
- * goTypedInternals — shared Go typed-emit helpers the RAW-ABI emitter (bc#76,
- * emit-raw-abi-go.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).
+ * goTypedInternals — shared Go typed-emit helpers the native emitter (emit-typed-native-go.ts)
+ * reuses so the native de-box path shares one implementation of the type-plan/naming/serializer/
+ * marshaller discipline. This module carries NO emitter plugin (#90/#99): the go-typed and
+ * go-straightline emitter surfaces were removed — go converges to the native target only.
  */
 export declare const goTypedInternals: {
     PKG: string;
@@ -143,7 +138,6 @@ export declare const goTypedInternals: {
     emitBehaviorPlanLiteral: (plan: unknown) => string;
     goPortVar: (name: string) => string;
     setGoForceRunPlanHelpers: typeof setGoForceRunPlanHelpers;
-    goStraightlineEmitter: EmitterPlugin;
 };
 export {};
-//# sourceMappingURL=emit-straightline-typed-go.d.ts.map
+//# sourceMappingURL=emit-shared-go-typed.d.ts.map

package/dist/generator/emit-shared-go-typed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-shared-go-typed.d.ts","sourceRoot":"","sources":["../../src/generator/emit-shared-go-typed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAGL,KAAK,QAAQ,EACb,KAAK,OAAO,EAEb,MAAM,YAAY,CAAC;AACpB,OAAO,EAA2B,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAGxF,OAAO,KAAK,EAAE,SAAS,EAAgB,MAAM,gBAAgB,CAAC;AAO9D,gFAAgF;AAChF,iBAAS,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAc9E;AAED,yEAAyE;AACzE,iBAAS,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAY3C;AAED;8DAC8D;AAC9D,iBAAS,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAc7C;AAED,wFAAwF;AACxF,iBAAS,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOzC;AAED;;;;GAIG;AACH,iBAAS,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAG/C;AA8FD;;;;;GAKG;AACH,iBAAS,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,GAAG,MAAM,CAW/E;AAED;;;GAGG;AACH,iBAAS,gBAAgB,CACvB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,EAAE,EAChB,IAAI,EAAE,QAAQ,GACb;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,CAchC;AAED;;;;GAIG;AACH,iBAAS,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,GAAG,MAAM,CAYhF;AASD,iGAAiG;AACjG,iBAAS,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CA0B/C;AAID,gDAAgD;AAChD,iBAAS,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtC;AAED,oDAAoD;AACpD,iBAAS,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE1C;AAYD;;;;;;;;;GASG;AACH,iBAAS,cAAc,CACrB,IAAI,EAAE,OAAO,EACb,QAAQ,EAAE,OAAO,GAAG,SAAS,EAC7B,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,IAAI,EAAE,QAAQ,GACb;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,OAAO,GAAG,SAAS,CAAA;CAAE,CA8D5C;AAoCD;;;GAGG;AACH,iBAAS,iBAAiB,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,QAAQ,GAAG,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAOhF;AAED,uCAAuC;AACvC,iBAAS,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAc1C;AAID,iBAAS,oBAAoB,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAMvD;AAED,6CAA6C;AAC7C,iBAAS,gBAAgB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAGlD;AAED,qFAAqF;AACrF,iBAAS,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAgD/C;AAED;;;;GAIG;AACH,iBAAS,qBAAqB,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,CA0CvE;AAkBD;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;uCAoBQ,SAAS;;;;;CAM7C,CAAC"}

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

@@ -0,0 +1,572 @@
+import { deriveTypeRef, findDecl, } from "./typed.js";
+import { goStraightlineInternals, setGoForceRunPlanHelpers } from "./emit-shared-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);
+}
+// ── 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, "_")}`;
+}
+/** `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()";
+/**
+ * collectTypedNodes — component の body ノードで outType を持つもの（componentRef / map / cond）を
+ * id → 結果 TypeRef に index 化する。map/cond も struct 空間で結果を保持する（#66 de-box 拡張）。
+ */
+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;
+}
+/** 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");
+}
+/** 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_");
+    }
+}
+/**
+ * goTypedInternals — shared Go typed-emit helpers the native emitter (emit-typed-native-go.ts)
+ * reuses so the native de-box path shares one implementation of the type-plan/naming/serializer/
+ * marshaller discipline. This module carries NO emitter plugin (#90/#99): the go-typed and
+ * go-straightline emitter surfaces were removed — go converges to the native target only.
+ */
+export const goTypedInternals = {
+    PKG,
+    sanitize,
+    goFieldName,
+    renderTypeRef,
+    goScalar,
+    typedLocal,
+    isTypedComponent,
+    collectTypedNodes,
+    hasAnyTypeAnnotation,
+    emitTypeDecls,
+    emitSerializers,
+    emitMarshallers,
+    materializeExpr,
+    serializeTyped,
+    typedFieldAccess,
+    emitTypedValue,
+    arrHelperKey,
+    emitMustHelpers,
+    emitArrOptNodeHelpers,
+    buildComponentPlanForTyped: (comp) => buildComponentPlan(comp, goStraightlineInternals.dialect, PORT_SCOPE),
+    emitOpsLiteral: goStraightlineInternals.emitOpsLiteral,
+    emitBehaviorPlanLiteral: goStraightlineInternals.emitBehaviorPlanLiteral,
+    goPortVar: goStraightlineInternals.goPortVar,
+    setGoForceRunPlanHelpers,
+};
+//# sourceMappingURL=emit-shared-go-typed.js.map