@mawaru/sdk 0.13.0 → 0.15.0

package/_schemas/extract-component.ts

@@ -1,20 +1,25 @@
 import type { GraphConnection, GraphNode } from "./graph.js"
+import type { GraphPort } from "./node.js"
 
-// 矩形選択からのグループ化・コンポーネント化（ノードのグループ化・コンポーネント化.md）。
+// 矩形選択からのグループ化・コンポーネント化（ノードのグループ化・コンポーネント化.md／
+// コンポーネントの複数入口・複数出口.md）。
 // 選択境界を分類・検証し（analyze）、「子（部品）loop の graph」と「親の置換後グラフ」を
 // 生成する（build）。純関数（id 採番は newId で注入）。エディタとテストの両方から使う。
 //
-// V1 制約：component の口は in 1つ・out main 1つなので、
-// 入口（外→選択内の線の到達先ノード）は1つ・出口（選択内→外の線の出発ポート）は1つまで。
+// 境界は start / end が吸収し、成立条件は型だけで決める（配線の由来は見ない）：
+// - 入口：外→選択内の線の到達先ポート。複数可。条件は全入口ポートの型が同一なこと
+//   （子では start.main から全入口へ fan-out する）
+// - 出口：選択内→外の線の出発ポート。複数可・無条件（子では出発ポートごとに end の
+//   in を1つ作り、component の out として親へ射影する）
 
 export type ExtractAnalysis =
   | { ok: false; reason: string }
   | {
       ok: true
-      // 外部からの入力を受けるノード（入出力の無い孤立した島は null）
-      entryNodeId: string | null
-      // 外部への出力の出発ポート（同一ポートからの fan-out は1出口扱い）
-      exitPortId: string | null
+      // 外部からの入力を受けるポート（重複排除・出現順。入出力の無い孤立した島は空）
+      entryPortIds: string[]
+      // 外部への出力の出発ポート（同一ポートからの fan-out は1出口扱い。出現順）
+      exitPortIds: string[]
       internal: GraphConnection[]
       inbound: GraphConnection[]
       outbound: GraphConnection[]
@@ -26,8 +31,10 @@ export const analyzeExtractSelection = (
   selectedIds: readonly string[],
 ): ExtractAnalysis => {
   const selected = new Set(selectedIds)
-  if (selected.size < 2) {
-    return { ok: false, reason: "2つ以上のノードを選択してください" }
+  // 1ノードからコンポーネント化できる（グループ化の「2つ以上」はエディタ側の
+  // 有効条件。コンポーネントの設定値（refs）と1ノードのコンポーネント化.md）
+  if (selected.size < 1) {
+    return { ok: false, reason: "ノードを選択してください" }
   }
   const selectedNodes = nodes.filter((n) => selected.has(n.id))
   const flow = selectedNodes.find((n) => n.kind === "start" || n.kind === "end")
@@ -41,6 +48,9 @@ export const analyzeExtractSelection = (
   const nodeIdByPortId = new Map(
     nodes.flatMap((n) => n.ports.map((p) => [p.id, n.id] as const)),
   )
+  const portById = new Map(
+    nodes.flatMap((n) => n.ports.map((p) => [p.id, p] as const)),
+  )
   const internal: GraphConnection[] = []
   const inbound: GraphConnection[] = []
   const outbound: GraphConnection[] = []
@@ -52,29 +62,27 @@ export const analyzeExtractSelection = (
     else if (fromIn && !toIn) outbound.push(conn)
   }
 
-  const entryNodeIds = new Set(
-    inbound.map((c) => nodeIdByPortId.get(c.to_port_id) ?? ""),
+  // 入口ポート（重複排除・出現順）。条件は「全入口の型が同一」だけ：
+  // 起点（どの外部ポートから入るか）は見ない。ノードが前のノードを知らないのと
+  // 同じ思想を境界にも適用する（グループ化＝入口の合流の宣言）
+  const entryPortIds = [...new Set(inbound.map((c) => c.to_port_id))]
+  const entrySchemas = new Set(
+    entryPortIds.map((id) => JSON.stringify(portById.get(id)?.schema ?? {})),
   )
-  if (entryNodeIds.size > 1) {
-    return {
-      ok: false,
-      reason:
-        "外部からの入力が複数のノードに入っています（入口は1つにしてください）",
-    }
-  }
-  const exitPortIds = new Set(outbound.map((c) => c.from_port_id))
-  if (exitPortIds.size > 1) {
+  if (entrySchemas.size > 1) {
     return {
       ok: false,
       reason:
-        "外部への出力が複数のポートから出ています（出口は1つにしてください）",
+        "入口の型が揃っていません（同じ型の入口だけを1つのグループにまとめられます）",
     }
   }
+  // 出口は無条件（出発ポートごとに end の in ＝ component の out になる）
+  const exitPortIds = [...new Set(outbound.map((c) => c.from_port_id))]
 
   return {
     ok: true,
-    entryNodeId: [...entryNodeIds][0] ?? null,
-    exitPortId: [...exitPortIds][0] ?? null,
+    entryPortIds,
+    exitPortIds,
     internal,
     inbound,
     outbound,
@@ -84,24 +92,30 @@ export const analyzeExtractSelection = (
 export type ExtractPlan = {
   // 子 loop に入るノード（新 id でコピー。seed 済み start/end は含まない＝呼び出し側が足す）
   childNodes: GraphNode[]
-  // 内部接続（新 id）＋ start.main → 入口／出口 → end.in
+  // 内部接続（新 id）＋ start.main → 各入口／各出口 → end の対応する in
   childConnections: GraphConnection[]
-  // 親に置く GROUP / COMPONENT ノード（in/main・参照＝componentLoopId・選択の重心）
+  // 出口を反映した子の end ノード（出口ごとに in を持つ。出口が無ければ渡された姿のまま）
+  childEnd: GraphNode
+  // 親に置く GROUP / COMPONENT ノード（in 1つ＋出口ごとの out・参照＝componentLoopId・選択の重心）
   groupNode: GraphNode
   // 置換後の親グラフ（選択ノードを除き groupNode を足した全量。線は繋ぎ直し済み）
   parentNodes: GraphNode[]
   parentConnections: GraphConnection[]
 }
 
+// 出口が1つのときの component out キー（既存コンポーネントとの互換。
+// end の in が1つの loop は out main の1口として振る舞う）
+const SINGLE_OUT_KEY = "main"
+
 export const buildExtractPlan = (params: {
   nodes: GraphNode[]
   connections: GraphConnection[]
   selectedIds: string[]
   name: string
   componentLoopId: string
-  // 子 loop（作成済み・seed 済み）の構造ノードのポート
+  // 子 loop（作成済み・seed 済み）の構造ノードのポート／ノード
   childStartOutPortId: string
-  childEndInPortId: string
+  childEnd: GraphNode
   newId: () => string
 }): { ok: false; reason: string } | ({ ok: true } & ExtractPlan) => {
   const {
@@ -111,7 +125,7 @@ export const buildExtractPlan = (params: {
     name,
     componentLoopId,
     childStartOutPortId,
-    childEndInPortId,
+    childEnd,
     newId,
   } = params
   const analysis = analyzeExtractSelection(nodes, connections, selectedIds)
@@ -138,28 +152,64 @@ export const buildExtractPlan = (params: {
       }
     })
 
+  const portById = new Map(
+    nodes.flatMap((n) => n.ports.map((p) => [p.id, p] as const)),
+  )
   const mapConn = (conn: GraphConnection): GraphConnection => ({
     from_port_id: portIdMap.get(conn.from_port_id) ?? conn.from_port_id,
     to_port_id: portIdMap.get(conn.to_port_id) ?? conn.to_port_id,
   })
   const childConnections = analysis.internal.map(mapConn)
-  // 境界の配線：start.main → 入口ノードの in／出口ポート → end.in
-  if (analysis.entryNodeId !== null) {
-    const entry = childNodes.find(
-      (n) => n.id === nodeIdMap.get(analysis.entryNodeId ?? ""),
-    )
-    const entryIn = entry?.ports.find((p) => p.io === "in")
-    if (entryIn) {
-      childConnections.push({
-        from_port_id: childStartOutPortId,
-        to_port_id: entryIn.id,
-      })
+  // 境界の配線（入口）：start.main → 各入口ポート（複数なら fan-out）
+  for (const entryPortId of analysis.entryPortIds) {
+    childConnections.push({
+      from_port_id: childStartOutPortId,
+      to_port_id: portIdMap.get(entryPortId) ?? entryPortId,
+    })
+  }
+
+  // 境界の配線（出口）：出発ポートごとに end の in を1つ充てる。
+  // 1つ目は seed 済みの in を使い（名前を出口ポート名へ）、2つ目以降は追加する。
+  // component の out はこの in たちの射影（出口1つは互換のため main キー）
+  const seededEndIns = childEnd.ports.filter((p) => p.io === "in")
+  const endInKeys = new Set(seededEndIns.map((p) => p.key))
+  const nextEndInKey = (): string => {
+    for (let i = 2; ; i++) {
+      const key = `in_${i}`
+      if (!endInKeys.has(key)) {
+        endInKeys.add(key)
+        return key
+      }
     }
   }
-  if (analysis.exitPortId !== null) {
+  const exits = analysis.exitPortIds.map((exitPortId, i) => {
+    const exitName = portById.get(exitPortId)?.name ?? "出力"
+    const seeded = i === 0 ? seededEndIns[0] : undefined
+    const endIn: GraphPort = seeded
+      ? { ...seeded, name: exitName }
+      : {
+          id: newId(),
+          io: "in",
+          key: nextEndInKey(),
+          name: exitName,
+          schema: {},
+        }
+    return { exitPortId, endIn }
+  })
+  const resolvedChildEnd: GraphNode =
+    exits.length === 0
+      ? childEnd
+      : {
+          ...childEnd,
+          ports: [
+            ...exits.map((e) => e.endIn),
+            ...childEnd.ports.filter((p) => p.io !== "in"),
+          ],
+        }
+  for (const exit of exits) {
     childConnections.push({
-      from_port_id: portIdMap.get(analysis.exitPortId) ?? analysis.exitPortId,
-      to_port_id: childEndInPortId,
+      from_port_id: portIdMap.get(exit.exitPortId) ?? exit.exitPortId,
+      to_port_id: exit.endIn.id,
     })
   }
 
@@ -173,13 +223,38 @@ export const buildExtractPlan = (params: {
       selectedNodes.reduce((sum, n) => sum + n.position_y, 0) /
       selectedNodes.length,
   }
+  // out は出口ごと（キーは end の in の射影。出口1つ以下は互換の main 1口）
+  const groupOuts: { exitPortId: string | null; port: GraphPort }[] =
+    exits.length <= 1
+      ? [
+          {
+            exitPortId: exits[0]?.exitPortId ?? null,
+            port: {
+              id: newId(),
+              io: "out",
+              key: SINGLE_OUT_KEY,
+              name: exits[0] ? exits[0].endIn.name : "出力",
+              schema: {},
+            },
+          },
+        ]
+      : exits.map((e) => ({
+          exitPortId: e.exitPortId,
+          port: {
+            id: newId(),
+            io: "out",
+            key: e.endIn.key,
+            name: e.endIn.name,
+            schema: {},
+          },
+        }))
   const groupNode: GraphNode = {
     id: newId(),
     kind: "component",
     name,
     ports: [
       { id: newId(), io: "in", key: "in", name: "入力", schema: {} },
-      { id: newId(), io: "out", key: "main", name: "出力", schema: {} },
+      ...groupOuts.map((o) => o.port),
     ],
     hooks: [],
     position_x: centroid.x,
@@ -187,12 +262,16 @@ export const buildExtractPlan = (params: {
     component: { component_loop_id: componentLoopId },
   }
   const groupIn = groupNode.ports.find((p) => p.io === "in")
-  const groupMain = groupNode.ports.find((p) => p.io === "out")
-  if (!groupIn || !groupMain) {
+  if (!groupIn) {
     return { ok: false, reason: "groupNode のポート生成に失敗しました" }
   }
+  const groupOutByExitPortId = new Map(
+    groupOuts
+      .filter((o) => o.exitPortId !== null)
+      .map((o) => [o.exitPortId as string, o.port] as const),
+  )
 
-  // 親の置換：選択関連の線（内部・境界）を除き、境界を group の in/main へ繋ぎ直す
+  // 親の置換：選択関連の線（内部・境界）を除き、境界を group の in／対応する out へ繋ぎ直す
   const removed = new Set(
     [...analysis.internal, ...analysis.inbound, ...analysis.outbound].map(
       (c) => `${c.from_port_id}→${c.to_port_id}`,
@@ -202,14 +281,17 @@ export const buildExtractPlan = (params: {
     ...connections.filter(
       (c) => !removed.has(`${c.from_port_id}→${c.to_port_id}`),
     ),
-    ...analysis.inbound.map((c) => ({
-      from_port_id: c.from_port_id,
-      to_port_id: groupIn.id,
-    })),
-    ...analysis.outbound.map((c) => ({
-      from_port_id: groupMain.id,
-      to_port_id: c.to_port_id,
-    })),
+    // 同一起点から複数入口へ入っていた線は group.in への1本に畳む（重複線を作らない）
+    ...[...new Set(analysis.inbound.map((c) => c.from_port_id))].map(
+      (from_port_id) => ({
+        from_port_id,
+        to_port_id: groupIn.id,
+      }),
+    ),
+    ...analysis.outbound.flatMap((c) => {
+      const out = groupOutByExitPortId.get(c.from_port_id)
+      return out ? [{ from_port_id: out.id, to_port_id: c.to_port_id }] : []
+    }),
   ]
   const parentNodes = [...nodes.filter((n) => !selected.has(n.id)), groupNode]
 
@@ -217,6 +299,7 @@ export const buildExtractPlan = (params: {
     ok: true,
     childNodes,
     childConnections,
+    childEnd: resolvedChildEnd,
     groupNode,
     parentNodes,
     parentConnections,

package/_schemas/graph.test.ts

@@ -8,7 +8,7 @@ import {
   waitConfigSchema,
 } from "./graph.js"
 import type { GraphPort } from "./node.js"
-import { envelopeSchemaOf, resolvePortSchemas } from "./port-spec.js"
+import { resolvePortSchemas } from "./port-spec.js"
 
 // テスト用の決定的な uuid（common は node 型定義を持たないため crypto は使わない）
 let seq = 0
@@ -89,15 +89,14 @@ const port = (io: "in" | "out", key: string): GraphPort => ({
   schema: { type: "object" },
 })
 
-// ai の out 宣言は封筒型 { data, description } 固定なので、デフォルトノードは
-// data=テキストの封筒を持つ
-const textEnvelope = envelopeSchemaOf({ type: "string" })
+// ai の out も自由な宣言型。デフォルトノードはテキスト（string）を宣言する
+const textOutput = { type: "string" }
 
 // 既定は ai ノード。ai の in は 上流データの in ＋ 差し戻しの instruction の2口
 const aiPorts = (): GraphPort[] => [
   port("in", "in"),
   port("in", "instruction"),
-  { ...port("out", "main"), schema: textEnvelope },
+  { ...port("out", "main"), schema: textOutput },
 ]
 
 // ai 以外に流用するとき用（in は1つ）
@@ -388,17 +387,27 @@ describe("saveGraphBodySchema", () => {
     ).toThrow(/key が重複/)
   })
 
-  it("in ポートがちょうど1つでない node を拒否する（0個・2個）", () => {
+  it("in ポートの口数：ai は1つ以上（自由）、program 等は ちょうど1つ", () => {
+    // ai：0個は拒否、複数は許可（in の追加・削除は自由）
     const zero = makeNode([port("out", "main")])
     expect(() =>
       saveGraphBodySchema.parse({ nodes: [zero], connections: [] }),
     ).toThrow(/in ポート/)
-
-    const two = makeNode([
+    const many = makeNode([
       port("in", "in"),
-      port("in", "in2"),
+      port("in", "feedback"),
+      port("in", "extra"),
       port("out", "main"),
     ])
+    expect(() =>
+      saveGraphBodySchema.parse({ nodes: [many], connections: [] }),
+    ).not.toThrow()
+
+    // program：ちょうど1つ
+    const two = {
+      ...makeNode([port("in", "in"), port("in", "in2"), port("out", "main")]),
+      kind: "program" as const,
+    }
     expect(() =>
       saveGraphBodySchema.parse({ nodes: [two], connections: [] }),
     ).toThrow(/in ポート/)
@@ -497,8 +506,6 @@ describe("saveGraphBodySchema", () => {
 
 // ---- kind 別ポート構成と型の接続バリデーション（ポートのkind別仕様.md） ----
 
-const aiEnvelope = textEnvelope
-
 const humanNode = () => ({
   ...makeNode([
     port("in", "in"),
@@ -511,7 +518,7 @@ const aiNode = () => ({
   ...makeNode([
     port("in", "in"),
     port("in", "instruction"),
-    { ...port("out", "main"), schema: aiEnvelope },
+    { ...port("out", "main"), schema: textOutput },
   ]),
   kind: "ai" as const,
 })
@@ -549,27 +556,27 @@ describe("saveGraphBodySchema（kind 別ポート構成）", () => {
       ...makeNode([
         port("in", "in"),
         port("in", "instruction"),
-        { ...port("out", "spam"), schema: aiEnvelope },
-        { ...port("out", "sales"), schema: aiEnvelope },
-        { ...port("out", "support"), schema: aiEnvelope },
+        { ...port("out", "spam"), schema: textOutput },
+        { ...port("out", "sales"), schema: textOutput },
+        { ...port("out", "support"), schema: textOutput },
       ]),
       kind: "ai" as const,
     }
     expect(() =>
       saveGraphBodySchema.parse({ nodes: [multi], connections: [] }),
     ).not.toThrow()
-    // in の構成は in / instruction 固定のまま
-    const badIn = {
+    // in の key も自由（in / instruction の固定構成は廃止）
+    const freeIn = {
       ...makeNode([
         port("in", "input"),
-        port("in", "instruction"),
-        { ...port("out", "main"), schema: aiEnvelope },
+        port("in", "feedback"),
+        { ...port("out", "main"), schema: textOutput },
       ]),
       kind: "ai" as const,
     }
     expect(() =>
-      saveGraphBodySchema.parse({ nodes: [badIn], connections: [] }),
-    ).toThrow(/ai の in ポート/)
+      saveGraphBodySchema.parse({ nodes: [freeIn], connections: [] }),
+    ).not.toThrow()
   })
 
   it("program は out を複数持てる（key 自由）", () => {
@@ -586,49 +593,38 @@ describe("saveGraphBodySchema（kind 別ポート構成）", () => {
     ).not.toThrow()
   })
 
-  it("ai の出力宣言が封筒型 { data, description } でないと拒否する（全出口に適用）", () => {
-    const bad = makeNode([
-      port("in", "in"),
-      port("in", "instruction"),
-      { ...port("out", "main"), schema: { type: "object" } },
-    ])
-    expect(() =>
-      saveGraphBodySchema.parse({ nodes: [bad], connections: [] }),
-    ).toThrow(/封筒型 \{ data, description \}/)
-    // main 以外の出口も封筒型を強制する
-    const badExtra = makeNode([
-      port("in", "in"),
-      port("in", "instruction"),
-      { ...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("in", "instruction"),
+  it("ai の出力宣言は任意の JSON Schema でよい（形の強制はしない）", () => {
+    for (const schema of [
+      { type: "object" },
+      { type: "string" },
+      { type: "array", items: { type: "number" } },
       {
-        ...port("out", "main"),
-        schema: envelopeSchemaOf({
-          type: "object",
-          properties: { title: { type: "string" } },
-          required: ["title"],
-        }),
+        // かつて強制していた { data, description } もただの object として valid
+        type: "object",
+        properties: {
+          data: { type: "string" },
+          description: { type: "string" },
+        },
+        required: ["data", "description"],
       },
-    ])
-    expect(() =>
-      saveGraphBodySchema.parse({ nodes: [custom], connections: [] }),
-    ).not.toThrow()
+    ]) {
+      const node = makeNode([
+        port("in", "in"),
+        port("in", "instruction"),
+        { ...port("out", "main"), schema },
+      ])
+      expect(() =>
+        saveGraphBodySchema.parse({ nodes: [node], connections: [] }),
+      ).not.toThrow()
+    }
   })
 })
 
 describe("saveGraphBodySchema（型の接続バリデーション）", () => {
-  // 接続の可否は kind ではなく型で決まる（reject と instruction は両端とも
-  // instructionSchema() で固定されているので、型検証だけで組み合わせが決まる）
-  // → docs/tasks/wip/Humanの入出力を承認ビューの宣言に一本化する.md
-  it("human の reject → ai の instruction は型が一致するので許可", () => {
+  // 接続の可否は kind ではなく型で決まる。reject / instruction の型固定は廃止され、
+  // ai の in はどの口も接続鏡映（接続元の型に同期）なので接続は自明に通る
+  // → docs/tasks/wip/ポート型固定の撤去とセッション再開のポート属性化.md
+  it("human の reject → ai の instruction を許可（kind の縛りも型固定も無い）", () => {
     const human = humanNode()
     const ai = aiNode()
     const rejectPort = outByKey(human, "reject")
@@ -645,7 +641,7 @@ describe("saveGraphBodySchema（型の接続バリデーション）", () => {
     ).not.toThrow()
   })
 
-  it("reject は ai 以外へも繋げる（接続鏡映の in が指示型を採用する）", () => {
+  it("reject は ai 以外へも繋げる（接続鏡映の in が接続元の型を採用する）", () => {
     const human = humanNode()
     const prog = programNode()
     expect(() =>
@@ -661,10 +657,11 @@ describe("saveGraphBodySchema（型の接続バリデーション）", () => {
     ).not.toThrow()
   })
 
-  it("instruction ポートには型の合わない出力を繋げない（kind ではなく型で弾く）", () => {
+  it("instruction も他の in と同じ接続鏡映：宣言と違う型の out でも同期して繋がる", () => {
     const upstream = aiNode()
     const downstream = aiNode()
-    // ai.main は封筒型 { data, description }、instruction は { prompt, files }
+    // ai.main は string、instruction の宣言は { type: "object" } だが、
+    // 鏡映で接続元に同期される（instruction の特別扱いは無い）
     expect(() =>
       saveGraphBodySchema.parse({
         nodes: [upstream, downstream],
@@ -675,10 +672,10 @@ describe("saveGraphBodySchema（型の接続バリデーション）", () => {
           },
         ],
       }),
-    ).toThrow(/適合しません/)
+    ).not.toThrow()
   })
 
-  it("human の in はどの型でも接続できる（封筒型の制約は課さない）", () => {
+  it("human の in はどの型でも接続できる（形の制約は課さない）", () => {
     const ai = aiNode()
     const human = humanNode()
     expect(() =>
@@ -688,8 +685,7 @@ describe("saveGraphBodySchema（型の接続バリデーション）", () => {
       }),
     ).not.toThrow()
 
-    // program out が封筒型でない（{ type: "object" } のまま）でも接続できる
-    // （input 全体を data として表示する）
+    // program out が素の object でも接続できる
     const human2 = humanNode()
     const progPlain = {
       ...makeNode([
@@ -707,7 +703,8 @@ describe("saveGraphBodySchema（型の接続バリデーション）", () => {
   })
 
   it("program の in への接続は 伝播型 ⊆ 宣言スキーマ（human 経由の伝播込み）", () => {
-    // ai(封筒型) → human(approve は data 型に剥がれる) → program(string を要求) は通る
+    // ai → human（approve は in と同型）→ program(string を要求) は、
+    // program の in が接続鏡映（sticky）なので通る
     const ai = aiNode()
     const human = humanNode()
     const prog = programNode({ type: "string" })
@@ -1027,6 +1024,30 @@ describe("saveGraphBodySchema：コンポーネントノード（component kind
     ).not.toThrow()
   })
 
+  it("component.refs（配置の設定値）を受け付けて保持する（省略も可）", () => {
+    const withRefs = {
+      ...componentNode(),
+      component: {
+        component_loop_id: uuid(),
+        refs: { labels: ["bug"], assignee: "kazuwombat" },
+      },
+    }
+    const parsed = saveGraphBodySchema.parse({
+      nodes: [withRefs],
+      connections: [],
+    })
+    expect(parsed.nodes[0]?.component?.refs).toEqual({
+      labels: ["bug"],
+      assignee: "kazuwombat",
+    })
+    // 省略時は undefined のまま（既存グラフの互換。保存側で {} 扱い）
+    const omitted = saveGraphBodySchema.parse({
+      nodes: [componentNode()],
+      connections: [],
+    })
+    expect(omitted.nodes[0]?.component?.refs).toBeUndefined()
+  })
+
   it("component_loop_id の無い component ノードを拒否する", () => {
     const node = { ...componentNode(), component: undefined }
     expect(() =>
@@ -1034,21 +1055,23 @@ describe("saveGraphBodySchema：コンポーネントノード（component kind
     ).toThrow(/component_loop_id/)
   })
 
-  it("ポート構成は in/main 固定（out の key 違い・複数 out を拒否）", () => {
-    const badKey = {
+  it("in は in 1つ固定・out は複数可（子 end の in 射影。コンポーネントの複数入口・複数出口.md）", () => {
+    // in の key 違いは拒否
+    const badIn = {
       ...componentNode(),
-      ports: [port("in", "in"), port("out", "result")],
+      ports: [port("in", "input"), port("out", "main")],
     }
     expect(() =>
-      saveGraphBodySchema.parse({ nodes: [badKey], connections: [] }),
-    ).toThrow(/component のポート構成/)
+      saveGraphBodySchema.parse({ nodes: [badIn], connections: [] }),
+    ).toThrow(/component の in ポートは in/)
+    // out は key 自由・複数可（キーは保存時にサーバが子契約から焼き込む）
     const multiOut = {
       ...componentNode(),
       ports: [port("in", "in"), port("out", "main"), port("out", "sub")],
     }
     expect(() =>
       saveGraphBodySchema.parse({ nodes: [multiOut], connections: [] }),
-    ).toThrow(/component のポート構成/)
+    ).not.toThrow()
   })
 
   it("component の in への接続は契約への適合を検証する（伝播型 ⊆ 契約）", () => {