@mawaru/sdk 0.40.0 → 0.41.0

package/dist/_schemas/human-manifest.js

@@ -1,121 +1,29 @@
 import { z } from "zod";
-import { jsonSchemaSchema } from "./node.js";
-import { COPY_UPSTREAM_SCHEMA, instructionSchema, } from "./port-spec.js";
-// 宣言に書ける type。file は x-mawaru-type マーカー付きの object
-const DECLARED_TYPES = [
-    "object",
-    "array",
-    "string",
-    "number",
-    "integer",
-    "boolean",
-];
-const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-// JSON Schema の形の崩れを場所つきで返す。接続の比較（schemaFit）が扱える形だけを通す：
-// 顧客 repo の宣言は mawaru のレビューを通らないので、壊れた型がノードに写る前に止める
-const schemaIssues = (schema, path) => {
-    const issues = [];
-    const { type, properties, required, items } = schema;
-    if (Array.isArray(type)) {
-        issues.push({
-            path: [...path, "type"],
-            message: "配列（nullable）は使えません。任意の値は required から外してください",
-        });
-    }
-    else if (type !== undefined &&
-        !DECLARED_TYPES.includes(type)) {
-        issues.push({
-            path: [...path, "type"],
-            message: `type は ${DECLARED_TYPES.join(" / ")} のどれかにしてください（${String(type)}）`,
-        });
-    }
-    else if (type === undefined &&
-        (properties !== undefined || items !== undefined)) {
-        issues.push({
-            path: [...path, "type"],
-            message: "properties / items を書くときは type も書いてください",
-        });
-    }
-    if (properties !== undefined) {
-        if (!isPlainObject(properties)) {
-            issues.push({
-                path: [...path, "properties"],
-                message: "properties はオブジェクトで書いてください",
-            });
-        }
-        else {
-            for (const [key, child] of Object.entries(properties)) {
-                if (!isPlainObject(child)) {
-                    issues.push({
-                        path: [...path, "properties", key],
-                        message: "スキーマはオブジェクトで書いてください",
-                    });
-                    continue;
-                }
-                issues.push(...schemaIssues(child, [...path, "properties", key]));
-            }
-        }
-    }
-    if (required !== undefined &&
-        !(Array.isArray(required) && required.every((r) => typeof r === "string"))) {
-        issues.push({
-            path: [...path, "required"],
-            message: "required は文字列の配列で書いてください",
-        });
-    }
-    if (items !== undefined) {
-        if (!isPlainObject(items)) {
-            issues.push({
-                path: [...path, "items"],
-                message: "items はスキーマ（オブジェクト）で書いてください",
-            });
-        }
-        else {
-            issues.push(...schemaIssues(items, [...path, "items"]));
-        }
-    }
-    return issues;
-};
-// 宣言に書く1つの型（検査つき）
-const checkedSchema = jsonSchemaSchema.superRefine((schema, ctx) => {
-    for (const issue of schemaIssues(schema, []))
-        ctx.addIssue({ code: "custom", ...issue });
-});
-const declaredPortSchema = z.union([
-    z.literal(COPY_UPSTREAM_SCHEMA),
-    checkedSchema,
-]);
-export const humanDeclarationSchema = z.object({
-    in: declaredPortSchema,
-    approve: declaredPortSchema,
-    reject: checkedSchema,
-});
-// 標準ビュー（common/standard）の宣言：上流の型をそのまま受けて出し、差し戻しは標準の指示フォーム
-export const STANDARD_HUMAN_DECLARATION = {
-    in: COPY_UPSTREAM_SCHEMA,
-    approve: COPY_UPSTREAM_SCHEMA,
-    reject: instructionSchema(),
-};
-// ---- 顧客 repo の nodes/human/<dir>/config.json ----
-// 形は AI の config.json に揃える（inputs の値は { schema }、outputs の値は素の JSON Schema）。
-// 口は in / approve / reject 固定。省略した口は STANDARD_HUMAN_DECLARATION と同じ扱い
+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
-        .object({ in: z.object({ schema: checkedSchema }).strict().optional() })
-        .strict()
-        .optional(),
-    outputs: z
-        .object({
-        approve: checkedSchema.optional(),
-        reject: checkedSchema.optional(),
-    })
-        .strict()
-        .optional(),
+    inputs: z.record(z.string(), z.object({ schema: jsonSchemaSchema })),
+    outputs: z.record(z.string(), jsonSchemaSchema),
+    // refs＝ループ変数の定義の転写（program と同じ。エディタのグラフ保存が一方向に書く生成物）
+    refs: z.record(portKeySchema, jsonSchemaSchema).default({}),
 })
