@mawaru/sdk 0.39.0 → 0.41.0

package/dist/_schemas/graph.js

@@ -116,10 +116,16 @@ export const assignMemberSchema = z.union([z.uuid(), z.literal(RUN_STARTER)]);
 // メンバーが tenant の membership であることの検証は保存 API 側で行う
 // （docs/tasks/backlog/Human担当者の高度化（複数人承認とラウンドロビン）.md）
 export const humanConfigSchema = z.object({
-    // 承認 UI（承認ビュー）の識別子。program_dir / ai_dir と同じ「不透明なキー」で、
-    // どのキーが実在するか・そのテナントが選べるかは保存時に mawaru 側が検証する
-    // （カタログは非公開。@mawaru/common の approval-view.ts）。省略時は標準ビュー
-    view: z.string().min(1).optional(),
+    // 実装（承認画面と入出力の宣言）の置き場所：実行 repo の nodes/human/ 直下のディレクトリ名。
+    // program_dir / ai_dir と同じ。省略時は mawaru 内蔵の標準の承認画面
+    // （docs/tasks/wip/承認ビューの顧客repo配置.md の「human ノードの実装として置く」）
+    human_dir: z
+        .string()
+        .min(1)
+        .refine((v) => !v.includes("/") && !v.includes("\\") && v !== "." && v !== "..", "human_dir は nodes/human/ 直下のディレクトリ名で指定してください")
+        .optional(),
+    // 読むブランチ（省略時はデフォルトブランチ）。publish でその先頭の commit に固定する
+    ref: z.string().min(1).optional(),
     assignment: z
         .object({
         strategy: z.enum(["fixed", "round_robin"]).default("fixed"),
@@ -236,8 +242,8 @@ export const graphNodeSchema = z.object({
     // 表示アイコン（全 kind 共通の任意設定。human はフロントが担当から導出するので通常設定しない）
     icon: nodeIconSchema.optional(),
     // Slack ビュー（全 kind 共通の任意設定。実行中（human は承認待ち）・完了メッセージの見せ方）。
-    // human の view と同じ「不透明なキー」で、選べる key は GET slack-views が返す。
-    // <slug>/<name> は実行 repo の views/slack/<name>/（@mawaru/sdk/slack-view の契約で書く）。
+    // human の view と同じ「不透明なキー」で、選べる key は GET views/slack が返す。
+    // <slug>/<name> は実行 repo の views/slack/<name>/（@mawaru/sdk/views/slack の契約で書く）。
     // 保存時に mawaru が見るのは common/* の実在と <slug>/* の可視性だけ。
     // 省略＝承認待ちは承認ボタンだけ・完了は ✅ の1行（データは出さない）。
     // ポートの型には一切影響しない

package/dist/_schemas/human-manifest.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const humanManifestSchema: z.ZodObject<{
+    inputs: z.ZodRecord<z.ZodString, z.ZodObject<{
+        schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+    outputs: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    refs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export type HumanManifest = z.infer<typeof humanManifestSchema>;

package/dist/_schemas/human-manifest.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { jsonSchemaSchema, portKeySchema } from "./node.js";
+import { kindPortsViolation } from "./port-spec.js";
+// 顧客 repo の nodes/human/<dir>/config.json（human ノードの実装の入出力の宣言）。
+// program / AI の config.json と同じく、エディタがディレクトリを選んだときに inputs / outputs から
+// ports を起こし、ポートの編集は保存時にここへ書き戻される（実行時の正は ports テーブルのまま）。
+// 形は AI に揃える（inputs の値は { schema }、outputs の値は素の JSON Schema）。
+// 口の構成（in 1つ・approve / reject は必須・追加の出口は自由）は kind のポート構成の規則をそのまま使う
+export const humanManifestSchema = z
+    .object({
+    inputs: z.record(z.string(), z.object({ schema: jsonSchemaSchema })),
+    outputs: z.record(z.string(), jsonSchemaSchema),
+    // refs＝ループ変数の定義の転写（program と同じ。エディタのグラフ保存が一方向に書く生成物）
+    refs: z.record(portKeySchema, jsonSchemaSchema).default({}),
+})
+    .superRefine((manifest, ctx) => {
+    const violation = kindPortsViolation("human", [
+        ...Object.keys(manifest.inputs).map((key) => ({
+            io: "in",
+            key,
+        })),
+        ...Object.keys(manifest.outputs).map((key) => ({
+            io: "out",
+            key,
+        })),
+    ]);
+    if (violation)
+        ctx.addIssue({ code: "custom", message: violation });
+});

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

@@ -55,24 +55,18 @@ type PropagationNode = {
     id: string;
     kind: string;
     ports: GraphPort[];
+    human?: {
+        human_dir?: string | null;
+    } | null;
 };
 type PortLink = {
     from_port_id: string;
     to_port_id: string;
 };
-export declare const COPY_UPSTREAM_SCHEMA = "T";
-export type DeclaredPortSchema = JsonSchema | typeof COPY_UPSTREAM_SCHEMA;
-export type PropagationOptions<N> = {
-    viewPortSchemasOf?: (node: N) => {
-        in: DeclaredPortSchema;
-        approve: DeclaredPortSchema;
-        reject: JsonSchema;
-    } | null | undefined;
-};
-export declare const resolvePortSchemas: <N extends PropagationNode>(nodes: N[], connections: PortLink[], options?: PropagationOptions<N>) => Map<string, JsonSchema>;
+export declare const resolvePortSchemas: <N extends PropagationNode>(nodes: N[], connections: PortLink[]) => Map<string, JsonSchema>;
 export declare const resolveFlexiblePorts: (nodes: PropagationNode[], connections: PortLink[]) => Set<string>;
 export declare const connectionAccepted: (from: JsonSchema, to: Pick<GraphPort, "schema" | "flexible">) => boolean;
-export declare const propagateDerivedPorts: <N extends PropagationNode>(nodes: N[], connections: PortLink[], options?: PropagationOptions<N>) => N[];
+export declare const propagateDerivedPorts: <N extends PropagationNode>(nodes: N[], connections: PortLink[]) => N[];
 export type SchemaFit = "ok" | "mismatch" | "unknown";
 export declare const schemaFit: (sub: JsonSchema, sup: JsonSchema) => SchemaFit;
 export declare const isSchemaSubset: (sub: JsonSchema, sup: JsonSchema) => boolean;

package/dist/_schemas/port-spec.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 // ポートの kind 別型システム（docs/tasks/done/ポートのkind別仕様.md）。
-// 型の決まり方は2分類：宣言（program / ai の in・out。human はビューの宣言を転写）／
+// 型の決まり方は2分類：宣言（program / ai と、実装（nodes/human/<dir>/）を指す human の in・out）／
 // 導出（それ以外。接続元から伝播し、結果は ports.schema にキャッシュする）。
 // mawaru がコードで型を固定するポートは無い
 // （docs/tasks/done/ポート型固定の撤去とセッション再開のポート属性化.md）
@@ -222,9 +222,10 @@ export const kindPortsViolation = (kind, ports) => {
 // ---- 型伝播（導出ポートの解決） ----
 // 接続の両端は同じスキーマになる（値入力フォームのSchemaForm統一.md）。
 // wait は素通し（パラメトリック）ノード：in は接続元の out、out は in と同型。
-// human はビューの宣言を転写（"T" は素通しと同じ挙動。reject もビューの宣言）。
-// 宣言 out（program / ai）は触らない。
-// program / ai の in は**全ての口が**接続鏡映（sticky）：接続元 out が具体型のときだけ
+// human は実装（nodes/human/<dir>/）を指していれば program / ai と同じ宣言ノード、指していなければ
+// （標準の承認画面）wait と同じ素通し（approve は in と同型、reject は標準の差し戻し instructionSchema）。
+// 宣言 out（program / ai / 実装を指す human）は触らない。
+// program / ai（と実装を指す human）の in は**全ての口が**接続鏡映（sticky）：接続元 out が具体型のときだけ
 // 上書きし、未接続・型割れ・未宣言は現スキーマ（宣言）を維持する（鏡映結果は repo の
 // config.json へも書き戻される。docs/tasks/done/ポート編集のrepo書き戻し同期.md）
 // ---- 型としての同一性（schemaTypeKey） ----
@@ -273,9 +274,6 @@ export const mergeInboundSchemas = (schemas) => {
 // 流入の具体型が2種類以上あるか（＝同じポートに違う型を流し込んでいる）
 export const hasInboundConflict = (schemas) => new Set(schemas.filter((s) => !isUndeclaredSchema(s)).map(schemaTypeKey))
     .size > 1;
-// 「上流の out をそのままコピーする」（in）／「in と同型」（approve）を表す指示。
-// 承認ビューのカタログ（@mawaru/common）の COPY_UPSTREAM と同じ値
-export const COPY_UPSTREAM_SCHEMA = "T";
 // end も導出ノード（各 in は上流から、out main は未宣言）。個別処理は
 // resolvePortSchemas 内で行うが、初期スキーマを未宣言にするためここに含める。
 // start も導出ノード：out main は接続先の in から逆向きに転写し、in は out と同型
@@ -284,9 +282,14 @@ export const COPY_UPSTREAM_SCHEMA = "T";
 const DERIVED_KINDS = new Set(["wait", "human", "end", "start", "join"]);
 // in を接続鏡映（sticky）するノード：接続元 out が具体型のときだけ上書き
 const MIRROR_KINDS = new Set(["program", "ai"]);
-const isDerivedPort = (kind, port) => DERIVED_KINDS.has(kind) &&
+// 実装（nodes/human/<dir>/）を指す human は program / ai と同じ（in は鏡映・out は宣言。
+// 型は config.json へ書き戻される）。指していない human は導出（標準の承認画面の素通し）
+const isMirrorNode = (node) => MIRROR_KINDS.has(node.kind) ||
+    (node.kind === "human" && Boolean(node.human?.human_dir));
+const isDerivedNode = (node) => DERIVED_KINDS.has(node.kind) && !isMirrorNode(node);
+const isDerivedPort = (node, port) => isDerivedNode(node) &&
     (port.io === "in" ||
-        (kind !== "human" && port.key === "main") ||
+        (node.kind !== "human" && port.key === "main") ||
         port.key === "approve" ||
         port.key === "reject");
 // port_id → 解決済みスキーマ。導出は接続を遡って固定点まで反復し、
@@ -294,13 +297,13 @@ const isDerivedPort = (kind, port) => DERIVED_KINDS.has(kind) &&
 // ai の in は nodes/ai/<dir>/config.json の inputs[key].schema 由来の宣言型が初期値で、
 // 接続時は program と同じ鏡映で接続元と同値に同期される（どの in も対等。
 // instruction への型の焼き込みは廃止）
-export const resolvePortSchemas = (nodes, connections, options) => {
+export const resolvePortSchemas = (nodes, connections) => {
     const resolved = new Map();
     const kindByPortId = new Map();
     for (const node of nodes) {
         for (const port of node.ports) {
             kindByPortId.set(port.id, node.kind);
-            resolved.set(port.id, isDerivedPort(node.kind, port) ? UNDECLARED_SCHEMA : port.schema);
+            resolved.set(port.id, isDerivedPort(node, port) ? UNDECLARED_SCHEMA : port.schema);
         }
     }
     // in ポートへの流入（差し戻しの fan-in があり得る。1本のときだけ型を採用）
@@ -373,10 +376,10 @@ export const resolvePortSchemas = (nodes, connections, options) => {
                 }
                 continue;
             }
-            const isMirror = MIRROR_KINDS.has(node.kind);
-            if (!DERIVED_KINDS.has(node.kind) && !isMirror)
+            const isMirror = isMirrorNode(node);
+            if (!isDerivedNode(node) && !isMirror)
                 continue;
-            // 鏡映（program / ai）：全ての in が対象。具体型が流れてきたときだけ上書きする
+            // 鏡映（program / ai / 実装を指す human）：全ての in が対象。具体型が流れてきたときだけ上書きする
             // （宣言を未宣言で潰さない）。ai の in はどの口も対等（instruction の特別扱いは無い）
             if (isMirror) {
                 for (const port of node.ports) {
@@ -392,34 +395,22 @@ export const resolvePortSchemas = (nodes, connections, options) => {
                 }
                 continue;
             }
-            // 導出（wait / human）：in は上流から
+            // 導出（wait / 実装を指さない human）：in は上流から、out（main・approve）は in と同型。
+            // human の reject は標準の承認画面の差し戻し（指示＋参考ファイル）。
+            // 上流の out は書き換えない（逆伝播すると fan-out 先の型割れが config.json へ書き戻され、
+            // 元の出力宣言を黙って壊す。ズレは接続の型エラーで見せる）
             const inPort = node.ports.find((p) => p.io === "in");
             if (!inPort)
                 continue;
             const sources = inbound.get(inPort.id) ?? [];
             const inSchema = mergeInboundSchemas(sources.map((id) => resolved.get(id) ?? UNDECLARED_SCHEMA));
-            // 承認ビューの宣言を human のポートへそのまま転写する（上流ノードの kind は見ない）。
-            // "T" は「上流の out をコピー」（in）／「in と同型」（approve）。reject は具体型の宣言
-            // のみで、宣言が無ければ未宣言のまま（mawaru が型を焼き込むことはしない）。
-            // 上流の out は書き換えない：逆伝播すると fan-out 先のビューが食い違ったとき
-            // 型割れが config.json へ write-through され、元の出力宣言を黙って壊す。
-            // ズレは接続の型エラーで見せてユーザーの [修正する] で直す
-            const declared = options?.viewPortSchemasOf?.(node);
-            const effectiveIn = declared && declared.in !== COPY_UPSTREAM_SCHEMA
-                ? declared.in
-                : inSchema;
-            assign(inPort.id, effectiveIn);
+            assign(inPort.id, inSchema);
             for (const port of node.ports) {
-                if (port.io !== "out" || !isDerivedPort(node.kind, port))
+                if (port.io !== "out" || !isDerivedPort(node, port))
                     continue;
-                if (node.kind === "human" && port.key === "reject") {
-                    if (declared)
-                        assign(port.id, declared.reject);
-                    continue;
-                }
-                assign(port.id, declared && declared.approve !== COPY_UPSTREAM_SCHEMA
-                    ? declared.approve
-                    : effectiveIn);
+                assign(port.id, node.kind === "human" && port.key === "reject"
+                    ? instructionSchema()
+                    : inSchema);
             }
         }
         if (!changed)
@@ -470,8 +461,8 @@ export const resolveFlexiblePorts = (nodes, connections) => {
 // sdk の保存契約・backend の保存時チェック・エディタの表示はすべてこれを使う
 // （判定が散ると表示と保存がズレる）
 export const connectionAccepted = (from, to) => to.flexible === true || isSchemaSubset(from, to.schema);
-export const propagateDerivedPorts = (nodes, connections, options) => {
-    const resolved = resolvePortSchemas(nodes, connections, options);
+export const propagateDerivedPorts = (nodes, connections) => {
+    const resolved = resolvePortSchemas(nodes, connections);
     const flexiblePorts = resolveFlexiblePorts(nodes, connections);
     return nodes.map((node) => {
         let touched = false;

package/dist/cli.js

@@ -12,7 +12,7 @@ const USAGE = `使い方: mawaru <command> [引数]
 
 コマンド:
   init       repo を mawaru 実行用に初期化する（runner yml・nodes/ 骨組み・スキルポインタ等。再実行は冪等）
-  typegen    nodes/program/<dir>/config.json から types.d.ts（Input / Outputs / Output 型）を生成する
+  typegen    nodes/program/<dir>/・nodes/human/<dir>/ の config.json から types.d.ts を生成する
   validate   リポジトリ規約を検証する（error があれば exit 1。CI 向け）
   login      ブラウザで承認して mawaru にログインする（~/.mawaru/credentials.json）
   logout     保存した資格情報を消す

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from "./_schemas/duplicate-selection.js";
 export * from "./_schemas/extract-component.js";
 export * from "./_schemas/graph.js";
 export * from "./_schemas/hook-manifest.js";
+export * from "./_schemas/human-manifest.js";
 export * from "./_schemas/node.js";
 export * from "./_schemas/port-spec.js";
 export * from "./_schemas/program-manifest.js";

package/dist/index.js

@@ -6,6 +6,7 @@ export * from "./_schemas/duplicate-selection.js";
 export * from "./_schemas/extract-component.js";
 export * from "./_schemas/graph.js";
 export * from "./_schemas/hook-manifest.js";
+export * from "./_schemas/human-manifest.js";
 export * from "./_schemas/node.js";
 export * from "./_schemas/port-spec.js";
 export * from "./_schemas/program-manifest.js";

package/dist/init.js

@@ -68,13 +68,32 @@ export const runInit = (root) => {
     // 作用してしまうため、ドット無しの "gitignore" で持つ
     writeIfAbsent(".gitignore", template("gitignore"));
     // package.json：@mawaru/sdk を devDependencies に（ポインタ・docs の参照解決と
-    // typegen / validate CLI のため）。バージョンはこのパッケージ自身から取る
-    const sdkVersion = JSON.parse(readFileSync(join(packageRoot(), "package.json"), "utf-8")).version;
+    // typegen / validate CLI のため）。承認ビュー（TSX）の型のために @types/react も。
+    // バージョンはこのパッケージ自身から取る
+    const sdkPackage = JSON.parse(readFileSync(join(packageRoot(), "package.json"), "utf-8"));
     writeIfAbsent("package.json", `${JSON.stringify({
         name: "mawaru",
         private: true,
         type: "module",
-        devDependencies: { "@mawaru/sdk": `^${sdkVersion}` },
+        devDependencies: {
+            "@mawaru/sdk": `^${sdkPackage.version}`,
+            "@types/react": sdkPackage.devDependencies["@types/react"],
+        },
+    }, null, 2)}\n`);
+    // tsconfig.json：エディタで human ノードの実装（nodes/human/）と Slack ビュー（views/）を型検査するための設定。
+    // ビルドはしない（mawaru がまとめる）。import の解決は mawaru のまとめ方（esbuild）に揃える
+    writeIfAbsent("tsconfig.json", `${JSON.stringify({
+        compilerOptions: {
+            target: "ES2022",
+            module: "ESNext",
+            moduleResolution: "Bundler",
+            jsx: "react-jsx",
+            lib: ["ES2023", "DOM", "DOM.Iterable"],
+            strict: true,
+            noEmit: true,
+            skipLibCheck: true,
+        },
+        include: ["nodes/human", "views"],
     }, null, 2)}\n`);
     // runner yml の `npm ci` とポインタの参照解決は node_modules / lockfile が前提
     if (!existsSync(join(root, "package-lock.json"))) {

package/dist/typegen.d.ts

@@ -1,9 +1,11 @@
+import { type HumanManifest } from "./_schemas/human-manifest.js";
 import type { JsonSchema } from "./_schemas/node.js";
 import { type ProgramManifest } from "./_schemas/program-manifest.js";
 export declare const CONFIG_HASH_PREFIX = "// mawaru:config-hash=";
 export declare const configHash: (rawConfig: string) => string;
-export declare const tsTypeFromJsonSchema: (schema: JsonSchema, indent?: number) => string;
+export declare const tsTypeFromJsonSchema: (schema: JsonSchema, indent?: number, fileAs?: string) => string;
 export declare const renderTypesFile: (manifest: ProgramManifest, rawConfig: string) => string;
+export declare const renderHumanTypesFile: (manifest: HumanManifest, rawConfig: string) => string;
 export type TypegenResult = {
     written: string[];
     errors: {

package/dist/typegen.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { REFS_INPUT_KEY } from "./_schemas/graph.js";
+import { humanManifestSchema, } from "./_schemas/human-manifest.js";
 import { programManifestSchema, } from "./_schemas/program-manifest.js";
 // 生成ファイルに刻む config.json 内容のハッシュ。validate が drift（config を変えて
 // typegen し忘れ）の検出に使う
@@ -12,14 +13,14 @@ const propertyKey = (key) => IDENTIFIER_RE.test(key) ? key : JSON.stringify(key)
 const literalType = (value) => value === null ? "null" : (JSON.stringify(value) ?? "unknown");
 // union / tuple の要素は結合子と混ざらないよう括弧で包む
 const wrapIfUnion = (type) => type.includes(" | ") || type.includes(" & ") ? `(${type})` : type;
-const objectType = (schema, indent) => {
+const objectType = (schema, indent, fileAs) => {
     const properties = schema.properties;
     if (typeof properties !== "object" ||
         properties === null ||
         Array.isArray(properties)) {
         const additional = schema.additionalProperties;
         if (typeof additional === "object" && additional !== null) {
-            return `Record<string, ${tsTypeFromJsonSchema(additional, indent)}>`;
+            return `Record<string, ${tsTypeFromJsonSchema(additional, indent, fileAs)}>`;
         }
         if (additional === false) {
             return "Record<string, never>";
@@ -39,14 +40,14 @@ const objectType = (schema, indent) => {
             lines.push(`${inner}/** ${description} */`);
         }
         const optional = required.has(key) ? "" : "?";
-        lines.push(`${inner}${propertyKey(key)}${optional}: ${tsTypeFromJsonSchema(propSchema, indent + 1)}`);
+        lines.push(`${inner}${propertyKey(key)}${optional}: ${tsTypeFromJsonSchema(propSchema, indent + 1, fileAs)}`);
     }
     if (lines.length === 0) {
         return "Record<string, unknown>";
     }
     return `{\n${lines.join("\n")}\n${"  ".repeat(indent)}}`;
 };
-const namedType = (typeName, schema, indent) => {
+const namedType = (typeName, schema, indent, fileAs) => {
     switch (typeName) {
         case "string":
             return "string";
@@ -60,22 +61,24 @@ const namedType = (typeName, schema, indent) => {
         case "array": {
             const items = schema.items;
             if (Array.isArray(items)) {
-                return `[${items.map((i) => tsTypeFromJsonSchema(i, indent)).join(", ")}]`;
+                return `[${items.map((i) => tsTypeFromJsonSchema(i, indent, fileAs)).join(", ")}]`;
             }
             if (typeof items === "object" && items !== null) {
-                return `${wrapIfUnion(tsTypeFromJsonSchema(items, indent))}[]`;
+                return `${wrapIfUnion(tsTypeFromJsonSchema(items, indent, fileAs))}[]`;
             }
             return "unknown[]";
         }
         case "object":
-            return objectType(schema, indent);
+            return objectType(schema, indent, fileAs);
         default:
             return "unknown";
     }
 };
 // JSON Schema（zodFromJsonSchema が扱うサブセット）を TS 型の文字列に写す。
 // 解釈できない形は unknown に落とす（型が付かないだけで、実行時検証は ports 側が担う）
-export const tsTypeFromJsonSchema = (schema, indent = 0) => {
+// fileAs＝file 型の TS 型。program の handler は手元のパス（string）を受ける。承認ビューは参照
+// （FileRef）のまま受ける
+export const tsTypeFromJsonSchema = (schema, indent = 0, fileAs = "string") => {
     if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
         return "unknown";
     }
@@ -84,7 +87,7 @@ export const tsTypeFromJsonSchema = (schema, indent = 0) => {
     // 出力にローカルパスを書く契約なので、参照 object ではなく string を生成する
     // （AI 側の schemaWithFilesAsPath と同じ規約）
     if (schema["x-mawaru-type"] === "file") {
-        return "string";
+        return fileAs;
     }
     if ("const" in schema) {
         return literalType(schema.const);
@@ -97,22 +100,24 @@ export const tsTypeFromJsonSchema = (schema, indent = 0) => {
     const variants = schema.oneOf ?? schema.anyOf;
     if (Array.isArray(variants) && variants.length > 0) {
         return variants
-            .map((v) => tsTypeFromJsonSchema(v, indent))
+            .map((v) => tsTypeFromJsonSchema(v, indent, fileAs))
             .join(" | ");
     }
     if (Array.isArray(schema.allOf) && schema.allOf.length > 0) {
         return schema.allOf
-            .map((v) => wrapIfUnion(tsTypeFromJsonSchema(v, indent)))
+            .map((v) => wrapIfUnion(tsTypeFromJsonSchema(v, indent, fileAs)))
             .join(" & ");
     }
     const type = schema.type;
     if (Array.isArray(type)) {
         return type.length > 0
-            ? type.map((t) => namedType(String(t), schema, indent)).join(" | ")
+            ? type
+                .map((t) => namedType(String(t), schema, indent, fileAs))
+                .join(" | ")
             : "unknown";
     }
     if (typeof type === "string") {
-        return namedType(type, schema, indent);
+        return namedType(type, schema, indent, fileAs);
     }
     return "unknown";
 };
@@ -166,8 +171,85 @@ export const renderTypesFile = (manifest, rawConfig) => {
         "",
     ].join("\n");
 };
-// nodes/program/ 直下の各 dir の config.json から types.d.ts を生成する
+// human ノードの実装（nodes/human/<dir>/config.json）の型。program と同じ Input / Outputs / Output / Refs を作り、
+// defineHuman<Input, Output, Refs>(({ input, out, ctx }) => …) に使う。
+// file は参照（FileRef）のまま届く（program の handler と違って実体化しない）
+export const renderHumanTypesFile = (manifest, rawConfig) => {
+    const inputType = tsTypeFromJsonSchema(manifest.inputs.in?.schema ?? {}, 0, "FileRef");
+    const outputEntries = Object.entries(manifest.outputs).map(([key, schema]) => `  ${propertyKey(key)}: ${tsTypeFromJsonSchema(schema, 1, "FileRef")}`);
+    // refs＝ループ変数の袋（program と同じ。予約キー input は run の起動入力）
+    const refEntries = [
+        `  ${propertyKey(REFS_INPUT_KEY)}: unknown`,
+        ...Object.entries(manifest.refs).map(([key, schema]) => `  ${propertyKey(key)}: ${tsTypeFromJsonSchema(schema, 1, "FileRef")}`),
+    ];
+    const usesFileRef = [inputType, ...outputEntries, ...refEntries].some((t) => t.includes("FileRef"));
+    return [
+        "// このファイルは mawaru typegen が config.json から自動生成した（手で編集しない）",
+        `${CONFIG_HASH_PREFIX}${configHash(rawConfig)}`,
+        "",
+        ...(usesFileRef
+            ? ['import type { FileRef } from "@mawaru/sdk/human"', ""]
+            : []),
+        `export type Input = ${inputType}`,
+        "",
+        `export type Outputs = {\n${outputEntries.join("\n")}\n}`,
+        "",
+        "// out に渡す値：ちょうど1つの出口ポートのキーで渡す { <出口キー>: 値 }",
+        outputUnionType(Object.keys(manifest.outputs)),
+        "",
+        `export type Refs = {\n${refEntries.join("\n")}\n}`,
+        "",
+    ].join("\n");
+};
+// nodes/human/ 直下の各 human ノードの実装の config.json から types.d.ts を生成する（program と同じ走査）
+const runHumanTypegen = (root) => {
+    const viewsDir = join(root, "nodes", "human");
+    const written = [];
+    const errors = [];
+    if (!existsSync(viewsDir))
+        return { written, errors };
+    for (const entry of readdirSync(viewsDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const dir = `nodes/human/${entry.name}`;
+        const configPath = join(viewsDir, entry.name, "config.json");
+        if (!existsSync(configPath)) {
+            errors.push({ dir, message: "config.json がありません" });
+            continue;
+        }
+        const rawConfig = readFileSync(configPath, "utf8");
+        let parsed;
+        try {
+            parsed = JSON.parse(rawConfig);
+        }
+        catch {
+            errors.push({ dir, message: "config.json が JSON として不正です" });
+            continue;
+        }
+        const config = humanManifestSchema.safeParse(parsed);
+        if (!config.success) {
+            errors.push({
+                dir,
+                message: `config.json が規約に合いません（${config.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(" / ")}）`,
+            });
+            continue;
+        }
+        const typesPath = join(viewsDir, entry.name, "types.d.ts");
+        writeFileSync(typesPath, renderHumanTypesFile(config.data, rawConfig));
+        written.push(typesPath);
+    }
+    return { written, errors };
+};
+// nodes/program/ 直下の各 dir と、nodes/human/ 直下の各実装の config.json から types.d.ts を生成する
 export const runTypegen = (root) => {
+    const programs = runProgramTypegen(root);
+    const views = runHumanTypegen(root);
+    return {
+        written: [...programs.written, ...views.written],
+        errors: [...programs.errors, ...views.errors],
+    };
+};
+const runProgramTypegen = (root) => {
     const programsDir = join(root, "nodes", "program");
     if (!existsSync(programsDir)) {
         return {

package/dist/validate.js

@@ -2,6 +2,7 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join, relative } from "node:path";
 import { z } from "zod";
 import { convertJsonSchemaToZod } from "zod-from-json-schema";
+import { humanManifestSchema } from "./_schemas/human-manifest.js";
 import { programManifestSchema } from "./_schemas/program-manifest.js";
 import { CONFIG_HASH_PREFIX, configHash } from "./typegen.js";
 // エディタ・オーケストレータは zod-from-json-schema（common の zodFromJsonSchema）で
@@ -101,6 +102,61 @@ const validateProgram = (programsDir, dir, root) => {
     checkTypegenDrift(programDir, rawConfig, path, issues);
     return issues;
 };
+// human ノードの実装（nodes/human/<dir>/）：config.json・index.tsx・types.d.ts の drift（program と同じ検査）
+const validateHumans = (root) => {
+    const issues = [];
+    const viewsDir = join(root, "nodes", "human");
+    if (!existsSync(viewsDir))
+        return issues;
+    for (const entry of readdirSync(viewsDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const viewDir = join(viewsDir, entry.name);
+        const path = relative(root, viewDir);
+        if (!existsSync(join(viewDir, "index.tsx"))) {
+            issues.push({ level: "error", path, message: "index.tsx がありません" });
+        }
+        const configPath = join(viewDir, "config.json");
+        if (!existsSync(configPath)) {
+            issues.push({ level: "error", path, message: "config.json がありません" });
+            continue;
+        }
+        const rawConfig = readFileSync(configPath, "utf8");
+        let parsed;
+        try {
+            parsed = JSON.parse(rawConfig);
+        }
+        catch {
+            issues.push({
+                level: "error",
+                path: `${path}/config.json`,
+                message: "JSON として不正です",
+            });
+            continue;
+        }
+        const config = humanManifestSchema.safeParse(parsed);
+        if (!config.success) {
+            for (const issue of config.error.issues) {
+                const at = issue.path.length > 0 ? `${issue.path.join(".")}: ` : "";
+                issues.push({
+                    level: "error",
+                    path: `${path}/config.json`,
+                    message: `${at}${issue.message}`,
+                });
+            }
+            continue;
+        }
+        checkPortSchemas(Object.fromEntries(Object.entries(config.data.inputs).map(([key, value]) => [
+            key,
+            value.schema,
+        ])), "inputs", `${path}/config.json`, issues);
+        checkPortSchemas(config.data.outputs, "outputs", `${path}/config.json`, issues);
+        if (existsSync(join(viewDir, "types.d.ts"))) {
+            checkTypegenDrift(viewDir, rawConfig, path, issues);
+        }
+    }
+    return issues;
+};
 // リポジトリ規約の構造検証。error が1つでもあれば CI を落とす想定（cli.ts が exit 1）
 export const validateRepo = (root) => {
     const issues = [];
@@ -119,6 +175,7 @@ export const validateRepo = (root) => {
             }
         }
     }
+    issues.push(...validateHumans(root));
     if (!existsSync(join(root, ".github", "workflows", "mawaru-runner.yml"))) {
         issues.push({
             level: "warning",

package/dist/views/_bridge.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from "react";
+import type { FileRef } from "./_parts/fileRef.js";
+export type ViewBridge = {
+    fileUrl: (file: FileRef) => Promise<string>;
+    uploadFile: (file: File) => Promise<FileRef>;
+    copyText: (text: string) => Promise<void>;
+};
+export declare const ViewBridgeProvider: ({ bridge, children, }: {
+    bridge: ViewBridge;
+    children: ReactNode;
+}) => import("react").JSX.Element;
+export declare const useViewBridge: () => ViewBridge;

package/dist/views/_bridge.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+const ViewBridgeContext = createContext(null);
+export const ViewBridgeProvider = ({ bridge, children, }) => (_jsx(ViewBridgeContext.Provider, { value: bridge, children: children }));
+export const useViewBridge = () => {
+    const bridge = useContext(ViewBridgeContext);
+    if (!bridge)
+        throw new Error("ViewBridgeProvider の中で使ってください");
+    return bridge;
+};

package/dist/views/_humanProps.d.ts

@@ -0,0 +1,10 @@
+import type { FileRef } from "./_parts/fileRef.js";
+import type { HumanProps } from "./human.js";
+import type { HumanViewData } from "./protocol.js";
+export type HumanOps = {
+    out: (output: Record<string, unknown>) => Promise<void>;
+    fetchFileUrl: (file: FileRef) => Promise<string>;
+    uploadFile: (file: File) => Promise<FileRef>;
+    writeText: (text: string) => Promise<void>;
+};
+export declare const humanPropsOf: (data: HumanViewData, ops: HumanOps) => HumanProps;

package/dist/views/_humanProps.js

@@ -0,0 +1,11 @@
+export const humanPropsOf = (data, ops) => ({
+    input: data.input,
+    out: ops.out,
+    ctx: {
+        input: { schema: data.inputSchema, fetchFileUrl: ops.fetchFileUrl },
+        output: { schema: data.outputSchema, uploadFile: ops.uploadFile },
+        clipboard: { writeText: ops.writeText },
+        refs: (data.refs ?? {}),
+        step: { isAssignee: data.isAssignee, editable: data.editable },
+    },
+});