behavior-contracts 0.2.5 → 0.3.0

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-go.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"emit-straightline-go.d.ts","sourceRoot":"","sources":["../../src/generator/emit-straightline-go.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,EAAe,aAAa,EAAE,MAAM,WAAW,CAAC;AAG5D,OAAO,EAQL,KAAK,aAAa,EAIlB,KAAK,mBAAmB,EACzB,MAAM,mBAAmB,CAAC;AA+B3B,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAE1D;AA8CD;;;GAGG;AACH,iBAAS,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAuBzD;AAgHD,oEAAoE;AACpE,iBAAS,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtC;AAkZD,oDAAoD;AACpD,iBAAS,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CASnD;AAmCD,iCAAiC;AACjC,iBAAS,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvC;AAgND,yEAAyE;AACzE,iBAAS,uBAAuB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAMtD;AA0PD;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;CAQnC,CAAC;AAMF,eAAO,MAAM,qBAAqB,EAAE,aAMnC,CAAC"}
+{"version":3,"file":"emit-straightline-go.d.ts","sourceRoot":"","sources":["../../src/generator/emit-straightline-go.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,EAAe,aAAa,EAAE,MAAM,WAAW,CAAC;AAG5D,OAAO,EAQL,KAAK,aAAa,EAIlB,KAAK,mBAAmB,EACzB,MAAM,mBAAmB,CAAC;AA+B3B,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAE1D;AA8ED;;;GAGG;AACH,iBAAS,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CA4BzD;AAgHD,oEAAoE;AACpE,iBAAS,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtC;AAkZD,oDAAoD;AACpD,iBAAS,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CASnD;AAmCD,iCAAiC;AACjC,iBAAS,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvC;AAgND,yEAAyE;AACzE,iBAAS,uBAAuB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAMtD;AA0PD;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;CAQnC,CAAC;AAMF,eAAO,MAAM,qBAAqB,EAAE,aAMnC,CAAC"}

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

@@ -34,54 +34,85 @@ function resetUsage() {
     for (const k of Object.keys(usage))
         usage[k] = false;
 }
-/** IR リテラルを単一行 Go 式として emit（primitive 被演算子用）。 */
+/**
+ * bc: codegen は IR を出力してはならない（no-ir invariant）。
+ * かつては非脱解釈の式（obj/arr/scalar/演算子被演算子）を IR リテラルとして埋め込み、
+ * A0 primitive（EvalExpr 等）に実行時解釈させていた＝インタプリタの松葉杖（＝癌）。撤去する。
+ * ここに来る式はまだネイティブ脱解釈されていない ＝ ネイティブコードで emit すべき（次タスク）。
+ */
 function lit(node) {
-    return emitDocLiteralCompact(node, "go", "$", usage);
+    throw new Error(`codegen no-ir invariant: refusing to emit IR literal for ${JSON.stringify(node).slice(0, 100)} — de-interpret this expression to native code (next task)`);
 }
-/** args 配列（binary/unary primitive の被演算子）を個別 IR リテラルへ落として `, ` 連結。 */
-function argList(arg) {
-    return arg.map((a) => lit(a)).join(", ");
+/** 被演算子 node を native ExprFn thunk（scope→評価済み Value）へ。primitive が短絡/評価順を制御。 */
+function thunk(node) {
+    return `func(s *${PKG}.Obj) (${PKG}.Value, error) { return ${emitExpr(node, "s")} }`;
+}
+/** JS number → Go float64 リテラル（整数表記には `.0` を補う。指数/小数はそのまま）。 */
+function goFloatLit(n) {
+    const s = String(n);
+    return /[.eE]/.test(s) ? s : `${s}.0`;
 }
 /**
- * OP_PRIM — overflow/短絡/型判定を持つ演算子 → A0 primitive 直呼びの綴じ方。
- * 命名は go/primitives.go の `Prim*`。被演算子は expr.go の Expr 契約どおり**未評価 IR リテラル**。
- * NB: ここに `ref`/`refOpt`/`concat` は無い（native 化する — AC#2）。
+ * OP_PRIM — op → native Go 式（bc no-ir invariant: IR は一切 emit しない）。被演算子は
+ * `thunk()` で native emit した評価済み Value を返すクロージャにして `*Native` primitive へ渡す。
+ * 短絡（and/or/coalesce/cond）は primitive が thunk を条件付きで呼ぶ（採用側のみ評価）。意味論 SSoT
+ * は go/expr.go の value-core（native primitive が委譲）。`ref`/`refOpt`/`concat` は上で native 化済み。
  */
+const bin = (fn) => (a, s) => {
+    const [x, y] = a;
+    return `${PKG}.${fn}(${thunk(x)}, ${thunk(y)}, ${s})`;
+};
+const un = (fn) => (a, s) => {
+    const [x] = a;
+    return `${PKG}.${fn}(${thunk(x)}, ${s})`;
+};
 const OP_PRIM = {
-    int: (a, s) => `${PKG}.PrimIntLit(${lit(a)}, ${s})`,
-    float: (a, s) => `${PKG}.PrimFloatLit(${lit(a)}, ${s})`,
-    obj: (a, s) => `${PKG}.PrimObj(${lit(a)}, ${s})`,
-    arr: (a, s) => `${PKG}.PrimArr(${lit(a)}, ${s})`,
-    add: (a, s) => `${PKG}.PrimAdd(${argList(a)}, ${s})`,
-    sub: (a, s) => `${PKG}.PrimSub(${argList(a)}, ${s})`,
-    mul: (a, s) => `${PKG}.PrimMul(${argList(a)}, ${s})`,
-    neg: (a, s) => `${PKG}.PrimNeg(${argList(a)}, ${s})`,
-    div: (a, s) => `${PKG}.PrimDiv(${argList(a)}, ${s})`,
-    mod: (a, s) => `${PKG}.PrimMod(${argList(a)}, ${s})`,
-    eq: (a, s) => `${PKG}.PrimEq(${argList(a)}, ${s})`,
-    ne: (a, s) => `${PKG}.PrimNe(${argList(a)}, ${s})`,
-    lt: (a, s) => `${PKG}.PrimLt(${argList(a)}, ${s})`,
-    le: (a, s) => `${PKG}.PrimLe(${argList(a)}, ${s})`,
-    gt: (a, s) => `${PKG}.PrimGt(${argList(a)}, ${s})`,
-    ge: (a, s) => `${PKG}.PrimGe(${argList(a)}, ${s})`,
-    and: (a, s) => `${PKG}.PrimAnd(${argList(a)}, ${s})`,
-    or: (a, s) => `${PKG}.PrimOr(${argList(a)}, ${s})`,
-    not: (a, s) => `${PKG}.PrimNot(${argList(a)}, ${s})`,
-    coalesce: (a, s) => `${PKG}.PrimCoalesce(${argList(a)}, ${s})`,
-    cond: (a, s) => `${PKG}.PrimCond(${argList(a)}, ${s})`,
-    len: (a, s) => `${PKG}.PrimLen(${argList(a)}, ${s})`,
+    int: (a) => `${PKG}.IntLitNative(${JSON.stringify(a)})`,
+    float: (a) => `${PKG}.FloatLitNative(${goFloatLit(a)})`,
+    obj: (a, s) => {
+        const obj = a;
+        const keys = Object.keys(obj);
+        const keyLits = keys.map((k) => JSON.stringify(k)).join(", ");
+        const vals = keys.map((k) => thunk(obj[k])).join(", ");
+        return `${PKG}.ObjNative([]string{${keyLits}}, []${PKG}.ExprFn{${vals}}, ${s})`;
+    },
+    arr: (a, s) => `${PKG}.ArrNative([]${PKG}.ExprFn{${a.map((e) => thunk(e)).join(", ")}}, ${s})`,
+    add: bin("AddNative"),
+    sub: bin("SubNative"),
+    mul: bin("MulNative"),
+    neg: un("NegNative"),
+    div: bin("DivNative"),
+    mod: bin("ModNative"),
+    eq: bin("EqNative"),
+    ne: bin("NeNative"),
+    lt: bin("LtNative"),
+    le: bin("LeNative"),
+    gt: bin("GtNative"),
+    ge: bin("GeNative"),
+    and: bin("AndNative"),
+    or: bin("OrNative"),
+    not: un("NotNative"),
+    coalesce: bin("CoalesceNative"),
+    cond: (a, s) => {
+        const [c, t, e] = a;
+        return `${PKG}.CondNative(${thunk(c)}, ${thunk(t)}, ${thunk(e)}, ${s})`;
+    },
+    len: un("LenNative"),
 };
 /**
  * emitExpr — Expression IR ノードを「scope を受けて (Value, error) を返す」Go 式に落とす
  * （**dynamic 式専用**の legacy 経路 — RunPlan 経路と typed emitter が流用する seam）。
  */
 function emitExpr(node, scopeVar) {
+    // bare スカラリテラル → native Value（evaluate 非経由）。
     if (node === null)
         return `slVal(nil)`;
     if (typeof node === "boolean")
         return `slVal(${node ? "true" : "false"})`;
     if (typeof node === "string")
         return `slVal(${JSON.stringify(node)})`;
+    if (typeof node === "number")
+        return `${PKG}.NumberLitNative(${goFloatLit(node)})`;
     if (node !== null && typeof node === "object" && !Array.isArray(node)) {
         const keys = Object.keys(node);
         if (keys.length === 1) {
@@ -101,7 +132,8 @@ function emitExpr(node, scopeVar) {
                 return prim(arg, scopeVar);
         }
     }
-    return `${PKG}.EvalExpr(${lit(node)}, ${scopeVar})`;
+    // 未知形（Portability Guard 通過済みなので通常到達しない）。IR は出力せず生成時に loud に落とす。
+    throw new Error(`straight-line go: cannot de-interpret node to native (no IR output): ${JSON.stringify(node).slice(0, 100)}`);
 }
 /** ref/refOpt の path（string リテラル配列）を Go の `[]string{...}` へ。非 string は不正 IR。 */
 function emitStringPath(arg) {