-    .strict();
-export const humanDeclarationOfManifest = (config) => ({
-    in: config.inputs?.in?.schema ?? COPY_UPSTREAM_SCHEMA,
-    approve: config.outputs?.approve ?? COPY_UPSTREAM_SCHEMA,
-    reject: config.outputs?.reject ?? instructionSchema(),
+    .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

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import type { HumanDeclaration } from "./human-manifest.js";
 import type { GraphPort, JsonSchema } from "./node.js";
 export declare const UNDECLARED_SCHEMA: JsonSchema;
 export declare const isUndeclaredSchema: (schema: JsonSchema) => boolean;
@@ -57,15 +56,13 @@ type PropagationNode = {
     kind: string;
     ports: GraphPort[];
     human?: {
-        declaration?: HumanDeclaration;
+        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 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;

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 は実装（nodes/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 は実装（nodes/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 → 解決済みスキーマ。導出は接続を遡って固定点まで反復し、
@@ -300,7 +303,7 @@ export const resolvePortSchemas = (nodes, connections) => {
     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) => {
                 }
                 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) => {
                 }
                 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));
-            // 実装（nodes/human/<dir>/）の宣言を human のポートへそのまま転写する（上流ノードの kind は見ない）。
-            // "T" は「上流の out をコピー」（in）／「in と同型」（approve）。reject は具体型の宣言
-            // のみで、宣言が無ければ未宣言のまま（mawaru が型を焼き込むことはしない）。
-            // 上流の out は書き換えない：逆伝播すると fan-out 先のビューが食い違ったとき
-            // 型割れが config.json へ write-through され、元の出力宣言を黙って壊す。
-            // ズレは接続の型エラーで見せてユーザーの [修正する] で直す
-            const declared = node.kind === "human" ? node.human?.declaration : undefined;
-            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)

package/dist/cli.js

