@mawaru/sdk 0.14.1 → 0.15.0

package/_schemas/duplicate-selection.test.ts

@@ -216,6 +216,26 @@ describe("duplicateSelection（選択ノードの複製）", () => {
     )
   })
 
+  it("手動ルート（waypoints）は dx / dy を適用して引き継ぐ", () => {
+    const { b, c, nodes, connections } = chain()
+    const manual = connections.map((conn, i) =>
+      i === 1
+        ? {
+            ...conn,
+            waypoints: [
+              { x: 150, y: 0 },
+              { x: 150, y: 100 },
+            ],
+          }
+        : conn,
+    )
+    const result = dup(nodes, manual, [b.id, c.id], 40, -20)
+    expect(result.connections[0]?.waypoints).toEqual([
+      { x: 190, y: -20 },
+      { x: 190, y: 80 },
+    ])
+  })
+
   it("dx / dy を全ノードへ一律に適用し、相対配置を保つ", () => {
     const { b, c, nodes, connections } = chain()
     const result = dup(nodes, connections, [b.id, c.id], 40, -20)

package/_schemas/duplicate-selection.ts

@@ -37,11 +37,27 @@ export const duplicateSelection = (params: {
     }))
 
   // 両端が複製対象のポートである線（＝選択内で完結する線）だけを張り替えて写す。
-  // 外部との線（入口・出口）はコピーしない
+  // 外部との線（入口・出口）はコピーしない。手動ルート（waypoints）は
+  // ノードと同じ移動量で写し、調整済みの形を保つ
   const copiedConnections = connections.flatMap((c) => {
     const from = portIdMap.get(c.from_port_id)
     const to = portIdMap.get(c.to_port_id)
-    return from && to ? [{ from_port_id: from, to_port_id: to }] : []
+    return from && to
+      ? [
+          {
+            from_port_id: from,
+            to_port_id: to,
+            ...(c.waypoints
+              ? {
+                  waypoints: c.waypoints.map((p) => ({
+                    x: p.x + dx,
+                    y: p.y + dy,
+                  })),
+                }
+              : {}),
+          },
+        ]
+      : []
   })
 
   return { nodes: copied, connections: copiedConnections }

package/_schemas/extract-component.test.ts

@@ -4,18 +4,22 @@ import {
   buildExtractPlan,
 } from "./extract-component.js"
 import type { GraphNode } from "./graph.js"
-import type { GraphPort } from "./node.js"
+import type { GraphPort, JsonSchema } from "./node.js"
 
 // テスト用の決定的な uuid（graph.test.ts と同じ流儀）
 let seq = 0
 const uuid = () => `00000000-0000-4000-8000-${String(++seq).padStart(12, "0")}`
 
-const port = (io: "in" | "out", key: string): GraphPort => ({
+const port = (
+  io: "in" | "out",
+  key: string,
+  schema: JsonSchema = { type: "object" },
+): GraphPort => ({
   id: uuid(),
   io,
   key,
   name: key,
-  schema: { type: "object" },
+  schema,
 })
 
 const makeNode = (
@@ -62,44 +66,60 @@ const chain = () => {
   return { a, b, c, d, nodes, connections }
 }
 
-describe("analyzeExtractSelection（境界の分類と V1 制約）", () => {
+describe("analyzeExtractSelection（境界の分類と成立条件）", () => {
   it("直列の中間2ノード：入口・出口と内部/入口/出口線を分類する", () => {
     const { a, b, c, d, nodes, connections } = chain()
     const result = analyzeExtractSelection(nodes, connections, [b.id, c.id])
     if (!result.ok) throw new Error(result.reason)
-    expect(result.entryNodeId).toBe(b.id)
-    expect(result.exitPortId).toBe(outOf(c).id)
+    expect(result.entryPortIds).toEqual([inOf(b).id])
+    expect(result.exitPortIds).toEqual([outOf(c).id])
     expect(result.internal).toEqual([connect(b, c)])
     expect(result.inbound).toEqual([connect(a, b)])
     expect(result.outbound).toEqual([connect(c, d)])
   })
 
-  it("孤立した島（入出力なし）も抽出できる（entry/exit は null）", () => {
+  it("孤立した島（入出力なし）も抽出できる（入口・出口は空）", () => {
     const { b, c, nodes } = chain()
     const internalOnly = [connect(b, c)]
     const result = analyzeExtractSelection(nodes, internalOnly, [b.id, c.id])
     if (!result.ok) throw new Error(result.reason)
-    expect(result.entryNodeId).toBeNull()
-    expect(result.exitPortId).toBeNull()
+    expect(result.entryPortIds).toEqual([])
+    expect(result.exitPortIds).toEqual([])
   })
 
-  it("入口が2ノードになる選択は拒否する", () => {
+  it("入口が複数でも型が同じなら成立する（同型の合流）", () => {
     const { a, b, c, d, nodes, connections } = chain()
-    // A→B と D→C を追加：選択 {B, C} への外部入力が B と C の2ノードに入る
+    // A→B に加えて D→C：選択 {B, C} への外部入力が B.in と C.in の2ポートに入る。
+    // どちらの in も {type:"object"} なので成立する
     const withSecondEntry = [...connections, connect(d, c)]
     const result = analyzeExtractSelection(nodes, withSecondEntry, [b.id, c.id])
+    if (!result.ok) throw new Error(result.reason)
+    expect(result.entryPortIds.sort()).toEqual([inOf(b).id, inOf(c).id].sort())
+    void a
+  })
+
+  it("入口の型が揃っていない選択は拒否する", () => {
+    const { a, b, d, nodes, connections } = chain()
+    // in の型が違うノードを選択に足し、外部から線を入れる
+    const e = {
+      ...makeNode("program", "E", 200, 200),
+      ports: [port("in", "in", { type: "string" }), port("out", "main")],
+    }
+    const withE = [...nodes, e]
+    const conns = [...connections, connect(d, e)]
+    const result = analyzeExtractSelection(withE, conns, [b.id, e.id])
     expect(result.ok).toBe(false)
-    if (!result.ok) expect(result.reason).toContain("入口")
+    if (!result.ok) expect(result.reason).toContain("入口の型")
     void a
   })
 
-  it("出口が2ポートになる選択は拒否する（同一ポートからの fan-out は許す）", () => {
+  it("出口は複数ポートでも成立する（同一ポートからの fan-out は1出口扱い）", () => {
     const { a, b, c, d, nodes, connections } = chain()
     // B→D を追加：選択 {B, C} から外への出力が B.main と C.main の2ポート
     const twoExits = [...connections, connect(b, d)]
     const result = analyzeExtractSelection(nodes, twoExits, [b.id, c.id])
-    expect(result.ok).toBe(false)
-    if (!result.ok) expect(result.reason).toContain("出口")
+    if (!result.ok) throw new Error(result.reason)
+    expect(result.exitPortIds.sort()).toEqual([outOf(b).id, outOf(c).id].sort())
 
     // C.main → D に加えて C.main → A（同一ポートの fan-out）は出口1つ扱い
     const fanOut = [
@@ -107,15 +127,16 @@ describe("analyzeExtractSelection（境界の分類と V1 制約）", () => {
       { from_port_id: outOf(c).id, to_port_id: inOf(a).id },
     ]
     const ok = analyzeExtractSelection(nodes, fanOut, [b.id, c.id])
-    expect(ok.ok).toBe(true)
+    if (!ok.ok) throw new Error(ok.reason)
+    expect(ok.exitPortIds).toEqual([outOf(c).id])
   })
 
-  it("1ノード選択：そのノードが入口、その out が出口になる", () => {
+  it("1ノード選択：そのノードの in が入口、その out が出口になる", () => {
     const { a, b, c, nodes, connections } = chain()
     const result = analyzeExtractSelection(nodes, connections, [b.id])
     if (!result.ok) throw new Error(result.reason)
-    expect(result.entryNodeId).toBe(b.id)
-    expect(result.exitPortId).toBe(outOf(b).id)
+    expect(result.entryPortIds).toEqual([inOf(b).id])
+    expect(result.exitPortIds).toEqual([outOf(b).id])
     expect(result.internal).toEqual([])
     expect(result.inbound).toEqual([connect(a, b)])
     expect(result.outbound).toEqual([connect(b, c)])
@@ -137,10 +158,20 @@ describe("analyzeExtractSelection（境界の分類と V1 制約）", () => {
 })
 
 describe("buildExtractPlan（子グラフと親置換の生成）", () => {
+  const childEndNode = (): GraphNode => ({
+    id: uuid(),
+    kind: "end",
+    name: "終了",
+    ports: [port("in", "in", {}), port("out", "main", {})],
+    hooks: [],
+    position_x: 560,
+    position_y: 200,
+  })
+
   const build = () => {
     const { a, b, c, d, nodes, connections } = chain()
     const childStartOutPortId = uuid()
-    const childEndInPortId = uuid()
+    const childEnd = childEndNode()
     const componentLoopId = uuid()
     const plan = buildExtractPlan({
       nodes,
@@ -149,7 +180,7 @@ describe("buildExtractPlan（子グラフと親置換の生成）", () => {
       name: "PRレビュー",
       componentLoopId,
       childStartOutPortId,
-      childEndInPortId,
+      childEnd,
       newId: uuid,
     })
     if (!plan.ok) throw new Error(plan.reason)
@@ -162,7 +193,7 @@ describe("buildExtractPlan（子グラフと親置換の生成）", () => {
       connections,
       plan,
       childStartOutPortId,
-      childEndInPortId,
+      childEnd,
       componentLoopId,
     }
   }
@@ -185,18 +216,20 @@ describe("buildExtractPlan（子グラフと親置換の生成）", () => {
     expect(internal).toBeDefined()
   })
 
-  it("子：start.main → 入口ノード、出口ポート → end.in が配線される", () => {
-    const { plan, childStartOutPortId, childEndInPortId } = build()
+  it("子：start.main → 入口、出口ポート → end.in が配線される（出口1つは seed の in を使う）", () => {
+    const { plan, childStartOutPortId, childEnd } = build()
     const [nb, nc] = plan.childNodes
     if (!nb || !nc) throw new Error("コピーがない")
     expect(plan.childConnections).toContainEqual({
       from_port_id: childStartOutPortId,
       to_port_id: inOf(nb).id,
     })
+    // seed 済みの end.in がそのまま使われ、名前は出口ポート名になる
     expect(plan.childConnections).toContainEqual({
       from_port_id: outOf(nc).id,
-      to_port_id: childEndInPortId,
+      to_port_id: inOf(childEnd).id,
     })
+    expect(inOf(plan.childEnd).name).toBe(outOf(nc).name)
   })
 
   it("親：選択が groupNode に置き換わり、外部との線が in/main へ繋ぎ直される", () => {
@@ -209,6 +242,10 @@ describe("buildExtractPlan（子グラフと親置換の生成）", () => {
     expect(plan.groupNode.name).toBe("PRレビュー")
     expect(plan.groupNode.position_x).toBe(150) // (100+200)/2
     expect(plan.groupNode.position_y).toBe(50) // (0+100)/2
+    // 出口1つ：out は互換の main 1口
+    expect(
+      plan.groupNode.ports.filter((p) => p.io === "out").map((p) => p.key),
+    ).toEqual(["main"])
 
     // 親 nodes：A, D, groupNode（B, C は消える）
     expect(plan.parentNodes.map((n) => n.id).sort()).toEqual(
@@ -228,10 +265,101 @@ describe("buildExtractPlan（子グラフと親置換の生成）", () => {
     void c
   })
 
+  it("複数入口（同型）：start.main から全入口へ fan-out し、親の同一起点は group.in への1本に畳まれる", () => {
+    // X.main が B と C の両方へ入る（今回の実例：開発.main → レビューと監視）
+    const { a, b, c, d, nodes, connections } = chain()
+    const conns = [
+      ...connections,
+      { from_port_id: outOf(a).id, to_port_id: inOf(c).id },
+    ]
+    const childStartOutPortId = uuid()
+    const plan = buildExtractPlan({
+      nodes,
+      connections: conns,
+      selectedIds: [b.id, c.id],
+      name: "レビュー",
+      componentLoopId: uuid(),
+      childStartOutPortId,
+      childEnd: childEndNode(),
+      newId: uuid,
+    })
+    if (!plan.ok) throw new Error(plan.reason)
+    const [nb, nc] = plan.childNodes
+    if (!nb || !nc) throw new Error("コピーがない")
+    // 子：start.main → B.in と C.in の両方
+    expect(plan.childConnections).toContainEqual({
+      from_port_id: childStartOutPortId,
+      to_port_id: inOf(nb).id,
+    })
+    expect(plan.childConnections).toContainEqual({
+      from_port_id: childStartOutPortId,
+      to_port_id: inOf(nc).id,
+    })
+    // 親：A.main → group.in は1本だけ（重複線を作らない）
+    const inboundToGroup = plan.parentConnections.filter(
+      (conn) => conn.to_port_id === inOf(plan.groupNode).id,
+    )
+    expect(inboundToGroup).toEqual([
+      { from_port_id: outOf(a).id, to_port_id: inOf(plan.groupNode).id },
+    ])
+    void d
+  })
+
+  it("複数出口：出発ポートごとに end の in と group の out が生え、親は対応する out から繋ぎ直される", () => {
+    const { a, b, c, d, nodes, connections } = chain()
+    // B→D を追加：出口は B.main と C.main の2つ
+    const conns = [...connections, connect(b, d)]
+    const childEnd = childEndNode()
+    const plan = buildExtractPlan({
+      nodes,
+      connections: conns,
+      selectedIds: [b.id, c.id],
+      name: "レビュー",
+      componentLoopId: uuid(),
+      childStartOutPortId: uuid(),
+      childEnd,
+      newId: uuid,
+    })
+    if (!plan.ok) throw new Error(plan.reason)
+    const [nb, nc] = plan.childNodes
+    if (!nb || !nc) throw new Error("コピーがない")
+
+    // 子 end：in が出口の数だけある（1つ目は seed 再利用・2つ目は追加）
+    const endIns = plan.childEnd.ports.filter((p) => p.io === "in")
+    expect(endIns).toHaveLength(2)
+    // 出口ポート → 対応する end.in の配線
+    const endInByExit = new Map(
+      plan.childConnections
+        .filter((conn) => endIns.some((p) => p.id === conn.to_port_id))
+        .map((conn) => [conn.from_port_id, conn.to_port_id] as const),
+    )
+    expect(endInByExit.get(outOf(nc).id)).toBeDefined()
+    expect(endInByExit.get(outOf(nb).id)).toBeDefined()
+
+    // group：出口ごとの out（key は end.in の射影）
+    const groupOuts = plan.groupNode.ports.filter((p) => p.io === "out")
+    expect(groupOuts).toHaveLength(2)
+    expect(groupOuts.map((p) => p.key).sort()).toEqual(
+      endIns.map((p) => p.key).sort(),
+    )
+
+    // 親：C.main → D は「C.main に対応する out」→ D、B.main → D は「B.main に対応する out」→ D
+    const parentOutConns = plan.parentConnections.filter((conn) =>
+      groupOuts.some((p) => p.id === conn.from_port_id),
+    )
+    expect(parentOutConns).toHaveLength(2)
+    expect(new Set(parentOutConns.map((c2) => c2.to_port_id))).toEqual(
+      new Set([inOf(d).id]),
+    )
+    // 2本は別々の out から出る（同じ out からの fan-out ではない）
+    expect(new Set(parentOutConns.map((c2) => c2.from_port_id)).size).toBe(2)
+    void a
+  })
+
   it("1ノード選択：start.main → ノード → end.in と配線され、親では component ノードに置き換わる", () => {
     const { a, b, c, nodes, connections } = chain()
     const childStartOutPortId = uuid()
-    const childEndInPortId = uuid()
+    const childEnd = childEndNode()
     const plan = buildExtractPlan({
       nodes,
       connections,
@@ -239,7 +367,7 @@ describe("buildExtractPlan（子グラフと親置換の生成）", () => {
       name: "待つだけ",
       componentLoopId: uuid(),
       childStartOutPortId,
-      childEndInPortId,
+      childEnd,
       newId: uuid,
     })
     if (!plan.ok) throw new Error(plan.reason)
@@ -253,7 +381,7 @@ describe("buildExtractPlan（子グラフと親置換の生成）", () => {
     })
     expect(plan.childConnections).toContainEqual({
       from_port_id: outOf(nb).id,
-      to_port_id: childEndInPortId,
+      to_port_id: inOf(childEnd).id,
     })
     // 親：B が component ノードに置き換わり、A.main → group.in／group.main → C.in
     expect(plan.parentNodes.some((n) => n.id === b.id)).toBe(false)

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[]
@@ -43,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[] = []
@@ -54,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,
@@ -86,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 {
@@ -113,7 +125,7 @@ export const buildExtractPlan = (params: {
     name,
     componentLoopId,
     childStartOutPortId,
-    childEndInPortId,
+    childEnd,
     newId,
   } = params
   const analysis = analyzeExtractSelection(nodes, connections, selectedIds)
@@ -140,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,
     })
   }
 
@@ -175,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,
@@ -189,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}`,
@@ -204,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]
 
@@ -219,6 +299,7 @@ export const buildExtractPlan = (params: {
     ok: true,
     childNodes,
     childConnections,
+    childEnd: resolvedChildEnd,
     groupNode,
     parentNodes,
     parentConnections,

package/_schemas/graph.test.ts

@@ -1055,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 への接続は契約への適合を検証する（伝播型 ⊆ 契約）", () => {

package/_schemas/graph.ts

@@ -247,9 +247,17 @@ export const graphNodeSchema = z.object({
 })
 export type GraphNode = z.infer<typeof graphNodeSchema>
 
+// 手動ルートの折れ点（loop 座標系の絶対座標）。connection の waypoints に並べる
+// （docs/tasks/wip/connection線ルートの手動編集（ウェイポイント）.md）
+export const waypointSchema = z.object({ x: z.number(), y: z.number() })
+export type Waypoint = z.infer<typeof waypointSchema>
+
 export const graphConnectionSchema = z.object({
   from_port_id: z.uuid(),
   to_port_id: z.uuid(),
+  // 手動ルート：線の内部コーナーの座標列。省略＝自動ルート。
+  // 「手動だが折れ無し」という状態は作らない（正規化で折れが消えたら省略へ戻す）ので最低1点
+  waypoints: z.array(waypointSchema).min(1).optional(),
 })
 export type GraphConnection = z.infer<typeof graphConnectionSchema>
 

package/_schemas/port-spec.ts

@@ -147,19 +147,20 @@ const FIXED_PORT_KEYS: Record<string, { in: string[]; out: string[] }> = {
   wait: { in: ["in"], out: ["main"] },
   // start は in 1つ（run 入力契約）＋ out main 1つの恒等パススルー
   start: { in: ["in"], out: ["main"] },
-  // component は in（子 loop の start.in 契約）＋ out main（end.out の戻り値）。
-  // スキーマは保存時にサーバが子 loop の契約から焼き込む宣言型
-  // （DERIVED/MIRROR には入れない＝接続で潰さない）
-  component: { in: ["in"], out: ["main"] },
 }
 
-const FREE_OUT_KINDS = new Set(["program", "ai"])
+// component は in（子 loop の start.in 契約）1つ＋ out は子 end の in ポートの射影
+// （複数可。end の in が1つなら互換のため main 1口）。スキーマ・構成とも保存時に
+// サーバが子 loop の契約から焼き込む宣言型（DERIVED/MIRROR には入れない＝接続で潰さない。
+// コンポーネントの複数入口・複数出口.md）
+const FREE_OUT_KINDS = new Set(["program", "ai", "component"])
 
 // out は自由（複数出口＝分岐）。program は in の構成も固定（1口）だが、
 // ai は in も自由（追加・削除・key 自由。セッション再開は key ではなくポートの
 // resume 属性で決まる。ポート型固定の撤去とセッション再開のポート属性化.md）
 const FIXED_IN_KEYS: Record<string, string[]> = {
   program: ["in"],
+  component: ["in"],
 }
 
 export const fixedInKeysOf = (kind: string): string[] | null =>

package/dist/_schemas/duplicate-selection.js

@@ -24,11 +24,27 @@ export const duplicateSelection = (params) => {
         position_y: n.position_y + dy,
     }));
     // 両端が複製対象のポートである線（＝選択内で完結する線）だけを張り替えて写す。
-    // 外部との線（入口・出口）はコピーしない
+    // 外部との線（入口・出口）はコピーしない。手動ルート（waypoints）は
+    // ノードと同じ移動量で写し、調整済みの形を保つ
     const copiedConnections = connections.flatMap((c) => {
         const from = portIdMap.get(c.from_port_id);
         const to = portIdMap.get(c.to_port_id);
-        return from && to ? [{ from_port_id: from, to_port_id: to }] : [];
+        return from && to
+            ? [
+                {
+                    from_port_id: from,
+                    to_port_id: to,
+                    ...(c.waypoints
+                        ? {
+                            waypoints: c.waypoints.map((p) => ({
+                                x: p.x + dx,
+                                y: p.y + dy,
+                            })),
+                        }
+                        : {}),
+                },
+            ]
+            : [];
     });
     return { nodes: copied, connections: copiedConnections };
 };

package/dist/_schemas/extract-component.d.ts

@@ -4,8 +4,8 @@ export type ExtractAnalysis = {
     reason: string;
 } | {
     ok: true;
-    entryNodeId: string | null;
-    exitPortId: string | null;
+    entryPortIds: string[];
+    exitPortIds: string[];
     internal: GraphConnection[];
     inbound: GraphConnection[];
     outbound: GraphConnection[];
@@ -14,6 +14,7 @@ export declare const analyzeExtractSelection: (nodes: GraphNode[], connections:
 export type ExtractPlan = {
     childNodes: GraphNode[];
     childConnections: GraphConnection[];
+    childEnd: GraphNode;
     groupNode: GraphNode;
     parentNodes: GraphNode[];
     parentConnections: GraphConnection[];
@@ -25,7 +26,7 @@ export declare const buildExtractPlan: (params: {
     name: string;
     componentLoopId: string;
     childStartOutPortId: string;
-    childEndInPortId: string;
+    childEnd: GraphNode;
     newId: () => string;
 }) => {
     ok: false;

package/dist/_schemas/extract-component.js

@@ -14,6 +14,7 @@ export const analyzeExtractSelection = (nodes, connections, selectedIds) => {
         };
     }
     const nodeIdByPortId = new Map(nodes.flatMap((n) => n.ports.map((p) => [p.id, n.id])));
+    const portById = new Map(nodes.flatMap((n) => n.ports.map((p) => [p.id, p])));
     const internal = [];
     const inbound = [];
     const outbound = [];
@@ -27,31 +28,33 @@ export const analyzeExtractSelection = (nodes, connections, selectedIds) => {
         else if (fromIn && !toIn)
             outbound.push(conn);
     }
-    const entryNodeIds = new Set(inbound.map((c) => nodeIdByPortId.get(c.to_port_id) ?? ""));
-    if (entryNodeIds.size > 1) {
+    // 入口ポート（重複排除・出現順）。条件は「全入口の型が同一」だけ：
+    // 起点（どの外部ポートから入るか）は見ない。ノードが前のノードを知らないのと
+    // 同じ思想を境界にも適用する（グループ化＝入口の合流の宣言）
+    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 (entrySchemas.size > 1) {
         return {
             ok: false,
-            reason: "外部からの入力が複数のノードに入っています（入口は1つにしてください）",
-        };
-    }
-    const exitPortIds = new Set(outbound.map((c) => c.from_port_id));
-    if (exitPortIds.size > 1) {
-        return {
-            ok: false,
-            reason: "外部への出力が複数のポートから出ています（出口は1つにしてください）",
+            reason: "入口の型が揃っていません（同じ型の入口だけを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,
     };
 };
+// 出口が1つのときの component out キー（既存コンポーネントとの互換。
+// end の in が1つの loop は out main の1口として振る舞う）
+const SINGLE_OUT_KEY = "main";
 export const buildExtractPlan = (params) => {
-    const { nodes, connections, selectedIds, name, componentLoopId, childStartOutPortId, childEndInPortId, newId, } = params;
+    const { nodes, connections, selectedIds, name, componentLoopId, childStartOutPortId, childEnd, newId, } = params;
     const analysis = analyzeExtractSelection(nodes, connections, selectedIds);
     if (!analysis.ok)
         return analysis;
@@ -75,26 +78,60 @@ export const buildExtractPlan = (params) => {
             }),
         };
     });
+    const portById = new Map(nodes.flatMap((n) => n.ports.map((p) => [p.id, p])));
     const mapConn = (conn) => ({
         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,
+        });
     }
-    if (analysis.exitPortId !== null) {
+    // 境界の配線（出口）：出発ポートごとに 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 = () => {
+        for (let i = 2;; i++) {
+            const key = `in_${i}`;
+            if (!endInKeys.has(key)) {
+                endInKeys.add(key);
+                return key;
+            }
+        }
+    };
+    const exits = analysis.exitPortIds.map((exitPortId, i) => {
+        const exitName = portById.get(exitPortId)?.name ?? "出力";
+        const seeded = i === 0 ? seededEndIns[0] : undefined;
+        const endIn = seeded
+            ? { ...seeded, name: exitName }
+            : {
+                id: newId(),
+                io: "in",
+                key: nextEndInKey(),
+                name: exitName,
+                schema: {},
+            };
+        return { exitPortId, endIn };
+    });
+    const resolvedChildEnd = 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,
         });
     }
     // 親に置くノード（位置は選択の重心。ポートスキーマは保存時にサーバが契約から焼き込む）
@@ -105,13 +142,37 @@ export const buildExtractPlan = (params) => {
         y: selectedNodes.reduce((sum, n) => sum + n.position_y, 0) /
             selectedNodes.length,
     };
+    // out は出口ごと（キーは end の in の射影。出口1つ以下は互換の main 1口）
+    const groupOuts = 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 = {
         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,
@@ -119,28 +180,32 @@ 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 のポート生成に失敗しました" };
     }
-    // 親の置換：選択関連の線（内部・境界）を除き、境界を group の in/main へ繋ぎ直す
+    const groupOutByExitPortId = new Map(groupOuts
+        .filter((o) => o.exitPortId !== null)
+        .map((o) => [o.exitPortId, o.port]));
+    // 親の置換：選択関連の線（内部・境界）を除き、境界を group の in／対応する out へ繋ぎ直す
     const removed = new Set([...analysis.internal, ...analysis.inbound, ...analysis.outbound].map((c) => `${c.from_port_id}→${c.to_port_id}`));
     const parentConnections = [
         ...connections.filter((c) => !removed.has(`${c.from_port_id}→${c.to_port_id}`)),
-        ...analysis.inbound.map((c) => ({
-            from_port_id: c.from_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.map((c) => ({
-            from_port_id: groupMain.id,
-            to_port_id: c.to_port_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];
     return {
         ok: true,
         childNodes,
         childConnections,
+        childEnd: resolvedChildEnd,
         groupNode,
         parentNodes,
         parentConnections,

package/dist/_schemas/graph.d.ts

@@ -155,9 +155,18 @@ export declare const graphNodeSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type GraphNode = z.infer<typeof graphNodeSchema>;
+export declare const waypointSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strip>;
+export type Waypoint = z.infer<typeof waypointSchema>;
 export declare const graphConnectionSchema: z.ZodObject<{
     from_port_id: z.ZodUUID;
     to_port_id: z.ZodUUID;
+    waypoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type GraphConnection = z.infer<typeof graphConnectionSchema>;
 export declare const saveGraphBodySchema: z.ZodObject<{
@@ -240,6 +249,10 @@ export declare const saveGraphBodySchema: z.ZodObject<{
     connections: z.ZodArray<z.ZodObject<{
         from_port_id: z.ZodUUID;
         to_port_id: z.ZodUUID;
+        waypoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>;
     refs: z.ZodDefault<z.ZodObject<{
         type: z.ZodLiteral<"object">;

package/dist/_schemas/graph.js

@@ -193,9 +193,15 @@ export const graphNodeSchema = z.object({
     human: humanConfigSchema.optional(),
     component: componentConfigSchema.optional(),
 });
+// 手動ルートの折れ点（loop 座標系の絶対座標）。connection の waypoints に並べる
+// （docs/tasks/wip/connection線ルートの手動編集（ウェイポイント）.md）
+export const waypointSchema = z.object({ x: z.number(), y: z.number() });
 export const graphConnectionSchema = z.object({
     from_port_id: z.uuid(),
     to_port_id: z.uuid(),
+    // 手動ルート：線の内部コーナーの座標列。省略＝自動ルート。
+    // 「手動だが折れ無し」という状態は作らない（正規化で折れが消えたら省略へ戻す）ので最低1点
+    waypoints: z.array(waypointSchema).min(1).optional(),
 });
 // PUT /tenants/:tenantId/loops/:loopId/graph のボディ（グラフ一括保存）。
 // refs＝ループ変数の定義スキーマ（loops.refs）。回路と同じ「エディタの保存」で全置換する。

package/dist/_schemas/port-spec.js

@@ -125,17 +125,18 @@ const FIXED_PORT_KEYS = {
     wait: { in: ["in"], out: ["main"] },
     // start は in 1つ（run 入力契約）＋ out main 1つの恒等パススルー
     start: { in: ["in"], out: ["main"] },
-    // component は in（子 loop の start.in 契約）＋ out main（end.out の戻り値）。
-    // スキーマは保存時にサーバが子 loop の契約から焼き込む宣言型
-    // （DERIVED/MIRROR には入れない＝接続で潰さない）
-    component: { in: ["in"], out: ["main"] },
 };
-const FREE_OUT_KINDS = new Set(["program", "ai"]);
+// component は in（子 loop の start.in 契約）1つ＋ out は子 end の in ポートの射影
+// （複数可。end の in が1つなら互換のため main 1口）。スキーマ・構成とも保存時に
+// サーバが子 loop の契約から焼き込む宣言型（DERIVED/MIRROR には入れない＝接続で潰さない。
+// コンポーネントの複数入口・複数出口.md）
+const FREE_OUT_KINDS = new Set(["program", "ai", "component"]);
 // out は自由（複数出口＝分岐）。program は in の構成も固定（1口）だが、
 // ai は in も自由（追加・削除・key 自由。セッション再開は key ではなくポートの
 // resume 属性で決まる。ポート型固定の撤去とセッション再開のポート属性化.md）
 const FIXED_IN_KEYS = {
     program: ["in"],
+    component: ["in"],
 };
 export const fixedInKeysOf = (kind) => FIXED_IN_KEYS[kind] ?? null;
 // config.json（manifest）の inputs 検査（適合なら null）。同じルールを二重に持たないため

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mawaru/sdk",
-  "version": "0.14.1",
+  "version": "0.15.0",
   "description": "mawaru 実行 repo の開発 SDK。契約スキーマ（config.json 規約・ループ graph API）の正 ＋ typegen / validate CLI",
   "type": "module",
   "bin": {