behavior-contracts 0.2.5 → 0.2.6

package/dist/generator/emit-raw-abi-rust.js

@@ -0,0 +1,380 @@
+import { GeneratorFailure } from "./core.js";
+import { buildTypePlan, deriveTypeRef } from "./typed.js";
+import { buildComponentPlan } from "./straightline.js";
+import { rustTypedInternals } from "./emit-straightline-typed-rust.js";
+const PORT_SCOPE = "port_scope()";
+const { sanitize, rustFieldName, rustStrLit, renderTypeRef, rustScalar, typedCell, isTypedComponent, hasAnyTypeAnnotation, collectTypedNodes, emitTypeDecls, emitDefaults, emitSerializers, emitMarshallers, emitMarshalHelpers, serializeTyped, emitTypedValue, indentBlock, emitOpsLiteral, emitPlanLiteral, rustStraightlineEmitter, setRustForceRunPlanImports, } = rustTypedInternals;
+// ── RAW marshallers (the de-box): read a RawValue field-by-field into a concrete struct ──
+function emitRawMarshallers(plan) {
+    if (plan.decls.length === 0)
+        return "";
+    return plan.decls.map((d) => emitOneRawMarshaller(d, plan)).join("\n\n");
+}
+function emitOneRawMarshaller(d, plan) {
+    const lines = [];
+    lines.push(`#[allow(dead_code)]`);
+    lines.push(`fn marshal_raw_${d.name}(raw: &RawValue) -> Result<${d.name}, BehaviorError> {`);
+    // The row seam: a RawRow (native accessor), NOT a Value::Obj. This IS the de-box.
+    lines.push(`    let row = match raw {`);
+    lines.push(`        RawValue::Row(r) => r,`);
+    lines.push(`        other => return Err(raw_type_mismatch(${rustStrLit("obj")}, 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 row.field(${keyLit}) {`);
+        lines.push(`            Some(v) => v,`);
+        lines.push(`            None => return Err(raw_missing_prop(${rustStrLit(d.name)}, ${keyLit})),`);
+        lines.push(`        };`);
+        lines.push(indentBlock(emitRawFieldMaterialize("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");
+}
+/**
+ * emitRawFieldMaterialize — materialize `src` (a `&RawValue` expr) into a concrete typed value
+ * per `ref` (a value-returning block). scalar -> RawValue match, named -> marshal_raw_T*, arr
+ * -> RawValue::Arr loop, opt -> RawValue::Null branch. No Value::Obj/Value ever built.
+ */
+function emitRawFieldMaterialize(src, ref, plan) {
+    switch (ref.kind) {
+        case "scalar": {
+            if (ref.scalar === "null") {
+                // null-only field stays a Value::Null (the struct field type is Value for null-only).
+                return `Value::Null`;
+            }
+            const variant = ref.scalar === "int" ? "Int" : ref.scalar === "float" ? "Float" : ref.scalar === "bool" ? "Bool" : "Str";
+            const bind = ref.scalar === "string" ? "s.clone()" : "*s";
+            return [
+                `match ${src} {`,
+                `    RawValue::${variant}(s) => ${bind},`,
+                `    other => return Err(raw_type_mismatch(${rustStrLit(ref.scalar)}, other.type_name())),`,
+                `}`,
+            ].join("\n");
+        }
+        case "named": {
+            return `marshal_raw_${ref.name}(${src})?`;
+        }
+        case "arr": {
+            const elemTy = renderTypeRef(ref.elem);
+            const inner = emitRawFieldMaterialize("elem_raw", ref.elem, plan);
+            return [
+                `match ${src} {`,
+                `    RawValue::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(raw_type_mismatch(${rustStrLit("arr")}, other.type_name())),`,
+                `}`,
+            ].join("\n");
+        }
+        case "opt": {
+            const inner = emitRawFieldMaterialize("inner_raw", ref.inner, plan);
+            return [
+                `match ${src} {`,
+                `    RawValue::Null => None,`,
+                `    inner_raw => {`,
+                `        let inner_out = ${indentBlock(inner, 2).trimStart()};`,
+                `        Some(inner_out)`,
+                `    }`,
+                `}`,
+            ].join("\n");
+        }
+    }
+}
+/** scalar/arr/opt node RAW materializer name. */
+function rawNodeMaterializerName(nodeId) {
+    return `materialize_raw_node_${typedCell(nodeId)}`;
+}
+function emitRawNodeMaterializers(comp, typedNodes, plan) {
+    const parts = [];
+    for (const [id, ref] of typedNodes.entries()) {
+        if (ref.kind === "named")
+            continue;
+        const ty = renderTypeRef(ref);
+        const body = emitRawFieldMaterialize("raw", ref, plan);
+        parts.push(`#[allow(dead_code)]\nfn ${rawNodeMaterializerName(id)}(raw: &RawValue) -> Result<${ty}, BehaviorError> {\n    Ok(${indentBlock(body, 1).trimStart()})\n}`);
+    }
+    return parts.join("\n\n");
+}
+// ── RAW runner ────────────────────────────────────────────────────────────────────────
+function assertRawSupported(comp) {
+    for (const n of comp.body) {
+        if ("map" in n || "cond" in n) {
+            const ot = n.outType;
+            if (ot !== undefined) {
+                throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust raw ABI (bc#76): component '${comp.name}' node '${n.id}' is a typed ${"map" in n ? "map" : "cond"} node. The raw handler ABI de-box currently covers the componentRef read-handler shape (graphddb's row hydrator). Regenerate this component on the boxed typed path (rust-typed) — do NOT emit a raw module that re-boxes map/cond results.`);
+            }
+        }
+    }
+}
+function emitStoreRawNode(nodeId, srcExpr, ref, indent, producedCell) {
+    const pad = "    ".repeat(indent);
+    if (ref === undefined)
+        return `${pad}let _ = ${srcExpr};`;
+    const call = ref.kind === "named" ? `marshal_raw_${ref.name}(${srcExpr})` : `${rawNodeMaterializerName(nodeId)}(${srcExpr})`;
+    const prod = ` ${producedCell(nodeId)}.set(true);`;
+    return `${pad}match ${call} {
+${pad}    Ok(tv) => { *${typedCell(nodeId)}.borrow_mut() = tv;${prod} }
+${pad}    Err(e) => {
+${pad}        *err_cell = Some(e);
+${pad}        return ExecOutcome::Error("aborted".to_string());
+${pad}    }
+${pad}}`;
+}
+function producedCellName(id) {
+    return `produced_${typedCell(id)}`;
+}
+function emitRawExecArm(op, typedNodes, plan) {
+    if (op.kind !== "componentRef") {
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `rust raw ABI (bc#76): node '${op.id}' kind '${op.kind}' is not supported on the raw path (componentRef only). Regenerate on rust-typed.`);
+    }
+    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);
+    const materialize = emitStoreRawNode(op.id, "v", ref, 4, producedCellName);
+    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_raw_ctx(${rustStrLit(op.id)}, ${rustStrLit(op.component ?? "")}, &ports, None) {
+                    Some(o) => o,
+                    None => {
+                        *err_cell = Some(BehaviorError::new("UNKNOWN_COMPONENT", format!("component '{}' has no handler (fail-closed)", ${rustStrLit(op.component ?? "")})));
+                        return ExecOutcome::Error("aborted".to_string());
+                    }
+                };
+                let v = match &outcome {
+                    RawOutcome::Ok(v) => v,
+                    RawOutcome::Error(e) => {
+                        *err_cell = Some(BehaviorError::new("OP_FAILED", e.clone()));
+                        return ExecOutcome::Error("aborted".to_string());
+                    }
+                };
+${materialize}
+                return ExecOutcome::Ok(Value::Null);
+            }`;
+}
+function emitRawRunner(comp, plan) {
+    assertRawSupported(comp);
+    const fn = sanitize(comp.name);
+    const plans = buildComponentPlan(comp, rustTypedInternals.rustStraightlineInternals.dialect, PORT_SCOPE);
+    const typedNodes = collectTypedNodes(comp, plan);
+    const cellDecls = [...typedNodes.entries()]
+        .map(([id, ref]) => `    let ${typedCell(id)}: RefCell<${renderTypeRef(ref)}> = RefCell::new(Default::default());`)
+        .join("\n");
+    const producedDecls = [...typedNodes.keys()]
+        .map((id) => `    let ${producedCellName(id)} = std::cell::Cell::new(false);`)
+        .join("\n");
+    const portScopeNodeInjections = [...typedNodes.entries()]
+        .map(([id, ref]) => {
+        const isBareCopyScalar = ref.kind === "scalar" && (ref.scalar === "int" || ref.scalar === "float" || ref.scalar === "bool");
+        const owned = isBareCopyScalar ? `*${typedCell(id)}.borrow()` : `${typedCell(id)}.borrow().clone()`;
+        const ser = serializeTyped(owned, ref, plan);
+        return `            if ${producedCellName(id)}.get() {\n                s.push((${rustStrLit(id)}.to_string(), ${ser}));\n            }`;
+    })
+        .join("\n");
+    const arms = plans.ops.map((op) => emitRawExecArm(op, typedNodes, plan)).join("\n");
+    const planExpr = comp.plan ? emitPlanLiteral(comp.plan) : "None";
+    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 = emitOpsLiteral(plans);
+    return `// run_typed_raw_${fn} — RAW-ABI STRUCT-NATIVE exec (bc#76 de-box): the run_plan primitive drives the
+// plan (plan SSoT); per-node arms call the RAW handler (exec_raw_ctx -> RawValue, NOT a boxed Value) and
+// materialize the node's outType struct DIRECTLY from the RawValue via marshal_raw_T*. The dynamic
+// Value/Value::Obj tree is NEVER built on the row data plane — that is the de-box the boxed typed path
+// only LAYERED. Output is assembled as a struct and serialized to a Value ONLY at the final return
+// boundary (the equivalence pin), so the OBSERVED result equals run_behavior. Called by bind_raw.
+fn run_typed_raw_${fn}<H: RawComponentExec>(
+    handlers: &mut H,
+    input: &[(String, Value)],
+) -> Result<Value, BehaviorError> {
+    let ops: Vec<OpSpec> = ${opsLiteral};
+${cellDecls ? cellDecls + "\n" : ""}${producedDecls ? producedDecls + "\n" : ""}    let port_scope = || -> Vec<(String, Value)> {
+        let mut s = input.to_vec();
+${portScopeNodeInjections ? portScopeNodeInjections + "\n" : ""}        s
+    };
+    let _ = &port_scope;
+    let mut pending_err: Option<BehaviorError> = None;
+
+    let run = {
+        let err_cell = &mut pending_err;
+        let exec = |op: &OpSpec, _bound: Option<&Value>| -> ExecOutcome {
+            if err_cell.is_some() {
+                return ExecOutcome::Error("aborted".to_string());
+            }
+            let i = match ops.iter().position(|o| o.id == op.id) {
+                Some(i) => i,
+                None => {
+                    *err_cell = Some(no_typed_exec_arm(&op.id));
+                    return ExecOutcome::Error("aborted".to_string());
+                }
+            };
+            let _ = i;
+${arms}
+            *err_cell = Some(BehaviorError::new("UNKNOWN_NODE_KIND", format!("op '{}' has no generated raw exec arm (fail-closed)", op.id)));
+            ExecOutcome::Error("aborted".to_string())
+        };
+        run_plan(${planExpr}, &ops, exec)
+    };
+
+    if let Some(e) = pending_err {
+        return Err(e);
+    }
+    let _run = run?;
+
+    let __typed_out = ${out.expr};
+    Ok(${serialized})
+}`;
+}
+// ── bind_raw dispatch surface ───────────────────────────────────────────────────────
+function emitBindRaw(ctx) {
+    const typedComps = ctx.ir.components.filter((c) => isTypedComponent(c));
+    const names = typedComps.map((c) => rustStrLit(c.name));
+    const arms = typedComps
+        .map((c) => `            ${rustStrLit(c.name)} => run_typed_raw_${sanitize(c.name)}(&mut self.handlers, input),`)
+        .join("\n");
+    return `// COMPONENT_NAMES_RAW — typed components exposed on the RAW-ABI de-boxed path.
+pub const COMPONENT_NAMES_RAW: [&str; ${names.length}] = [${names.join(", ")}];
+
+// bind_raw / BoundRaw — the RAW-ABI dispatch surface (bc#76): binds a RawComponentExec (native-backed
+// handler results) to the de-boxed struct-native runners. Mirrors bind/Bound::call but drives the raw
+// runner. Untyped components stay on the boxed bind.
+pub fn bind_raw<H: RawComponentExec>(handlers: H) -> BoundRaw<H> {
+    BoundRaw { handlers }
+}
+
+pub struct BoundRaw<H: RawComponentExec> {
+    handlers: H,
+}
+
+impl<H: RawComponentExec> BoundRaw<H> {
+    pub fn call(&mut self, name: &str, input: &[(String, Value)]) -> Result<Value, BehaviorError> {
+        match name {
+${arms}
+            other => Err(BehaviorError::new("UNKNOWN_ENTRY", format!("component '{other}' is not a raw-typed entry (fail-closed)"))),
+        }
+    }
+}`;
+}
+// ── module assembly ──────────────────────────────────────────────────────────────────
+function emit(ctx) {
+    const typed = hasAnyTypeAnnotation(ctx);
+    if (!typed) {
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", "rust raw ABI (bc#76): the IR has no outType/outputType annotations — there is nothing to de-box. Use rust-straightline for untyped IR.");
+    }
+    const plan = buildTypePlan(ctx.ir);
+    const decls = emitTypeDecls(plan);
+    const defaults = emitDefaults(plan);
+    const rawMarshallers = emitRawMarshallers(plan);
+    const serializers = emitSerializers(plan);
+    // Boxed marshallers + helpers exist ONLY for the Value-space output-assembly fallback
+    // (materializeExpr on an output that directly refs an input param of a named type — a Value
+    // boundary read, NOT the row data plane). The ROW data plane is de-boxed via marshal_raw_* in
+    // the runner (asserted by the anti-sham gate).
+    const boxedMarshallers = emitMarshallers(plan);
+    const marshalHelpers = emitMarshalHelpers();
+    const nodeMaterializers = [];
+    for (const comp of ctx.ir.components) {
+        if (!isTypedComponent(comp))
+            continue;
+        const typedNodes = new Map();
+        for (const n of comp.body) {
+            if ("map" in n)
+                continue;
+            const ot = n.outType;
+            if (ot !== undefined)
+                typedNodes.set(n.id, deriveTypeRef(ot, plan));
+        }
+        const nm = emitRawNodeMaterializers(comp, typedNodes, plan);
+        if (nm)
+            nodeMaterializers.push(nm);
+    }
+    const runners = ctx.ir.components
+        .filter((c) => isTypedComponent(c))
+        .map((c) => emitRawRunner(c, plan))
+        .join("\n\n");
+    const bindRaw = emitBindRaw(ctx);
+    const banner = `// ── RAW handler ABI layer (bc#76 — Rust de-box: struct materialized DIRECTLY from the wire payload) ──
+// This layer is ADDITIVE to the straight-line body above. A RawComponentExec handler returns a RawValue
+// (native-backed, NOT a Value::Obj tree — see rust/src/rawabi.rs). marshal_raw_T* matches on it straight
+// into the concrete struct: the dynamic Value tree the boxed typed path built and then re-walked NEVER
+// exists here. bind_raw drives the de-boxed runners.
+use std::cell::RefCell;
+use behavior_contracts::{RawComponentExec, RawOutcome, RawValue, raw_missing_prop, raw_type_mismatch};`;
+    const sections = [
+        banner,
+        decls || undefined,
+        defaults || undefined,
+        rawMarshallers
+            ? `// RAW marshallers (§4.4, de-box): materialize a concrete struct field-by-field from a native RawValue.\n// NO Value::Obj on this data plane — that is the whole point of #76.\n${rawMarshallers}`
+            : undefined,
+        marshalHelpers,
+        boxedMarshallers
+            ? `// Value-space output-assembly fallback (marshal_*): reached ONLY when an output directly refs an\n// input param of a named type (a Value boundary read, not the row data plane). Off the de-box hot path.\n${boxedMarshallers}`
+            : undefined,
+        nodeMaterializers.length
+            ? `// scalar/arr/opt node RAW materializers: FAIL-CLOSED de-box (TYPE_MISMATCH/MISSING_PROP) from RawValue.\n${nodeMaterializers.join("\n\n")}`
+            : undefined,
+        serializers
+            ? `// typed -> Value serializers (final return boundary only): canonical observation for the equivalence pin.\n${serializers}`
+            : undefined,
+        `// RAW-ABI struct-native runners: the REAL de-box exec path (called by bind_raw).\n${runners}`,
+        bindRaw,
+    ];
+    const typedBody = sections.filter((s) => !!s).join("\n\n");
+    // Force the RunPlan-path imports the raw runner needs (run_plan/OpSpec/ExecOutcome). Ports are
+    // Value-space, so the straight-line body's expression helpers are reused unchanged. relationKind
+    // is needed when a raw op literal carries a relationKind (parent-field child/relation nodes, #74).
+    setRustForceRunPlanImports({
+        runPlan: true,
+        relationKind: /\bRelationKind\b/.test(typedBody),
+        json: /\bjson!\(/.test(typedBody),
+    });
+    const straightlineCode = rustStraightlineEmitter.emit(ctx);
+    setRustForceRunPlanImports(null);
+    // The RAW module reuses the straight-line body as a SUBSTRATE (its expression helpers drive the
+    // Value-space ports), but drives dispatch through bind_raw — so the boxed bind/Bound/run_* and the
+    // boxed-only marshal helpers are unused in this artifact. A module-level allow keeps the generated
+    // RAW module clippy -D warnings clean without hand-editing the shared straight-line emitter. This
+    // is a GENERATED-TOOLKIT allowance on dead SUBSTRATE, not a blanket allow on the de-box path: the
+    // de-box (marshal_raw_*, run_typed_raw_*, bind_raw) is exercised and asserted by the anti-sham gate.
+    const moduleAllow = `#![allow(dead_code, unused_imports)]\n`;
+    return `${moduleAllow}${straightlineCode.replace(/\n+$/, "\n")}\n${typedBody}\n`;
+}
+/**
+ * rustRawAbiEmitter — language id `rust-typed-raw` (bc#76). Emits the straight-line body (for
+ * untyped components / helpers) plus the RAW-ABI de-boxed layer (struct materialized directly from
+ * RawValue) and the bind_raw surface. Requires at least one outType/outputType annotation.
+ */
+export const rustRawAbiEmitter = {
+    language: "rust-typed-raw",
+    fileExtension: ".rs",
+    defaultRuntimeImport: "behavior_contracts",
+    filenameHint: "behaviors_typed_raw_generated.rs",
+    emit,
+};
+//# sourceMappingURL=emit-raw-abi-rust.js.map

