behavior-contracts 0.1.3 → 0.2.1

package/dist/generator/emit-rust.js

@@ -0,0 +1,125 @@
+import { emitDocLiteral } from "./literal.js";
+function rustStrLit(s) {
+    // 識別子・fingerprint 用（ASCII 前提だが JSON エスケープで安全側に倒す）。
+    return JSON.stringify(s);
+}
+/** rustfmt の fits-on-one-line 規則を模倣した COMPONENT_NAMES 配列 emit。 */
+function componentNamesConst(names) {
+    const items = names.map(rustStrLit);
+    const oneLine = `pub const COMPONENT_NAMES: [&str; ${names.length}] = [${items.join(", ")}];`;
+    if (oneLine.length <= 100)
+        return oneLine;
+    return `pub const COMPONENT_NAMES: [&str; ${names.length}] = [\n${items.map((s) => `    ${s},`).join("\n")}\n];`;
+}
+function emit(ctx) {
+    const { fingerprint, specVersions, componentNames, runtimeImport } = ctx;
+    const irLiteral = emitDocLiteral(ctx.ir, "rust", 1);
+    return `// GENERATED by behavior-contracts common generator (bc#13) — DO NOT EDIT.
+// Input: portable component-graph IR only (scp-ir-architecture.md §5/§7.4).
+// This module is the codegen endpoint (§7.3 endpoint 3): the IR is embedded as
+// NATIVE json! constructor code (compile-time checked; no JSON-text parsing at
+// runtime) and handed to the EXISTING runtime core (run_behavior) — no execution
+// logic is generated. Handlers are ALWAYS injected at the boundary
+// (IR + {effects,config,hooks} — concept.md §4.4); they are never generated.
+//
+// Const deviation (documented): serde_json::Value is not const-constructible, so
+// the IR is built ONCE on first use behind std::sync::LazyLock (requires Rust
+// >= 1.80). The first-use fail-closed checks (#208 prepared-artifact discipline)
+// run inside the initializer: a spec-version skew or fingerprint mismatch panics
+// LOUDLY before any behavior can run.
+// irFingerprint: ${fingerprint}
+
+use ${runtimeImport}::{
+    fingerprint_component_graph, run_behavior, BehaviorError, ComponentExec, SpecVersions, Value,
+};
+use serde_json::{json, Value as J};
+use std::sync::LazyLock;
+
+/// Spec versions baked at generation time (fail-closed comparison on first use).
+pub const EXPECTED_SPEC_VERSIONS: [(&str, i64); 3] =
+    [("behavior", ${specVersions.behavior}), ("expression", ${specVersions.expression}), ("plan", ${specVersions.plan})];
+
+/// FNV-1a 64 fingerprint of the source portable IR (canonical_json discipline, #208).
+pub const IR_FINGERPRINT: &str = ${rustStrLit(fingerprint)};
+
+/// Component names exposed by bind(), in IR declaration order.
+${componentNamesConst(componentNames)}
+
+/// The portable component-graph IR, built once on first use from native json!
+/// constructor code (no JSON-text parsing at runtime; see the const-deviation
+/// note in the module header).
+pub static IR: LazyLock<J> = LazyLock::new(|| {
+    let ir = json!(${irLiteral});
+    check_generated_module(&ir);
+    ir
+});
+
+fn runtime_spec_version(key: &str) -> i64 {
+    match key {
+        "behavior" => SpecVersions::BEHAVIOR,
+        "expression" => SpecVersions::EXPRESSION,
+        "plan" => SpecVersions::PLAN,
+        other => {
+            panic!("behavior-contracts generated module: unknown spec key '{other}' (fail-closed)")
+        }
+    }
+}
+
+// First-use fail-closed checks (#208 prepared-artifact discipline).
+fn check_generated_module(ir: &J) {
+    for (key, want) in EXPECTED_SPEC_VERSIONS {
+        let got = runtime_spec_version(key);
+        if got != want {
+            panic!("behavior-contracts generated module: spec-version skew for '{key}' (generated={want}, runtime={got}) — regenerate against this runtime (fail-closed)");
+        }
+    }
+    for name in COMPONENT_NAMES {
+        let found = ir["components"]
+            .as_array()
+            .is_some_and(|cs| cs.iter().any(|c| c["name"] == name));
+        if !found {
+            panic!("behavior-contracts generated module: component '{name}' missing from the embedded IR — the generated code was modified or corrupted (fail-closed)");
+        }
+    }
+    let got_fp = fingerprint_component_graph(ir).unwrap_or_else(|e| {
+        panic!(
+            "behavior-contracts generated module: fingerprint recompute failed: {e} (fail-closed)"
+        )
+    });
+    if got_fp != IR_FINGERPRINT {
+        panic!("behavior-contracts generated module: IR fingerprint mismatch (baked={IR_FINGERPRINT}, embedded literal={got_fp}) — the generated code was modified or corrupted (fail-closed)");
+    }
+}
+
+/// Injected-handler accessor over the embedded IR (see [\`bind\`]). Rust ownership
+/// makes a map of per-component closures sharing one \`&mut handlers\` impractical,
+/// so the per-component executor surface is \`call(name, input)\` with the
+/// component name checked against [\`COMPONENT_NAMES\`] by the runtime core.
+pub struct Bound<H: ComponentExec> {
+    handlers: H,
+}
+
+/// bind — inject handlers (boundary injection; catalog name → implementation)
+/// and get an executor over the embedded IR. Each \`call\` delegates to the
+/// runtime core's run_behavior (dynamic-path equivalent — §7.3). Forces the
+/// first-use fail-closed checks.
+pub fn bind<H: ComponentExec>(handlers: H) -> Bound<H> {
+    LazyLock::force(&IR);
+    Bound { handlers }
+}
+
+impl<H: ComponentExec> Bound<H> {
+    pub fn call(&mut self, name: &str, input: &[(String, Value)]) -> Result<Value, BehaviorError> {
+        run_behavior(&IR, &mut self.handlers, input, Some(name))
+    }
+}
+`;
+}
+export const rustEmitter = {
+    language: "rust",
+    fileExtension: ".rs",
+    defaultRuntimeImport: "behavior_contracts",
+    filenameHint: "behaviors_generated.rs",
+    emit,
+};
+//# sourceMappingURL=emit-rust.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"emit-rust.js","sourceRoot":"","sources":["../../src/generator/emit-rust.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9C,SAAS,UAAU,CAAC,CAAS;IAC3B,mDAAmD;IACnD,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AAC3B,CAAC;AAED,kEAAkE;AAClE,SAAS,mBAAmB,CAAC,KAAe;IAC1C,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IACpC,MAAM,OAAO,GAAG,qCAAqC,KAAK,CAAC,MAAM,QAAQ,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;IAC9F,IAAI,OAAO,CAAC,MAAM,IAAI,GAAG;QAAE,OAAO,OAAO,CAAC;IAC1C,OAAO,qCAAqC,KAAK,CAAC,MAAM,UAAU,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;AACnH,CAAC;AAED,SAAS,IAAI,CAAC,GAAgB;IAC5B,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,GAAG,GAAG,CAAC;IACzE,MAAM,SAAS,GAAG,cAAc,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;IACpD,OAAO;;;;;;;;;;;;;oBAaW,WAAW;;MAEzB,aAAa;;;;;;;;oBAQC,YAAY,CAAC,QAAQ,qBAAqB,YAAY,CAAC,UAAU,eAAe,YAAY,CAAC,IAAI;;;mCAGlF,UAAU,CAAC,WAAW,CAAC;;;EAGxD,mBAAmB,CAAC,cAAc,CAAC;;;;;;qBAMhB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgE7B,CAAC;AACF,CAAC;AAED,MAAM,CAAC,MAAM,WAAW,GAAkB;IACxC,QAAQ,EAAE,MAAM;IAChB,aAAa,EAAE,KAAK;IACpB,oBAAoB,EAAE,oBAAoB;IAC1C,YAAY,EAAE,wBAAwB;IACtC,IAAI;CACL,CAAC"}

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

