@mawaru/sdk 0.5.0

package/_schemas/graph.test.ts

@@ -0,0 +1,872 @@
+import { describe, expect, it } from "vitest"
+import {
+  aiConfigSchema,
+  humanConfigSchema,
+  programConfigSchema,
+  refsDefaultsOf,
+  saveGraphBodySchema,
+  waitConfigSchema,
+} from "./graph.js"
+import type { GraphPort } from "./node.js"
+import { envelopeSchemaOf } from "./port-spec.js"
+
+// テスト用の決定的な uuid（common は node 型定義を持たないため crypto は使わない）
+let seq = 0
+const uuid = () => `00000000-0000-4000-8000-${String(++seq).padStart(12, "0")}`
+
+describe("waitConfigSchema", () => {
+  it("duration: 正の整数秒を受け付ける", () => {
+    const parsed = waitConfigSchema.parse({
+      wait_type: "duration",
+      duration_seconds: 90,
+    })
+    expect(parsed).toEqual({ wait_type: "duration", duration_seconds: 90 })
+  })
+
+  it("duration: 0・負数・非整数を拒否する", () => {
+    for (const duration_seconds of [0, -1, 1.5]) {
+      expect(() =>
+        waitConfigSchema.parse({ wait_type: "duration", duration_seconds }),
+      ).toThrow()
+    }
+  })
+
+  it("until: ISO 日時（Z / オフセット）を受け付ける", () => {
+    for (const until_at of [
+      "2026-07-10T09:00:00.000Z",
+      "2026-07-10T09:00:00+09:00",
+    ]) {
+      expect(waitConfigSchema.parse({ wait_type: "until", until_at })).toEqual({
+        wait_type: "until",
+        until_at,
+      })
+    }
+  })
+
+  it("until: 日時でない文字列を拒否する", () => {
+    expect(() =>
+      waitConfigSchema.parse({ wait_type: "until", until_at: "2026-07-10" }),
+    ).toThrow()
+  })
+
+  it("cron: 非空の式を受け付ける（式の妥当性検証は保存時）", () => {
+    expect(
+      waitConfigSchema.parse({ wait_type: "cron", cron_expr: "0 9 * * 1-5" }),
+    ).toEqual({ wait_type: "cron", cron_expr: "0 9 * * 1-5" })
+  })
+
+  it("cron: 空文字を拒否する", () => {
+    expect(() =>
+      waitConfigSchema.parse({ wait_type: "cron", cron_expr: "" }),
+    ).toThrow()
+  })
+
+  it("種別と値カラムの取り違えを拒否する", () => {
+    // duration に until_at だけ、など判別後の必須欠落
+    expect(() =>
+      waitConfigSchema.parse({
+        wait_type: "duration",
+        until_at: "2026-07-10T09:00:00.000Z",
+      }),
+    ).toThrow()
+    expect(() =>
+      waitConfigSchema.parse({ wait_type: "until", duration_seconds: 60 }),
+    ).toThrow()
+  })
+
+  it("未知の wait_type を拒否する", () => {
+    expect(() => waitConfigSchema.parse({ wait_type: "forever" })).toThrow()
+  })
+})
+
+// ---- グラフ一括保存の契約（ports 配列＋port_id 接続。ポートのテーブル化.md） ----
+
+const port = (io: "in" | "out", key: string): GraphPort => ({
+  id: uuid(),
+  io,
+  key,
+  name: key,
+  schema: { type: "object" },
+})
+
+// ai の out 宣言は封筒型 { data, description } 固定なので、デフォルトノードは
+// data=テキストの封筒を持つ
+const textEnvelope = envelopeSchemaOf({ type: "string" })
+
+const makeNode = (ports?: GraphPort[]) => ({
+  id: uuid(),
+  kind: "ai" as const,
+  name: "ノード",
+  ports: ports ?? [
+    port("in", "in"),
+    { ...port("out", "main"), schema: textEnvelope },
+  ],
+  position_x: 0,
+  position_y: 0,
+})
+// kind 別のテストノード（{...makeNode(), kind: "human"} 等）も受けられるよう広げる
+type TestNode = Omit<ReturnType<typeof makeNode>, "kind"> & { kind: string }
+
+const inOf = (node: TestNode): GraphPort => {
+  const p = node.ports.find((p) => p.io === "in")
+  if (!p) throw new Error("in port not found")
+  return p
+}
+const outOf = (node: TestNode): GraphPort => {
+  const p = node.ports.find((p) => p.io === "out")
+  if (!p) throw new Error("out port not found")
+  return p
+}
+const connect = (from: TestNode, to: TestNode) => ({
+  from_port_id: outOf(from).id,
+  to_port_id: inOf(to).id,
+})
+
+describe("programConfigSchema", () => {
+  it("program_dir を受け付ける（ref は省略可・日本語可）", () => {
+    expect(programConfigSchema.parse({ program_dir: "sendReply" })).toEqual({
+      program_dir: "sendReply",
+    })
+    expect(
+      programConfigSchema.parse({ program_dir: "返信を送る", ref: "develop" })
+        .ref,
+    ).toBe("develop")
+  })
+
+  it("空の program_dir を拒否する", () => {
+    expect(() => programConfigSchema.parse({ program_dir: "" })).toThrow()
+  })
+
+  it("ディレクトリ名でないもの（パス区切り・. ..）を拒否する", () => {
+    for (const program_dir of ["a/b", "..\\x", ".", ".."]) {
+      expect(() => programConfigSchema.parse({ program_dir })).toThrow()
+    }
+  })
+})
+
+describe("aiConfigSchema", () => {
+  it("ai_dir を受け付ける（ref は省略可・日本語可）", () => {
+    expect(aiConfigSchema.parse({ ai_dir: "draftReply" })).toEqual({
+      ai_dir: "draftReply",
+    })
+    expect(
+      aiConfigSchema.parse({ ai_dir: "返信下書き", ref: "develop" }).ref,
+    ).toBe("develop")
+  })
+
+  it("空の ai_dir を拒否する", () => {
+    expect(() => aiConfigSchema.parse({ ai_dir: "" })).toThrow()
+  })
+
+  it("ディレクトリ名でないもの（パス区切り・. ..）を拒否する", () => {
+    for (const ai_dir of ["a/b", "..\\x", ".", ".."]) {
+      expect(() => aiConfigSchema.parse({ ai_dir })).toThrow()
+    }
+  })
+})
+
+describe("humanConfigSchema", () => {
+  it("既定値を補う（fixed・any・units 空＝tenant の誰でも）", () => {
+    expect(humanConfigSchema.parse({ assignment: {} })).toEqual({
+      assignment: { strategy: "fixed", approval_mode: "any", units: [] },
+    })
+  })
+
+  it("fixed：1ユニット（複数人の and/or）を受け付ける", () => {
+    const u1 = uuid()
+    const u2 = uuid()
+    const parsed = humanConfigSchema.parse({
+      assignment: {
+        strategy: "fixed",
+        approval_mode: "all",
+        units: [[u1, u2]],
+      },
+    })
+    expect(parsed.assignment.units).toEqual([[u1, u2]])
+  })
+
+  it("fixed：ユニットが2つ以上は拒否する", () => {
+    expect(() =>
+      humanConfigSchema.parse({
+        assignment: { strategy: "fixed", units: [[uuid()], [uuid()]] },
+      }),
+    ).toThrow()
+  })
+
+  it("round_robin：2ユニット以上を受け付ける（個人・グループ混在可）", () => {
+    const parsed = humanConfigSchema.parse({
+      assignment: {
+        strategy: "round_robin",
+        units: [[uuid()], [uuid(), uuid()]],
+      },
+    })
+    expect(parsed.assignment.units).toHaveLength(2)
+  })
+
+  it("round_robin：ユニット1つ以下は拒否する（交代の意味がない）", () => {
+    for (const units of [[], [[uuid()]]]) {
+      expect(() =>
+        humanConfigSchema.parse({
+          assignment: { strategy: "round_robin", units },
+        }),
+      ).toThrow()
+    }
+  })
+
+  it("空ユニット・ユニット内の user_id 重複を拒否する（ユニットをまたぐ重複は許す）", () => {
+    const u1 = uuid()
+    expect(() =>
+      humanConfigSchema.parse({ assignment: { units: [[]] } }),
+    ).toThrow()
+    expect(() =>
+      humanConfigSchema.parse({
+        assignment: { strategy: "fixed", units: [[u1, u1]] },
+      }),
+    ).toThrow()
+    // またぐ重複は許す（「Aは毎回・相手が交代」のような形を排除しない）
+    expect(() =>
+      humanConfigSchema.parse({
+        assignment: { strategy: "round_robin", units: [[u1], [u1, uuid()]] },
+      }),
+    ).not.toThrow()
+  })
+
+  it("uuid でない user_id を拒否する", () => {
+    expect(() =>
+      humanConfigSchema.parse({ assignment: { units: [["not-a-uuid"]] } }),
+    ).toThrow()
+  })
+})
+
+describe("saveGraphBodySchema", () => {
+  it("ports 配列を持つ node と port_id 接続を受け付ける（既定値も補われる）", () => {
+    const a = makeNode()
+    const b = makeNode()
+    const parsed = saveGraphBodySchema.parse({
+      nodes: [a, b],
+      connections: [
+        {
+          from_port_id: outOf(a).id,
+          to_port_id: inOf(b).id,
+        },
+      ],
+    })
+    expect(parsed.nodes[0]?.hooks).toEqual([])
+    expect(parsed.connections[0]).toEqual({
+      from_port_id: outOf(a).id,
+      to_port_id: inOf(b).id,
+    })
+  })
+
+  it("node id の重複を拒否する", () => {
+    const a = makeNode()
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [a, { ...makeNode(), id: a.id }],
+        connections: [],
+      }),
+    ).toThrow(/node の id が重複/)
+  })
+
+  it("port id の重複（ノードを跨いでも）を拒否する", () => {
+    const shared = port("out", "main")
+    const a = makeNode([port("in", "in"), shared])
+    const b = makeNode([port("in", "in"), { ...shared, key: "other" }])
+    expect(() =>
+      saveGraphBodySchema.parse({ nodes: [a, b], connections: [] }),
+    ).toThrow(/port の id が重複/)
+  })
+
+  it("同一 node 内の (io, key) 重複を拒否する", () => {
+    const a = makeNode([
+      port("in", "in"),
+      port("out", "main"),
+      port("out", "main"),
+    ])
+    expect(() =>
+      saveGraphBodySchema.parse({ nodes: [a], connections: [] }),
+    ).toThrow(/key が重複/)
+  })
+
+  it("in ポートがちょうど1つでない node を拒否する（0個・2個）", () => {
+    const zero = makeNode([port("out", "main")])
+    expect(() =>
+      saveGraphBodySchema.parse({ nodes: [zero], connections: [] }),
+    ).toThrow(/in ポート/)
+
+    const two = makeNode([
+      port("in", "in"),
+      port("in", "in2"),
+      port("out", "main"),
+    ])
+    expect(() =>
+      saveGraphBodySchema.parse({ nodes: [two], connections: [] }),
+    ).toThrow(/in ポート/)
+  })
+
+  it("out ポート0個の node を拒否する（最低1ポート）", () => {
+    const noOut = makeNode([port("in", "in")])
+    expect(() =>
+      saveGraphBodySchema.parse({ nodes: [noOut], connections: [] }),
+    ).toThrow(/out ポート/)
+  })
+
+  it("グラフ内に存在しない port への接続を拒否する", () => {
+    const a = makeNode()
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [a],
+        connections: [{ from_port_id: outOf(a).id, to_port_id: uuid() }],
+      }),
+    ).toThrow(/接続先/)
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [a],
+        connections: [{ from_port_id: uuid(), to_port_id: inOf(a).id }],
+      }),
+    ).toThrow(/接続元/)
+  })
+
+  it("向き違反（from が in ポート・to が out ポート）を拒否する", () => {
+    const a = makeNode()
+    const b = makeNode()
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [a, b],
+        connections: [
+          // from に in ポート
+          { from_port_id: inOf(a).id, to_port_id: inOf(b).id },
+        ],
+      }),
+    ).toThrow(/接続元/)
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [a, b],
+        connections: [
+          // to に out ポート
+          { from_port_id: outOf(a).id, to_port_id: outOf(b).id },
+        ],
+      }),
+    ).toThrow(/接続先/)
+  })
+
+  it("同じ出力ポートから複数の接続（fan-out）を許す", () => {
+    const a = makeNode()
+    const b = makeNode()
+    const c = makeNode()
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [a, b, c],
+        connections: [
+          { from_port_id: outOf(a).id, to_port_id: inOf(b).id },
+          { from_port_id: outOf(a).id, to_port_id: inOf(c).id },
+        ],
+      }),
+    ).not.toThrow()
+  })
+
+  it("完全に同じ接続（同じ from→to の2本）を拒否する", () => {
+    const a = makeNode()
+    const b = makeNode()
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [a, b],
+        connections: [
+          { from_port_id: outOf(a).id, to_port_id: inOf(b).id },
+          { from_port_id: outOf(a).id, to_port_id: inOf(b).id },
+        ],
+      }),
+    ).toThrow(/同じ接続/)
+  })
+
+  it("同じ in ポートへの複数の接続（差し戻し）は許す", () => {
+    const a = makeNode()
+    const b = makeNode()
+    const c = makeNode()
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [a, b, c],
+        connections: [
+          { from_port_id: outOf(a).id, to_port_id: inOf(c).id },
+          { from_port_id: outOf(b).id, to_port_id: inOf(c).id },
+        ],
+      }),
+    ).not.toThrow()
+  })
+})
+
+// ---- kind 別ポート構成と型の接続バリデーション（ポートのkind別仕様.md） ----
+
+const aiEnvelope = textEnvelope
+
+const humanNode = () => ({
+  ...makeNode([
+    port("in", "in"),
+    port("out", "approve"),
+    port("out", "reject"),
+  ]),
+  kind: "human" as const,
+})
+const aiNode = () => ({
+  ...makeNode([
+    port("in", "in"),
+    { ...port("out", "main"), schema: aiEnvelope },
+  ]),
+  kind: "ai" as const,
+})
+const programNode = (inSchema: GraphPort["schema"] = {}) => ({
+  ...makeNode([{ ...port("in", "in"), schema: inSchema }, port("out", "main")]),
+  kind: "program" as const,
+})
+const outByKey = (node: TestNode, key: string): GraphPort => {
+  const p = node.ports.find((p) => p.io === "out" && p.key === key)
+  if (!p) throw new Error(`out port not found: ${key}`)
+  return p
+}
+
+describe("saveGraphBodySchema（kind 別ポート構成）", () => {
+  it("human の旧 ok/ng 構成を拒否し、in/approve/reject を受け付ける", () => {
+    expect(() =>
+      saveGraphBodySchema.parse({ nodes: [humanNode()], connections: [] }),
+    ).not.toThrow()
+    const legacy = {
+      ...makeNode([port("in", "in"), port("out", "ok"), port("out", "ng")]),
+      kind: "human" as const,
+    }
+    expect(() =>
+      saveGraphBodySchema.parse({ nodes: [legacy], connections: [] }),
+    ).toThrow(/human のポート構成/)
+  })
+
+  it("ai は out を複数持てる（key 自由。AI の複数出口＝分岐）", () => {
+    const multi = {
+      ...makeNode([
+        port("in", "in"),
+        { ...port("out", "spam"), schema: aiEnvelope },
+        { ...port("out", "sales"), schema: aiEnvelope },
+        { ...port("out", "support"), schema: aiEnvelope },
+      ]),
+      kind: "ai" as const,
+    }
+    expect(() =>
+      saveGraphBodySchema.parse({ nodes: [multi], connections: [] }),
+    ).not.toThrow()
+    // in の key は "in" 固定のまま
+    const badIn = {
+      ...makeNode([
+        port("in", "input"),
+        { ...port("out", "main"), schema: aiEnvelope },
+      ]),
+      kind: "ai" as const,
+    }
+    expect(() =>
+      saveGraphBodySchema.parse({ nodes: [badIn], connections: [] }),
+    ).toThrow(/ai の in ポート/)
+  })
+
+  it("program は out を複数持てる（key 自由）", () => {
+    const prog = {
+      ...makeNode([
+        port("in", "in"),
+        port("out", "success"),
+        port("out", "failure"),
+      ]),
+      kind: "program" as const,
+    }
+    expect(() =>
+      saveGraphBodySchema.parse({ nodes: [prog], connections: [] }),
+    ).not.toThrow()
+  })
+
+  it("ai の出力宣言が封筒型 { data, description } でないと拒否する（全出口に適用）", () => {
+    const bad = makeNode([
+      port("in", "in"),
+      { ...port("out", "main"), schema: { type: "object" } },
+    ])
+    expect(() =>
+      saveGraphBodySchema.parse({ nodes: [bad], connections: [] }),
+    ).toThrow(/封筒型 \{ data, description \}/)
+    // main 以外の出口も封筒型を強制する
+    const badExtra = makeNode([
+      port("in", "in"),
+      { ...port("out", "main"), schema: aiEnvelope },
+      { ...port("out", "extra"), schema: { type: "object" } },
+    ])
+    expect(() =>
+      saveGraphBodySchema.parse({ nodes: [badExtra], connections: [] }),
+    ).toThrow(/封筒型 \{ data, description \}/)
+    // data は任意の型でよい（カタログ外の object も通る）
+    const custom = makeNode([
+      port("in", "in"),
+      {
+        ...port("out", "main"),
+        schema: envelopeSchemaOf({
+          type: "object",
+          properties: { title: { type: "string" } },
+          required: ["title"],
+        }),
+      },
+    ])
+    expect(() =>
+      saveGraphBodySchema.parse({ nodes: [custom], connections: [] }),
+    ).not.toThrow()
+  })
+})
+
+describe("saveGraphBodySchema（型の接続バリデーション）", () => {
+  it("human の reject → ai は許可、ai 以外は拒否", () => {
+    const human = humanNode()
+    const ai = aiNode()
+    const prog = programNode()
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [human, ai],
+        connections: [
+          {
+            from_port_id: outByKey(human, "reject").id,
+            to_port_id: inOf(ai).id,
+          },
+        ],
+      }),
+    ).not.toThrow()
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [human, prog],
+        connections: [
+          {
+            from_port_id: outByKey(human, "reject").id,
+            to_port_id: inOf(prog).id,
+          },
+        ],
+      }),
+    ).toThrow(/reject.*AI ノードのみ/)
+  })
+
+  it("human の in はどの型でも接続できる（封筒型の制約は課さない）", () => {
+    const ai = aiNode()
+    const human = humanNode()
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [ai, human],
+        connections: [connect(ai, human)],
+      }),
+    ).not.toThrow()
+
+    // program out が封筒型でない（{ type: "object" } のまま）でも接続できる
+    // （input 全体を data として表示する）
+    const human2 = humanNode()
+    const progPlain = {
+      ...makeNode([
+        port("in", "in"),
+        { ...port("out", "main"), schema: { type: "object" } },
+      ]),
+      kind: "program" as const,
+    }
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [progPlain, human2],
+        connections: [connect(progPlain, human2)],
+      }),
+    ).not.toThrow()
+  })
+
+  it("program の in への接続は 伝播型 ⊆ 宣言スキーマ（human 経由の伝播込み）", () => {
+    // ai(封筒型) → human(approve は data 型に剥がれる) → program(string を要求) は通る
+    const ai = aiNode()
+    const human = humanNode()
+    const prog = programNode({ type: "string" })
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [ai, human, prog],
+        connections: [
+          connect(ai, human),
+          {
+            from_port_id: outByKey(human, "approve").id,
+            to_port_id: inOf(prog).id,
+          },
+        ],
+      }),
+    ).not.toThrow()
+
+    // program の in は接続鏡映（sticky）：宣言と型が違っても保存エラーにせず、
+    // 接続元の具体型が in に鏡映される（repo の config.json へ書き戻され、
+    // handler との型整合は SDK の typegen が担う。ポート編集のrepo書き戻し同期.md）
+    const prog2 = programNode({
+      type: "object",
+      properties: { data: { type: "number" } },
+      required: ["data"],
+    })
+    const ai2 = aiNode()
+    const human2 = humanNode()
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [ai2, human2, prog2],
+        connections: [
+          connect(ai2, human2),
+          {
+            from_port_id: outByKey(human2, "approve").id,
+            to_port_id: inOf(prog2).id,
+          },
+        ],
+      }),
+    ).not.toThrow()
+  })
+
+  it("ai の in への接続は常に許可（coerce）", () => {
+    const prog = programNode()
+    const ai = aiNode()
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [prog, ai],
+        connections: [connect(prog, ai)],
+      }),
+    ).not.toThrow()
+  })
+})
+
+describe("saveGraphBodySchema（hooks）", () => {
+  const hook = (dir = "監査ログ") => ({
+    hook_dir: dir,
+    on_input: true,
+    on_output: false,
+  })
+
+  it("program ノードの hooks 配列を受け付ける（省略時は [] が補われる）", () => {
+    const withHooks = {
+      ...programNode(),
+      hooks: [hook(), { ...hook("通知"), ref: "main" }],
+    }
+    const parsed = saveGraphBodySchema.parse({
+      nodes: [withHooks],
+      connections: [],
+    })
+    expect(parsed.nodes[0]?.hooks).toHaveLength(2)
+    expect(parsed.nodes[0]?.hooks?.[1]?.ref).toBe("main")
+
+    const without = saveGraphBodySchema.parse({
+      nodes: [programNode()],
+      connections: [],
+    })
+    expect(without.nodes[0]?.hooks).toEqual([])
+  })
+
+  it("program 以外のノードへの hooks を拒否する", () => {
+    for (const node of [makeNode(), humanNode()]) {
+      expect(() =>
+        saveGraphBodySchema.parse({
+          nodes: [{ ...node, hooks: [hook()] }],
+          connections: [],
+        }),
+      ).toThrow(/program ノード/)
+    }
+  })
+
+  it("hook_dir のパス区切り・. / .. を拒否する", () => {
+    for (const dir of ["a/b", "a\\b", ".", ".."]) {
+      expect(() =>
+        saveGraphBodySchema.parse({
+          nodes: [{ ...programNode(), hooks: [hook(dir)] }],
+          connections: [],
+        }),
+      ).toThrow(/hook_dir/)
+    }
+  })
+
+  it("同一 node 内の hook_dir 重複を拒否する", () => {
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [{ ...programNode(), hooks: [hook(), hook()] }],
+        connections: [],
+      }),
+    ).toThrow(/hook_dir が重複/)
+  })
+
+  it("on_signal を受け付ける（省略時は false が補われる）", () => {
+    const parsed = saveGraphBodySchema.parse({
+      nodes: [
+        {
+          ...programNode(),
+          hooks: [hook(), { ...hook("PR同期"), on_signal: true }],
+        },
+      ],
+      connections: [],
+    })
+    expect(parsed.nodes[0]?.hooks?.[0]?.on_signal).toBe(false)
+    expect(parsed.nodes[0]?.hooks?.[1]?.on_signal).toBe(true)
+  })
+})
+
+// ---- refs（ループ変数の定義スキーマ。ループ変数（refs）のJSON Schema化.md） ----
+
+describe("saveGraphBodySchema（refs：ループ変数の定義スキーマ）", () => {
+  it("object JSON Schema 形の refs（properties / required / default）を受け付ける", () => {
+    const refs = {
+      type: "object",
+      properties: {
+        thread_ts: { type: "string" },
+        channel: { type: "string", default: "#nitte-cs" },
+        retry_limit: { type: "number", default: 3 },
+      },
+      required: ["thread_ts"],
+    }
+    const parsed = saveGraphBodySchema.parse({
+      nodes: [makeNode()],
+      connections: [],
+      refs,
+    })
+    expect(parsed.refs).toEqual(refs)
+  })
+
+  it("省略時は空の object スキーマが補われる", () => {
+    const parsed = saveGraphBodySchema.parse({
+      nodes: [makeNode()],
+      connections: [],
+    })
+    expect(parsed.refs).toEqual({ type: "object", properties: {} })
+  })
+
+  it("properties のキーはポート key 規則（^[a-z][a-z0-9_]*$）に従う", () => {
+    for (const key of ["Reply", "reply-to", "1st", ""]) {
+      expect(() =>
+        saveGraphBodySchema.parse({
+          nodes: [makeNode()],
+          connections: [],
+          refs: { type: "object", properties: { [key]: { type: "string" } } },
+        }),
+      ).toThrow()
+    }
+  })
+
+  it("required が properties に無いキーを含むと拒否する", () => {
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [makeNode()],
+        connections: [],
+        refs: {
+          type: "object",
+          properties: { thread_ts: { type: "string" } },
+          required: ["reply_to"],
+        },
+      }),
+    ).toThrow(/required/)
+  })
+
+  it("object 以外の type・旧「値の袋」形は拒否する", () => {
+    for (const refs of [
+      { type: "string" },
+      { reply_to: "someone@example.com" },
+    ]) {
+      expect(() =>
+        saveGraphBodySchema.parse({
+          nodes: [makeNode()],
+          connections: [],
+          refs,
+        }),
+      ).toThrow()
+    }
+  })
+
+  it("旧 node 単位の refs は受け付けず strip される", () => {
+    const parsed = saveGraphBodySchema.parse({
+      nodes: [
+        {
+          ...programNode(),
+          refs: [{ key: "reply_to", schema: { type: "string" } }],
+        },
+      ],
+      connections: [],
+    })
+    expect(Object.keys(parsed.nodes[0] ?? {})).not.toContain("refs")
+  })
+})
+
+// start / end は恒等パススルー（in＋out(main)）。end は in を複数持てる
+const startNode = (): TestNode => ({
+  ...makeNode([port("in", "in"), port("out", "main")]),
+  kind: "start",
+})
+const endNode = (inKeys: string[] = ["in"]): TestNode => ({
+  ...makeNode([...inKeys.map((k) => port("in", k)), port("out", "main")]),
+  kind: "end",
+})
+
+describe("saveGraphBodySchema：開始/終了ノード（start/end kind）", () => {
+  it("start/end を含むグラフを受け付ける", () => {
+    const parsed = saveGraphBodySchema.parse({
+      nodes: [startNode(), endNode()],
+      connections: [],
+    })
+    expect(parsed.nodes.map((n) => n.kind).sort()).toEqual(["end", "start"])
+  })
+
+  it("start は最大1つ・end は最大1つ", () => {
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [startNode(), startNode()],
+        connections: [],
+      }),
+    ).toThrow(/start/)
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [endNode(), endNode()],
+        connections: [],
+      }),
+    ).toThrow(/end/)
+  })
+
+  it("end は in を複数持てる／start・他 kind は in 1つ固定", () => {
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [endNode(["in", "in_2"])],
+        connections: [],
+      }),
+    ).not.toThrow()
+    const badStart: TestNode = {
+      ...startNode(),
+      ports: [port("in", "in"), port("in", "in_2"), port("out", "main")],
+    }
+    expect(() =>
+      saveGraphBodySchema.parse({ nodes: [badStart], connections: [] }),
+    ).toThrow(/in ポートはちょうど1つ/)
+  })
+
+  it("start への接続・end からの接続を拒否する", () => {
+    const s = startNode()
+    const e = endNode()
+    const other = makeNode()
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [s, other],
+        connections: [connect(other, s)],
+      }),
+    ).toThrow(/開始ノード/)
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [e, other],
+        connections: [connect(e, other)],
+      }),
+    ).toThrow(/終了ノード/)
+  })
+})
+
+describe("refsDefaultsOf（定義スキーマ→デフォルト値の袋）", () => {
+  it("default を持つプロパティだけを値の袋に集める", () => {
+    const defaults = refsDefaultsOf({
+      type: "object",
+      properties: {
+        thread_ts: { type: "string" },
+        channel: { type: "string", default: "#nitte-cs" },
+        flags: { type: "object", default: { dry_run: true } },
+      },
+      required: ["thread_ts"],
+    })
+    expect(defaults).toEqual({
+      channel: "#nitte-cs",
+      flags: { dry_run: true },
+    })
+  })
+
+  it("properties が空なら空の袋を返す", () => {
+    expect(refsDefaultsOf({ type: "object", properties: {} })).toEqual({})
+  })
+})