package/dist/generator/emit-raw-abi-rust.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-raw-abi-rust.js","sourceRoot":"","sources":["../../src/generator/emit-raw-abi-rust.ts"],"names":[],"mappings":"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"}

package/dist/generator/emit-straightline-typed-go.d.ts

@@ -27,13 +27,106 @@
  * `outType`/`outputType` が IR のどこにも無ければ typed 層は emit されず、出力は `go-straightline` と
  * byte-identical（後方互換 pin）。
  */
-import type { EmitterPlugin } from "./core.js";
-import { type TypedMaterializer } from "./typed.js";
+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 { Component } from "../behavior.js";
+/** 可搬スカラ → Go の具体型名（de-box 後の struct field 型）。int/float は int64/float64 で区別。 */
+declare function goScalar(scalar: "string" | "int" | "float" | "bool" | "null"): string;
+/** TypeRef を Go の具体型名へ（named→struct 名、arr→slice、opt→ポインタ、scalar→具体型）。 */
+declare function renderTypeRef(ref: TypeRef): string;
+/** 型プランの named obj を Go struct 宣言へ（decls 順＝決定的）。field は宣言順・export 名。gofmt と同じ
+ * 列アラインで綴じる（field 名列・型列を最大幅に揃える — 生成物が gofmt clean になるよう）。 */
+declare function emitTypeDecls(plan: TypePlan): string;
+/** wire field 名 → Go の export struct field 名（決定的・一意）。元名は struct コメント/marshaller で保持。 */
+declare function goFieldName(wire: string): string;
+/**
+ * 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。
+ */
+declare function emitMarshallers(plan: TypePlan): string;
+/**
+ * serializeTyped — 具体 typed 値式を canonical 直列化用の動的 Value へ戻す式（観測等価 pin）。exec は
+ * typed のまま進み、component 境界でだけ Value 化して golden と突き合わせる。named→ser_T*、scalar は
+ * そのまま 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 と同規律）。 */
+declare function sanitize(name: string): string;
+/** 生成コード内の typed ローカル変数名（materialize 済み struct）。 */
+declare function typedLocal(nodeId: string): string;
+/**
+ * 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 が持つ）。
+ */
+declare function emitTypedValue(node: unknown, expected: TypeRef | undefined, typedNodes: Map<string, TypeRef>, plan: TypePlan): {
+    expr: string;
+    ref: TypeRef | undefined;
+};
+/**
+ * collectTypedNodes — component の body ノードで outType を持つもの（componentRef / map / cond）を
+ * id → 結果 TypeRef に index 化する。map/cond も struct 空間で結果を保持する（#66 de-box 拡張）。
+ */
+declare function collectTypedNodes(comp: Component, plan: TypePlan): Map<string, TypeRef>;
+/** arr/opt helper 名の決定的キー（要素型で一意化）。 */
+declare function arrHelperKey(ref: TypeRef): string;
+declare function hasAnyTypeAnnotation(ctx: EmitContext): boolean;
+/** typed component（typedView 経路で駆動するもの）か。 */
+declare function isTypedComponent(comp: Component): boolean;
+/** must 系 helper（struct-native exec の scalar/arr/opt/named de-box を単一式で使う）を emit。 */
+declare function emitMustHelpers(plan: TypePlan): string;
+/**
+ * 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）。
+ */
+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).
+ */
+export declare const goTypedInternals: {
+    PKG: string;
+    sanitize: typeof sanitize;
+    goFieldName: typeof goFieldName;
+    renderTypeRef: typeof renderTypeRef;
+    goScalar: typeof goScalar;
+    typedLocal: typeof typedLocal;
+    isTypedComponent: typeof isTypedComponent;
+    collectTypedNodes: typeof collectTypedNodes;
+    hasAnyTypeAnnotation: typeof hasAnyTypeAnnotation;
+    emitTypeDecls: typeof emitTypeDecls;
+    emitSerializers: typeof emitSerializers;
+    emitMarshallers: typeof emitMarshallers;
+    serializeTyped: typeof serializeTyped;
+    emitTypedValue: typeof emitTypedValue;
+    arrHelperKey: typeof arrHelperKey;
+    emitMustHelpers: typeof emitMustHelpers;
+    emitArrOptNodeHelpers: typeof emitArrOptNodeHelpers;
+    buildComponentPlanForTyped: (comp: Component) => import("./straightline.js").ComponentPlan;
+    emitOpsLiteral: (plan: import("./straightline.js").ComponentPlan) => string;
+    emitBehaviorPlanLiteral: (plan: unknown) => string;
+    goPortVar: (name: string) => string;
+    setGoForceRunPlanHelpers: typeof setGoForceRunPlanHelpers;
+    goStraightlineEmitter: EmitterPlugin;
+};
+export {};
 //# sourceMappingURL=emit-straightline-typed-go.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"emit-straightline-typed-go.d.ts","sourceRoot":"","sources":["../../src/generator/emit-straightline-typed-go.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,KAAK,EAAe,aAAa,EAAE,MAAM,WAAW,CAAC;AAE5D,OAAO,EAOL,KAAK,iBAAiB,EACvB,MAAM,YAAY,CAAC;AAiPpB,eAAO,MAAM,mBAAmB,EAAE,iBAOjC,CAAC;AA03BF;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,aAM5B,CAAC"}