@@ -0,0 +1,77 @@
+/**
+ * emit-straightline-go.ts — Go 直線 emitter（bc#38 / Layer A2, de-interpretation）。
+ *
+ * typed-codegen.md §4.1 の Go 具体化。language-neutral な {@link StraightlineDialect} を
+ * 実装し、component ごとに「plan を A0 の `RunPlan` primitive で直呼び・各ノードの port 評価と
+ * handler 呼びを直線展開した」ネイティブ **Go** 関数を emit する。生成コードは
+ * **`RunBehavior` の tree-walk（nodeKind ディスパッチ / evalPorts / 汎用 output 評価）を
+ * 経由しない**（A1 と同じ骨組み）。
+ *
+ * 式の綴じ方（A2 の眼目 = Phase B の脱解釈利得 — TS oracle と決定的に異なる点）:
+ *   - **単純式はネイティブ化する（AC#2）**:
+ *       - `ref` / `refOpt` → 生成モジュール内の native Go helper（`slRef` / `slRefOpt`）で
+ *         `*Obj.Get` を直接歩く scope/field アクセス。`EvaluateExpression` も `Prim*` も呼ばない。
+ *       - `concat`  → native Go `strings.Builder` 連結（`slConcat`。part は再帰的に native emit）。
+ *     これで単純 port の式ツリー `evaluate()` 解釈が生成コードから**消える**。native helper は
+ *     expr.go の意味論（`UNKNOWN_BINDING` / `NULL_REF` / `MISSING_PROP` / `TYPE_MISMATCH` /
+ *     `refOpt` の null 伝播 / concat の「string 以外は TYPE_MISMATCH」/ arity>=2）を
+ *     **同じ Failure code で**再現する（意味論の等価は conformance で pin）。
+ *   - **overflow / 短絡系はネイティブ化しない**: `add`/`sub`/`mul`/`neg`/`div`/`mod` は
+ *     INT_OVERFLOW / PRECISION_LOSS / MOD_ZERO 等の fail-closed 意味論、`and`/`or`/`cond`/
+ *     `coalesce` は短絡（未評価 IR を渡して primitive 内 evaluate が短絡）を保存するため、
+ *     A0 primitive SSoT（`Prim*`）を直呼びする（再実装しない）。`eq`/`ne`/比較/`obj`/`arr`/
+ *     `len`/`int`/`float` も SSoT を呼ぶ（型判定・code-point 順・checked リテラルの一本化）。
+ *   - 上記いずれにも当たらないむき出しスカラ（cond then/else の bare リテラル等）は `EvalExpr`
+ *     （同一 SSoT）へ落とす（型判定を生成コードに残さない）。
+ *
+ * この emitter は A1 の TS golden oracle と観測等価（値・発行 op 列・Failure）であることを
+ * conformance（codegen-straightline.test.ts の Go 節）で実 Go toolchain 実行により pin する。
+ */
+import type { EmitterPlugin } from "./core.js";
+import { type ComponentPlan, type StraightlineDialect } from "./straightline.js";
+/**
+ * emitExpr — Expression IR ノードを「scope を受けて (Value, error) を返す」Go 式に落とす。
+ *
+ * 単純式は **native Go helper** へ（脱解釈 — AC#2）、overflow/短絡系は A0 primitive SSoT へ、
+ * むき出しスカラは EvalExpr（同一 SSoT）へ落とす。生成される Go 式はどれも `(Value, error)` を
+ * 返すので、直線関数側は `must(<expr>)` で 1 行に畳んで scope へ束ねる。
+ *   - `{ref:[...]}`    → `${PKG}.slRef(<path>, scope)`      （native scope/field walk）
+ *   - `{refOpt:[...]}` → `${PKG}? no — slRefOpt`            （native, null 伝播）
+ *   - `{concat:[...]}` → `slConcat([]slPart{...}, scope)`   （native strings.Builder）
+ *   - overflow/短絡    → `${PKG}.PrimAdd(...)` 等            （SSoT 直呼び）
+ *   - bare scalar      → `${PKG}.EvalExpr(<lit>, scope)`    （SSoT）
+ * slRef/slRefOpt/slConcat は **生成モジュール内の native helper**（`EvaluateExpression`/`Prim*`
+ * を呼ばない）で、pure ref/concat の生成コードには evaluate/primitive 呼びが一切現れない
+ * （AC#2 の構造的 grep 証明）。
+ */
+declare function emitExpr(node: unknown, scopeVar: string): string;
+/** ops リテラル（RunPlan に渡す []OpSpec の Go リテラル）を綴じる。 */
+declare function emitOpsLiteral(plan: ComponentPlan): string;
+/** port ローカル変数名（Go 識別子として安全・一意）。宣言順に p0,p1,… を index で衝突回避。 */
+declare function goPortVar(name: string): string;
+/** behavior plan（{groups, concurrency}）を *ExecutionPlanSpec Go リテラルへ。 */
+declare function emitBehaviorPlanLiteral(plan: unknown): string;
+/** component 名を Go 関数名に使える形へ（決定的。名前一意は DUPLICATE_COMPONENT で保証）。 */
+declare function sanitize(name: string): string;
+/**
+ * go-typed（bc#47）が struct-native exec を綴じるために再利用する内部 emit ヘルパ。straight-line の
+ * plan/handler-dispatch SSoT（RunPlan + ExecHandler + native/primitive port eval）をそのまま使い、
+ * 「結果を Value scope でなく struct scope に持つ」差分だけを typed 側で足すための seam。runtime 語彙
+ * （PKG）と ops/plan リテラル・式 emit を共有する（意味論の二重実装を避ける）。
+ */
+export declare const goStraightlineInternals: {
+    PKG: string;
+    emitExpr: typeof emitExpr;
+    emitOpsLiteral: typeof emitOpsLiteral;
+    emitBehaviorPlanLiteral: typeof emitBehaviorPlanLiteral;
+    goPortVar: typeof goPortVar;
+    sanitize: typeof sanitize;
+    dialect: StraightlineDialect;
+};
+/**
+ * goStraightlineEmitter — 言語識別子 `"go-straightline"` の emitter plugin。
+ * 既存の `go`（リテラル焼き込み・endpoint 3-literal）と併存する additive な第2モード。
+ */
+export declare const goStraightlineEmitter: EmitterPlugin;
+export {};
+//# sourceMappingURL=emit-straightline-go.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"emit-straightline-go.d.ts","sourceRoot":"","sources":["../../src/generator/emit-straightline-go.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,KAAK,EAAe,aAAa,EAAE,MAAM,WAAW,CAAC;AAE5D,OAAO,EAEL,KAAK,aAAa,EAElB,KAAK,mBAAmB,EACzB,MAAM,mBAAmB,CAAC;AAyD3B;;;;;;;;;;;;;;GAcG;AACH,iBAAS,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CA6BzD;AA2BD,oDAAoD;AACpD,iBAAS,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CASnD;AAqCD,+DAA+D;AAC/D,iBAAS,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvC;AAqND,yEAAyE;AACzE,iBAAS,uBAAuB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAMtD;AAED,oEAAoE;AACpE,iBAAS,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtC;AAkLD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;CAQnC,CAAC;AAMF;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,aAMnC,CAAC"}