@@ -19,8 +19,7 @@ const USAGE = `使い方: mawaru <command> [引数]
   session resume <step URL>
              AI ノードのセッションを手元に復元して CLI（claude / codex）の resume で再開する
   preview <種類>/<名前> [--case <ケース名>] [--surface running|completed] [--channel <#名前|ID>]
-             push せずに手元のファイルで確かめる（human：nodes/human/ の承認画面をブラウザで開く／
-             slack：views/slack/ のビューで cases.ts のケースを Slack に送る）`;
+             views/ のビューを push せずに手元のファイルで確かめる（slack：cases.ts のケースを Slack に送る）`;
 const [command, ...rest] = process.argv.slice(2);
 // init / typegen / validate は repo ルートを任意で受ける（省略時はカレント）
 const root = rest[0] ?? process.cwd();

package/dist/typegen.d.ts

@@ -1,11 +1,11 @@
-import { type HumanDeclaration } from "./_schemas/human-manifest.js";
+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, fileAs?: string) => string;
 export declare const renderTypesFile: (manifest: ProgramManifest, rawConfig: string) => string;
-export declare const renderApprovalViewTypesFile: (declaration: HumanDeclaration, rawConfig: string) => string;
+export declare const renderHumanTypesFile: (manifest: HumanManifest, rawConfig: string) => string;
 export type TypegenResult = {
     written: string[];
     errors: {

package/dist/typegen.js

@@ -2,7 +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 { humanDeclarationOfManifest, humanManifestSchema, } from "./_schemas/human-manifest.js";
+import { humanManifestSchema, } from "./_schemas/human-manifest.js";
 import { programManifestSchema, } from "./_schemas/program-manifest.js";
 // 生成ファイルに刻む config.json 内容のハッシュ。validate が drift（config を変えて
 // typegen し忘れ）の検出に使う
@@ -171,15 +171,18 @@ export const renderTypesFile = (manifest, rawConfig) => {
         "",
     ].join("\n");
 };
-// human ノードの実装（nodes/human/<dir>/config.json）の型。ビューの ctx の型（defineApprovalView<In>）と、
-// 承認バーで approve に流す値の型（<ApprovalBar<Approve> output={…} />）に使う。
+// human ノードの実装（nodes/human/<dir>/config.json）の型。program と同じ Input / Outputs / Output / Refs を作り、
+// defineHuman<Input, Output, Refs>(({ input, out, ctx }) => …) に使う。
 // file は参照（FileRef）のまま届く（program の handler と違って実体化しない）
-export const renderApprovalViewTypesFile = (declaration, rawConfig) => {
-    const typeOf = (schema) => tsTypeFromJsonSchema(schema, 0, "FileRef");
-    const inType = declaration.in === "T" ? "unknown" : typeOf(declaration.in);
-    const approveType = declaration.approve === "T" ? "In" : typeOf(declaration.approve);
-    const rejectType = typeOf(declaration.reject);
-    const usesFileRef = [inType, approveType, rejectType].some((t) => t.includes("FileRef"));
+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)}`,
@@ -187,18 +190,18 @@ export const renderApprovalViewTypesFile = (declaration, rawConfig) => {
         ...(usesFileRef
             ? ['import type { FileRef } from "@mawaru/sdk/human"', ""]
             : []),
-        "// 承認待ちの値（ctx.output）。inputs.in を省略した（上流の型をそのまま受ける）なら unknown",
-        `export type In = ${inType}`,
+        `export type Input = ${inputType}`,
+        "",
+        `export type Outputs = {\n${outputEntries.join("\n")}\n}`,
         "",
-        "// 承認で approve に載せる値（ApprovalBar の output）。省略したなら In と同じ",
-        `export type Approve = ${approveType}`,
+        "// out に渡す値：ちょうど1つの出口ポートのキーで渡す { <出口キー>: 値 }",
+        outputUnionType(Object.keys(manifest.outputs)),
         "",
-        "// 差し戻しで reject に載せる値",
-        `export type Reject = ${rejectType}`,
+        `export type Refs = {\n${refEntries.join("\n")}\n}`,
         "",
     ].join("\n");
 };
-// nodes/human/ 直下の各 human ノードの実装（`_` 始まりは部品の置き場なので除く）の config.json から types.d.ts を生成する
+// nodes/human/ 直下の各 human ノードの実装の config.json から types.d.ts を生成する（program と同じ走査）
 const runHumanTypegen = (root) => {
     const viewsDir = join(root, "nodes", "human");
     const written = [];
@@ -206,11 +209,8 @@ const runHumanTypegen = (root) => {
     if (!existsSync(viewsDir))
         return { written, errors };
     for (const entry of readdirSync(viewsDir, { withFileTypes: true })) {
-        if (!entry.isDirectory() ||
-            entry.name.startsWith("_") ||
-            entry.name.startsWith(".")) {
+        if (!entry.isDirectory())
             continue;
-        }
         const dir = `nodes/human/${entry.name}`;
         const configPath = join(viewsDir, entry.name, "config.json");
         if (!existsSync(configPath)) {
@@ -235,7 +235,7 @@ const runHumanTypegen = (root) => {
             continue;
         }
         const typesPath = join(viewsDir, entry.name, "types.d.ts");
-        writeFileSync(typesPath, renderApprovalViewTypesFile(humanDeclarationOfManifest(config.data), rawConfig));
+        writeFileSync(typesPath, renderHumanTypesFile(config.data, rawConfig));
         written.push(typesPath);
     }
     return { written, errors };

package/dist/validate.js

@@ -102,19 +102,15 @@ const validateProgram = (programsDir, dir, root) => {
     checkTypegenDrift(programDir, rawConfig, path, issues);
     return issues;
 };
-// human ノードの実装（nodes/human/<dir>/）：config.json（宣言の検査）・index.tsx・types.d.ts の drift。
-// `_` 始まりは部品の置き場なので見ない
+// 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() ||
-            entry.name.startsWith("_") ||
-            entry.name.startsWith(".")) {
+        if (!entry.isDirectory())
             continue;
-        }
         const viewDir = join(viewsDir, entry.name);
         const path = relative(root, viewDir);
         if (!existsSync(join(viewDir, "index.tsx"))) {
@@ -141,14 +137,20 @@ const validateHumans = (root) => {
         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: `${issue.path.join(".")}: ${issue.message}`,
+                    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);
         }

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 },
+    },
+});