+{"version":3,"file":"emit-straightline-typed-go.d.ts","sourceRoot":"","sources":["../../src/generator/emit-straightline-typed-go.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE5D,OAAO,EAIL,KAAK,QAAQ,EACb,KAAK,OAAO,EAEZ,KAAK,iBAAiB,EACvB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAkD,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAGrH,OAAO,KAAK,EAAE,SAAS,EAAkC,MAAM,gBAAgB,CAAC;AAOhF,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;AA0ID;;;;GAIG;AACH,iBAAS,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,GAAG,MAAM,CAYhF;AAOD,eAAO,MAAM,mBAAmB,EAAE,iBAOjC,CAAC;AAIF,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;AAoBD;;;;;;;;;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;AAgKD;;;GAGG;AACH,iBAAS,iBAAiB,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,QAAQ,GAAG,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAOhF;AAuRD,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;AAyKD;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,aAM5B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;uCAkBQ,SAAS;;;;;;CAO7C,CAAC"}

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

@@ -1077,4 +1077,35 @@ export const goTypedEmitter = {
     filenameHint: "behaviors.typed.generated.go",
     emit,
 };
+/**
+ * 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).
+ */
+export const goTypedInternals = {
+    PKG,
+    sanitize,
+    goFieldName,
+    renderTypeRef,
+    goScalar,
+    typedLocal,
+    isTypedComponent,
+    collectTypedNodes,
+    hasAnyTypeAnnotation,
+    emitTypeDecls,
+    emitSerializers,
+    emitMarshallers,
+    serializeTyped,
+    emitTypedValue,
+    arrHelperKey,
+    emitMustHelpers,
+    emitArrOptNodeHelpers,
+    buildComponentPlanForTyped: (comp) => buildComponentPlan(comp, goStraightlineInternals.dialect, PORT_SCOPE),
+    emitOpsLiteral: goStraightlineInternals.emitOpsLiteral,
+    emitBehaviorPlanLiteral: goStraightlineInternals.emitBehaviorPlanLiteral,
+    goPortVar: goStraightlineInternals.goPortVar,
+    setGoForceRunPlanHelpers,
+    goStraightlineEmitter,
+};
 //# sourceMappingURL=emit-straightline-typed-go.js.map