@mawaru/sdk 0.13.0 → 0.15.0

package/dist/_schemas/extract-component.js

@@ -1,7 +1,9 @@
 export const analyzeExtractSelection = (nodes, connections, selectedIds) => {
     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");
@@ -12,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 = [];
@@ -25,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;
@@ -73,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,
         });
     }
     // 親に置くノード（位置は選択の重心。ポートスキーマは保存時にサーバが契約から焼き込む）
@@ -103,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,
@@ -117,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

@@ -67,6 +67,7 @@ export declare const humanConfigSchema: z.ZodObject<{
 export type HumanConfig = z.infer<typeof humanConfigSchema>;
 export declare const componentConfigSchema: z.ZodObject<{
     component_loop_id: z.ZodUUID;
+    refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
 export type ComponentConfig = z.infer<typeof componentConfigSchema>;
 export declare const graphNodeHookSchema: z.ZodObject<{
@@ -98,6 +99,7 @@ export declare const graphNodeSchema: z.ZodObject<{
         key: z.ZodString;
         name: z.ZodString;
         schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        resume: z.ZodOptional<z.ZodBoolean>;
         side: z.ZodOptional<z.ZodEnum<{
             top: "top";
             right: "right";
@@ -149,12 +151,22 @@ export declare const graphNodeSchema: z.ZodObject<{
     }, z.core.$strip>>;
     component: z.ZodOptional<z.ZodObject<{
         component_loop_id: z.ZodUUID;
+        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, 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<{
@@ -179,6 +191,7 @@ export declare const saveGraphBodySchema: z.ZodObject<{
             key: z.ZodString;
             name: z.ZodString;
             schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            resume: z.ZodOptional<z.ZodBoolean>;
             side: z.ZodOptional<z.ZodEnum<{
                 top: "top";
                 right: "right";
@@ -230,11 +243,16 @@ export declare const saveGraphBodySchema: z.ZodObject<{
         }, z.core.$strip>>;
         component: z.ZodOptional<z.ZodObject<{
             component_loop_id: z.ZodUUID;
+            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { graphPortSchema, jsonSchemaSchema, nodeKindSchema, portKeySchema, } from "./node.js";
-import { AI_INSTRUCTION_PORT_KEY, hasInboundConflict, isAiEnvelopeSchema, isSchemaSubset, kindPortsViolation, resolvePortSchemas, UNDECLARED_SCHEMA, } from "./port-spec.js";
+import { hasInboundConflict, isSchemaSubset, kindPortsViolation, resolvePortSchemas, UNDECLARED_SCHEMA, } from "./port-spec.js";
 // refs＝ループ変数の袋（key→任意の JSON 値。上流出力の参照（refs）.md）。
 // run 開始時に定義から複製され、全 step に全量差し込まれる。
 // key はポート key と同じ規則（^[a-z][a-z0-9_]*$）。実行系ボディ
@@ -156,6 +156,10 @@ export const humanConfigSchema = z.object({
 // （docs/tasks/wip/コンポーネント（ループの部品化と再利用）.md）
 export const componentConfigSchema = z.object({
     component_loop_id: z.uuid(),
+    // 配置の設定値：子 loop の refs 定義（default/required）への上書き。
+    // 子 run 起動時の起動時指定として渡る（省略＝上書きなし。検証は保存 API と
+    // 起動時の mergeRefs が行う。コンポーネントの設定値（refs）と1ノードのコンポーネント化.md）
+    refs: z.record(z.string(), z.unknown()).optional(),
 });
 // ノードにアタッチされた IOHook（node_hooks に対応。アタッチできるのは program ノードのみ）。
 // on_input / on_output / on_signal はアタッチ時に repo の config.json（hookManifestSchema）から
@@ -189,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）。回路と同じ「エディタの保存」で全置換する。
@@ -256,17 +266,16 @@ export const saveGraphBodySchema = z
                 outCount++;
         });
         // end は「in は1つ以上」（複数ルートを別々の in で集約する）。
-        // ai は2つ（上流データの in ＋ 差し戻しの instruction）。他 kind は1つ固定。
+        // ai も1つ以上（in は自由ポート：追加・削除・key 自由）。他 kind は1つ固定。
         // key の妥当性は kindPortsViolation が別途見る
-        const expectIn = node.kind === "ai" ? 2 : 1;
-        const inCountOk = node.kind === "end" ? inCount >= 1 : inCount === expectIn;
+        const inCountOk = node.kind === "end" || node.kind === "ai" ? inCount >= 1 : inCount === 1;
         if (!inCountOk) {
             ctx.addIssue({
                 code: "custom",
                 path: ["nodes", i, "ports"],
-                message: node.kind === "end"
+                message: node.kind === "end" || node.kind === "ai"
                     ? "in ポートが1つ以上必要です"
-                    : `in ポートはちょうど${expectIn}つ必要です`,
+                    : "in ポートはちょうど1つ必要です",
             });
         }
         if (outCount < 1) {
@@ -305,7 +314,8 @@ export const saveGraphBodySchema = z
                 message: "component ノードには component_loop_id が必要です",
             });
         }
-        // kind 別のポート構成（program 以外は数・key・io 固定。ポートのkind別仕様.md）
+        // kind 別のポート構成（program 以外は数・key・io 固定。ポートのkind別仕様.md）。
+        // ポートのスキーマ自体は kind によらず任意の JSON Schema（形の強制はしない）
         const violation = kindPortsViolation(node.kind, node.ports);
         if (violation) {
             ctx.addIssue({
@@ -314,19 +324,6 @@ export const saveGraphBodySchema = z
                 message: violation,
             });
         }
-        // AI の出力宣言は封筒型 { data: T, description: string }（T は任意の JSON Schema）。
-        // 複数出口でも全出口に強制する（どの出口も human に接続できる不変条件）
-        if (node.kind === "ai") {
-            node.ports.forEach((port, j) => {
-                if (port.io === "out" && !isAiEnvelopeSchema(port.schema)) {
-                    ctx.addIssue({
-                        code: "custom",
-                        path: ["nodes", i, "ports", j],
-                        message: "AI の出力は封筒型 { data, description } で宣言してください",
-                    });
-                }
-            });
-        }
     });
     // 接続：両端がグラフ内の port を指し、from=out / to=in。
     // 同じ out ポートから複数の in への fan-out は許す（並行分岐）。
@@ -407,16 +404,14 @@ export const saveGraphBodySchema = z
                 message: "終了ノードからは接続できません",
             });
         }
-        // 差し戻し（reject）と instruction の組み合わせは kind で縛らない：両端とも
-        // instructionSchema()（{ prompt, files }）で型が固定されているので、下の型検証だけで
-        // 「型が合う口にしか繋がらない」が成立する。差し戻し先が AI である必要はない
-        // （{ prompt, files } を受ける program へも繋げる）
+        // 差し戻し（reject）と instruction の組み合わせに kind の縛りも型固定も無い：
+        // reject の型はビューの宣言、instruction は ai の in の1つ（接続鏡映）でしかない
+        // → docs/tasks/wip/ポート型固定の撤去とセッション再開のポート属性化.md
         // 型検証は kind によらず常に 伝播型（out） ⊆ 伝播型（in）。
         // 未宣言は unknown＝判断できないので通す（作りかけのグラフを保存できなくしない）。
         // 接続鏡映する口（program / ai の in）とコピー宣言のビューは接続元の型を採用する
         // ので自明に通り、実質の検証対象は宣言で固定された口
-        // （component の契約・ai の instruction・宣言のあるビューの human.in）になる
-        // → docs/tasks/wip/Humanの入出力を承認ビューの宣言に一本化する.md
+        // （component の契約・宣言のあるビューの human.in）になる
         const fromSchema = resolved.get(conn.from_port_id) ?? from.schema;
         const toSchema = resolved.get(conn.to_port_id) ?? to.schema;
         if (!isSchemaSubset(fromSchema, toSchema)) {

package/dist/_schemas/node.d.ts

@@ -37,6 +37,7 @@ export declare const graphPortSchema: z.ZodObject<{
     key: z.ZodString;
     name: z.ZodString;
     schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    resume: z.ZodOptional<z.ZodBoolean>;
     side: z.ZodOptional<z.ZodEnum<{
         top: "top";
         right: "right";

package/dist/_schemas/node.js

@@ -36,6 +36,10 @@ export const graphPortSchema = z
     key: portKeySchema,
     name: z.string().min(1),
     schema: jsonSchemaSchema,
+    // in ポートの実行属性：true ならこの口から届いた実行は前回セッションを復元して
+    // 再開する（AI ノードで意味を持つ。key ではなくこの属性が再開を決める。
+    // ポート型固定の撤去とセッション再開のポート属性化.md）
+    resume: z.boolean().optional(),
     side: portSideSchema.optional(),
     offset: z.number().min(0).max(1).optional(),
 })

package/dist/_schemas/port-spec.d.ts

@@ -6,7 +6,6 @@ export declare const FILE_SCHEMA_MARKER = "x-mawaru-type";
 export declare const FILE_SCHEMA_TYPE = "file";
 export declare const fileSchema: () => JsonSchema;
 export declare const isFileSchema: (schema: JsonSchema) => boolean;
-export declare const AI_INSTRUCTION_PORT_KEY = "instruction";
 export declare const instructionSchema: () => JsonSchema;
 export declare const LIST_COLUMN_TYPES: readonly ["string", "number", "boolean", "date"];
 export declare const listColumnTypeSchema: z.ZodEnum<{
@@ -45,9 +44,6 @@ export declare const dataFormatSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 export type DataFormat = z.infer<typeof dataFormatSchema>;
 export declare const dataSchemaOf: (format: DataFormat) => JsonSchema;
 export declare const dataFormatOf: (schema: JsonSchema) => DataFormat | null;
-export declare const envelopeSchemaOf: (dataSchema: JsonSchema) => JsonSchema;
-export declare const envelopeDataSchemaOf: (schema: JsonSchema) => JsonSchema | null;
-export declare const isAiEnvelopeSchema: (schema: JsonSchema) => boolean;
 export declare const fixedInKeysOf: (kind: string) => string[] | null;
 export declare const manifestInKeysViolation: (kind: string, keys: string[]) => string | null;
 export declare const kindPortsViolation: (kind: string, ports: Pick<GraphPort, "io" | "key">[]) => string | null;
@@ -67,7 +63,8 @@ export type DeclaredPortSchema = JsonSchema | typeof COPY_UPSTREAM_SCHEMA;
 export type PropagationOptions<N> = {
     viewPortSchemasOf?: (node: N) => {
         in: DeclaredPortSchema;
-        out: DeclaredPortSchema;
+        approve: DeclaredPortSchema;
+        reject: JsonSchema;
     } | null | undefined;
 };
 export declare const resolvePortSchemas: <N extends PropagationNode>(nodes: N[], connections: PortLink[], options?: PropagationOptions<N>) => Map<string, JsonSchema>;