package/dist/views/{index.d.ts → components.d.ts}

@@ -1,4 +1,3 @@
-export { useViewBridge, type ViewBridge } from "./_bridge.js";
 export { documentCardStyle } from "./_parts/DocumentCard.js";
 export { FilePreview } from "./_parts/FilePreview.js";
 export { type FileRef, isFileRef } from "./_parts/fileRef.js";

package/dist/views/components.js

@@ -0,0 +1,12 @@
+// 共通の部品（`@mawaru/sdk/components`）。human ノードの約束（`@mawaru/sdk/human`）には依存しない。
+// mawaru の画面と顧客 repo の human ノードの実装が同じ部品を使う（mawaru が顧客 repo の実装をまとめるとき、
+// mawaru の今の版のこの部品を同梱する）。ファイルの表示・アップロードは、mawaru の画面ではホストの口、
+// sandbox iframe の中では mawaru の承認画面への頼みごととして裏で差し込まれる（_bridge.tsx）。
+// **公開 API**：部品の props は後方互換でしか変えない
+export { documentCardStyle } from "./_parts/DocumentCard.js";
+export { FilePreview } from "./_parts/FilePreview.js";
+export { isFileRef } from "./_parts/fileRef.js";
+export { isUrl, Linkify, linkify } from "./_parts/Linkify.js";
+export { isLongText, Markdown, useAutoGrow } from "./_parts/Markdown.js";
+export { asFormSchema, SchemaForm, } from "./_parts/SchemaForm.js";
+export { NARROW_WIDTH, useNarrow } from "./_parts/useNarrow.js";

package/dist/views/host.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
-export { ApprovalActionsProvider } from "./_approvalActions.js";
-export { ViewBridgeProvider } from "./_bridge.js";
+export { useViewBridge, type ViewBridge, ViewBridgeProvider, } from "./_bridge.js";
+export { type HumanOps, humanPropsOf } from "./_humanProps.js";
 export * from "./protocol.js";
 export declare const viewToHostSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     tag: z.ZodLiteral<"mawaru:view">;
@@ -13,6 +13,11 @@ export declare const viewToHostSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     tag: z.ZodLiteral<"mawaru:view">;
     type: z.ZodLiteral<"request">;
     id: z.ZodNumber;
-    method: z.ZodString;
+    method: z.ZodEnum<{
+        out: "out";
+        fetchFileUrl: "fetchFileUrl";
+        uploadFile: "uploadFile";
+        writeText: "writeText";
+    }>;
     args: z.ZodUnknown;
 }, z.core.$strip>], "type">;

package/dist/views/host.js

@@ -1,10 +1,10 @@
 import { z } from "zod";
 import { VIEW_MESSAGE_TAG } from "./protocol.js";
-export { ApprovalActionsProvider } from "./_approvalActions.js";
 // ホスト（mawaru の画面）だけが使うもの（公開 API ではない）：sandbox iframe からのメッセージを確かめる形
-// （protocol.ts の型と同じ。iframe の中は信用できないコードなので、形を確かめてから使う）と、
-// ビューに頼む口を差す提供部品
-export { ViewBridgeProvider } from "./_bridge.js";
+// （protocol.ts の型と同じ。iframe の中は信用できないコードなので、形を確かめてから使う）、
+// 部品が裏で使う口を差す提供部品、human ノードの実装に渡す props の組み立て（標準の承認画面も同じものを使う）
+export { useViewBridge, ViewBridgeProvider, } from "./_bridge.js";
+export { humanPropsOf } from "./_humanProps.js";
 export * from "./protocol.js";
 const tag = z.literal(VIEW_MESSAGE_TAG);
 export const viewToHostSchema = z.discriminatedUnion("type", [
@@ -14,7 +14,7 @@ export const viewToHostSchema = z.discriminatedUnion("type", [
         tag,
         type: z.literal("request"),
         id: z.number().int(),
-        method: z.string(),
+        method: z.enum(["out", "fetchFileUrl", "uploadFile", "writeText"]),
         args: z.unknown(),
     }),
 ]);