@kanf/wema-kake 0.1.1 → 0.1.3

package/README.md

@@ -62,7 +62,7 @@ npm run deploy
 - 複数のブラウザで同じページを開くと、変更がその場で反映される
 - ページの中に子ページを置ける。子ページは、中の付箋の配置を縮小した図つきの付箋として表示され、押すとズームして入る
 - ページの一覧もボードで、ページが付箋、ページ間のリンクが線になる。全文検索で絞り込める
-- リモート MCP サーバーを備えていて、claude.ai のコネクタとして登録できる。LLM がボードを読み、付箋を足し、整理する
+- リモート MCP サーバーを備えていて、claude.ai のコネクタとして登録できる。LLM がボードを読み、付箋を足し、整理する。ページを作り、子ページとしてまとめることもできる
 - LLM の操作は、操作の単位で記録される。ページの画面から、まとめて取り消せる
 
 ## wema との関係

package/dist/lib/shared/hierarchy.d.ts

@@ -1,6 +1,11 @@
 import type { HistoryDelta, WemaNote } from './delta';
 /** 子ページの付箋の meta のキー。値は、子ページのスラッグ */
 export declare const CHILD_PAGE_KEY = "page";
+/** 子ページの付箋の大きさ。配置の再現が入るよう、ふつうの付箋より少し大きくする */
+export declare const CHILD_NOTE_SIZE: {
+    width: number;
+    height: number;
+};
 /** 階層の深さの上限。ルートを 1 段目と数える */
 export declare const MAX_DEPTH = 5;
 /**

package/dist/lib/shared/hierarchy.js

@@ -1,5 +1,7 @@
 /** 子ページの付箋の meta のキー。値は、子ページのスラッグ */
 export const CHILD_PAGE_KEY = 'page';
+/** 子ページの付箋の大きさ。配置の再現が入るよう、ふつうの付箋より少し大きくする */
+export const CHILD_NOTE_SIZE = { width: 240, height: 180 };
 /** 階層の深さの上限。ルートを 1 段目と数える */
 export const MAX_DEPTH = 5;
 /** 置けなかったときの `reject` の `reason` の先頭。続けて、理由と、置こうとしたページが入る */

package/dist/lib/shared/op-summary.d.ts

@@ -8,6 +8,8 @@ export declare const systemSummary: {
     revert: (seq: number) => string;
     /** ページ `page` から移した（写した）付箋を置いた */
     notesReceived: (page: string) => string;
+    /** 付箋を、ページ `page` へ移したので、このページから消した */
+    notesSent: (page: string) => string;
     /** 子ページ `page` の色に、その付箋の色を合わせた */
     childRecolored: (page: string) => string;
 };
@@ -22,6 +24,9 @@ export type SystemSummary = {
 } | {
     kind: 'notesReceived';
     page: string;
+} | {
+    kind: 'notesSent';
+    page: string;
 } | {
     kind: 'childRecolored';
     page: string;

package/dist/lib/shared/op-summary.js

@@ -14,6 +14,8 @@ export const systemSummary = {
     revert: (seq) => `${PREFIX}revert:${seq}`,
     /** ページ `page` から移した（写した）付箋を置いた */
     notesReceived: (page) => `${PREFIX}notes-received:${page}`,
+    /** 付箋を、ページ `page` へ移したので、このページから消した */
+    notesSent: (page) => `${PREFIX}notes-sent:${page}`,
     /** 子ページ `page` の色に、その付箋の色を合わせた */
     childRecolored: (page) => `${PREFIX}child-recolored:${page}`,
 };
@@ -31,6 +33,8 @@ export function parseSystemSummary(summary) {
         return { kind: 'revert', seq: Number(value) };
     if (kind === 'notes-received' && value !== '')
         return { kind: 'notesReceived', page: value };
+    if (kind === 'notes-sent' && value !== '')
+        return { kind: 'notesSent', page: value };
     if (kind === 'child-recolored' && value !== '')
         return { kind: 'childRecolored', page: value };
     return null;

package/dist/lib/shared/tools.d.ts

@@ -42,13 +42,29 @@ export interface BoardAccess {
     }[]>;
     /** ページがまだ作られていなければ null */
     readBoard(page: string): Promise<BoardState | null>;
+    /** 親ページのスラッグ（ルートなら null）。ページがなければ undefined。索引ではなく、ページの今の値を返す */
+    parentOf(page: string): Promise<string | null | undefined>;
+    /** ページの親が `parent` なら、ルートへ戻す（親の記録が古く、親ページに子ページの付箋がないときに使う） */
+    clearParent(page: string, parent: string): Promise<void>;
+    /** ページを、付箋のない状態で作る。すでにあれば作らずに `exists` を返す */
+    createPage(page: string, title: string): Promise<'created' | 'exists' | 'invalid title'>;
     /** 付箋の text（HTML）をプレーンテキストにする */
     plainText(html: string): Promise<string>;
     /**
      * デルタを 1 つの操作として適用する。`summary` は履歴に出る説明。
-     * ページがなければ適用せず、`ok: false` を返すこと（ツールはページを作らない）
+     * ページがなければ適用せず、`ok: false` を返すこと（ページを作るのは create_page だけ）
      */
     apply(page: string, deltas: HistoryDelta[], summary: string): Promise<ApplyOutcome>;
+    /**
+     * ページ `from` の付箋を、ページ `to` へ移す（作成者は引き継ぐ）。付箋の中身は、実装の側が
+     * 元のページから読む。移せなければ ToolError を投げる。`noteIds` は移した後の付箋の id
+     * （`ids` と同じ順）、`received` と `removed` は、それぞれのページで記録した操作の番号
+     */
+    moveNotes(from: string, to: string, ids: string[], summary: string): Promise<{
+        noteIds: string[];
+        received: number;
+        removed: number | null;
+    }>;
     /** 自分（この agent）の最近の操作 */
     ownOps(page: string): Promise<OpSummary[]>;
     /** 自分の操作を取り消す */

package/dist/lib/shared/tools.js

@@ -5,8 +5,8 @@
 // 渡せば、同じツールがそのまま使える。
 import { computeAutoLayout } from '@kanf/wema';
 import { z } from 'zod';
-import { MAX_LIST_LIMIT, MAX_QUERY_LENGTH } from './api';
-import { childPageOf } from './hierarchy';
+import { MAX_LIST_LIMIT, MAX_QUERY_LENGTH, MAX_TITLE_LENGTH } from './api';
+import { CHILD_NOTE_SIZE, CHILD_PAGE_KEY, childPageOf, MAX_DEPTH } from './hierarchy';
 import { textToHtml } from './note-text';
 import { SLUG_RE } from './slug';
 /** ツールが入力や状態の問題で実行できなかった。メッセージは LLM に返す */
@@ -60,7 +60,7 @@ function placeNote(size, near, taken) {
 }
 async function existingBoard(access, slug) {
     const board = await access.readBoard(slug);
-    // ページの作成はツールでは行わない（人が画面から作る）
+    // 書き込みのツールは、ページを作らない（作るのは create_page だけ）
     if (!board)
         throw new ToolError(`page not found: ${slug}`);
     return { ...board, notesById: new Map(board.notes.map((n) => [n.id, n])) };
@@ -87,6 +87,33 @@ function assertUnique(ids) {
     }
 }
 const summaryOf = (tool, why) => (why ? `${tool}: ${why}` : tool);
+const messageOf = (e) => (e instanceof Error ? e.message : String(e));
+/** `page` が `ancestor` の子孫（`ancestor` 自身を含む）か。親をたどる（階層の深さの上限までで止まる） */
+async function isDescendant(access, page, ancestor) {
+    let name = page;
+    for (let depth = 0; name && depth <= MAX_DEPTH; depth++) {
+        if (name === ancestor)
+            return true;
+        name = await access.parentOf(name);
+    }
+    return false;
+}
+/**
+ * `parent` のボードに、`child` の子ページの付箋を置く（既存の付箋の下に、重ならないように）。
+ * 置けるかどうか（親は 1 つだけ、輪にならない、深さ）は、ページの DO が確かめる。記録した操作の番号を返す
+ */
+async function placeChild(access, parent, parentSlug, child, summary) {
+    const rect = placeNote(CHILD_NOTE_SIZE, undefined, parent.notes);
+    const note = {
+        id: crypto.randomUUID(),
+        ...rect,
+        text: '',
+        color: NOTE_COLOR,
+        zIndex: 1,
+        meta: { [CHILD_PAGE_KEY]: child },
+    };
+    return applyOrThrow(access, parentSlug, [{ type: 'note:create', note }], summary);
+}
 function findNote(board, id) {
     const note = board.notesById.get(id);
     if (!note)
@@ -255,6 +282,27 @@ export const TOOLS = [
             return { operation: seq };
         },
     }),
+    tool({
+        name: 'move_notes',
+        description: '付箋を、別のページ（すでにあるページ）へ移す。付箋の作成者は変わらない（delete_notes と add_notes で移すと、作成者が自分に変わるので、移すときはこれを使う）。移す付箋どうしをつなぐ接続線も一緒に移り、残る付箋とつながっていた接続線は消える。移す先では、付箋どうしの位置関係を保ったまま、今ある付箋の下に置く。子ページを表す付箋は移せない（ページごと移すときは move_page を使う）。note_ids は移した後の付箋の id で、指定した順に並ぶ。operations は、変更したページと操作の番号の組で、それぞれのページで revert_operation に渡せる。',
+        readOnly: false,
+        input: z.object({
+            page: page.describe('付箋が今あるページのスラッグ'),
+            note_ids: z.array(z.string()).min(1).max(MAX_ITEMS),
+            to: page.describe('移す先のページのスラッグ'),
+            reason,
+        }),
+        async run(access, input) {
+            if (input.to === input.page)
+                throw new ToolError('the notes are already in this page');
+            assertUnique(input.note_ids);
+            const moved = await access.moveNotes(input.page, input.to, input.note_ids, summaryOf('move_notes', input.reason));
+            const operations = [{ page: input.to, operation: moved.received }];
+            if (moved.removed !== null)
+                operations.push({ page: input.page, operation: moved.removed });
+            return { note_ids: moved.noteIds, operations };
+        },
+    }),
     tool({
         name: 'connect_notes',
         description: '付箋同士を接続線（矢印）でつなぐ。ラベルを付けられる。',
@@ -321,6 +369,109 @@ export const TOOLS = [
             return { operation: seq, moved: deltas.length };
         },
     }),
+    tool({
+        name: 'create_page',
+        description: 'ページを新しく作る。付箋のない空のページができる。parent を指定すると、そのページの中に子ページとして置く（parent のボードに、子ページを表す付箋が足される）。すでにある名前では作れない（既存のページを別のページの中へ移すときは move_page を使う）。ページの作成そのものは、revert_operation では取り消せない。子ページとして置いた操作は、parent のページで取り消せる（取り消すと、作ったページはルートのページとして残る）。',
+        readOnly: false,
+        input: z.object({
+            name: z
+                .string()
+                .regex(SLUG_RE)
+                .describe('新しいページのスラッグ（URL に使う名前。英小文字、数字、ハイフン。後から変えられない）'),
+            title: z.string().max(MAX_TITLE_LENGTH).optional().describe('ページの表示名。省略すると、スラッグが表示される'),
+            parent: page.optional().describe('子ページとして置く先のページのスラッグ。省略すると、ルートのページになる'),
+            reason,
+        }),
+        async run(access, input) {
+            const { name, parent } = input;
+            if (parent === name)
+                throw new ToolError(`a page cannot be placed in itself: ${name}`);
+            // 置く先が無ければ、ページを作る前に断る
+            const parentBoard = parent === undefined ? undefined : await existingBoard(access, parent);
+            const created = await access.createPage(name, input.title ?? '');
+            if (created === 'exists') {
+                throw new ToolError(`page already exists: ${name} (use move_page to place an existing page)`);
+            }
+            if (created === 'invalid title')
+                throw new ToolError('invalid title (control characters are not allowed)');
+            if (parent === undefined || parentBoard === undefined)
+                return { page: name, parent: null };
+            try {
+                const seq = await placeChild(access, parentBoard, parent, name, summaryOf('create_page', input.reason));
+                return { page: name, parent, operation: seq };
+            }
+            catch (e) {
+                // ページはできているので、どんな失敗でも、そのことを伝える（作り直そうとすると exists で断られる）
+                throw new ToolError(`created ${name} as a root page, but could not place it in ${parent}: ${messageOf(e)}`);
+            }
+        },
+    }),
+    tool({
+        name: 'move_page',
+        description: '既存のページを、別のページの中へ子ページとして移す（今の親ページにある子ページの付箋を消し、移す先に置く）。parent に null を指定すると、親から外してルートのページにする。子ページを持つページは、子孫ごと移る。今の親ページで子ページの付箋につながっていた接続線は消える。移す先に置けなかった場合（輪になる、階層が深すぎるなど）は、元の親ページに戻してエラーを返す。operations は、変更したページと操作の番号の組で、それぞれのページで revert_operation に渡せる。',
+        readOnly: false,
+        input: z.object({
+            name: page.describe('移すページのスラッグ'),
+            parent: page
+                .nullable()
+                .describe('移す先の親ページのスラッグ。null なら、親から外してルートのページにする'),
+            reason,
+        }),
+        async run(access, input) {
+            const { name, parent: target } = input;
+            const current = await access.parentOf(name);
+            if (current === undefined)
+                throw new ToolError(`page not found: ${name}`);
+            if (target === name)
+                throw new ToolError(`a page cannot be placed in itself: ${name}`);
+            if (current === target) {
+                throw new ToolError(target === null ? `already a root page: ${name}` : `already in ${target}: ${name}`);
+            }
+            const summary = summaryOf('move_page', input.reason);
+            // 移す先が無いか、移す先が自分の子孫（輪になる）なら、今の親から外す前に断る。
+            // 深さの上限は、置くときに DO が確かめる（断られたら、下で元に戻す）
+            const targetBoard = target === null ? undefined : await existingBoard(access, target);
+            if (target !== null && (await isDescendant(access, target, name))) {
+                throw new ToolError(`could not place ${name} in ${target}: ${target} is inside ${name}`);
+            }
+            const operations = [];
+            let removed;
+            if (current !== null) {
+                const board = await access.readBoard(current);
+                const notes = board?.notes.filter((n) => childPageOf(n) === name) ?? [];
+                if (notes.length > 0) {
+                    removed = await applyOrThrow(access, current, notes.map((note) => ({ type: 'note:delete', note })), summary);
+                    operations.push({ page: current, operation: removed });
+                }
+                else {
+                    // 親の記録が古い（親ページに付箋がない、親ページがもうない）。記録だけを消す
+                    await access.clearParent(name, current);
+                }
+            }
+            if (target === null || targetBoard === undefined)
+                return { page: name, from: current, to: null, operations };
+            try {
+                const placed = await placeChild(access, targetBoard, target, name, summary);
+                operations.push({ page: target, operation: placed });
+                return { page: name, from: current, to: target, operations };
+            }
+            catch (e) {
+                const why = `could not place ${name} in ${target}: ${messageOf(e)}`;
+                if (current === null || removed === undefined)
+                    throw new ToolError(why);
+                // 置けなかったので、外した操作を取り消して、元の親ページに戻す
+                await access
+                    .revert(current, removed, summaryOf('move_page', `restore ${name} after a failed move`))
+                    .catch(() => undefined);
+                // 戻せたかは、取り消しの結果ではなく、今の親で判断する（間に人が別のページへ置いたこともある）
+                const now = await access.parentOf(name).catch(() => undefined);
+                if (now === current)
+                    throw new ToolError(`${why} (left it in ${current})`);
+                const where = now === null ? 'is now a root page' : now === undefined ? 'could not be checked' : `is now in ${now}`;
+                throw new ToolError(`${why}. It was removed from ${current} and ${where}; operation ${removed} on ${current} is the removal`);
+            }
+        },
+    }),
     tool({
         name: 'revert_operation',
         description: '自分が行った操作を取り消す。operation を省略すると、まだ取り消していない直前の操作が対象になる。その後に人が変更した付箋は戻さず、skipped で返す。何も戻せなかった場合（applied が 0）は、それより前の自分の操作の番号を earlier_operations で返すので、必要なら operation に指定して呼び直す。',

package/dist/lib/worker/apply-ops.d.ts

@@ -41,6 +41,16 @@ export declare function readBoardWithInfos(sql: SqlStorage): {
 };
 /** 付箋（作成者つき）と接続線。agent に渡す */
 export declare function readBoardWithAuthors(sql: SqlStorage): Pick<BoardState, 'notes' | 'edges'>;
+/** 他のページへ移すために読んだ付箋。作成者と、最後に変更した時刻が付く */
+export type TakenNote = WemaNote & {
+    createdBy: string | null;
+    updatedAt: number;
+};
+/** 付箋 `ids` と、その付箋どうしをつなぐ接続線。他のページへ移す付箋を読む */
+export declare function readNotesAmong(sql: SqlStorage, ids: string[]): {
+    notes: TakenNote[];
+    edges: WemaEdge[];
+};
 export declare const readBoard: (sql: SqlStorage) => BoardData;
 export interface Sanitized {
     /** サニタイズで text が変わった付箋について、送信元の手元の状態を直すためのデルタ */
@@ -71,5 +81,7 @@ export interface Applied {
  *   変える前に保存した text を編集できるようにするため。後者は、送信元がサニタイズ前の
  *   text を手元に持ったまま続けて編集した場合のため
  * - 更新で `after` にキーがなく `before` にあるものは、未設定に戻す
+ * - 作成した付箋の作成者は `actor`。`authors` に付箋の id があれば、その値にする（他のページから
+ *   移した付箋の作成者を引き継ぐ）。`authors` はサーバーが読んだ値だけを渡すこと
  */
-export declare function applyDeltas(sql: SqlStorage, deltas: HistoryDelta[], actor: string, now: number, cleanBefore?: Map<HistoryDelta, string>): Applied;
+export declare function applyDeltas(sql: SqlStorage, deltas: HistoryDelta[], actor: string, now: number, cleanBefore?: Map<HistoryDelta, string>, authors?: ReadonlyMap<string, string | null>): Applied;

package/dist/lib/worker/apply-ops.js

@@ -163,6 +163,25 @@ export function readBoardWithAuthors(sql) {
         edges: readEdges(sql),
     };
 }
+/** 付箋 `ids` と、その付箋どうしをつなぐ接続線。他のページへ移す付箋を読む */
+export function readNotesAmong(sql, ids) {
+    const json = JSON.stringify(ids);
+    const among = `(SELECT value FROM json_each(?))`;
+    return {
+        notes: sql
+            .exec(`SELECT * FROM notes WHERE id IN ${among} ORDER BY rowid`, json)
+            .toArray()
+            .map((row) => ({
+            ...rowToNote(row),
+            createdBy: row.created_by,
+            updatedAt: row.updated_at,
+        })),
+        edges: sql
+            .exec(`SELECT * FROM edges WHERE from_id IN ${among} AND to_id IN ${among} ORDER BY rowid`, json, json)
+            .toArray()
+            .map(rowToEdge),
+    };
+}
 export const readBoard = (sql) => readBoardWithInfos(sql).data;
 /**
  * デルタ中の text をサニタイズする（`note.text` と `after.text` を書き換える）。
@@ -205,8 +224,10 @@ export async function sanitizeDeltas(deltas, options = { cleanBefore: true }) {
  *   変える前に保存した text を編集できるようにするため。後者は、送信元がサニタイズ前の
  *   text を手元に持ったまま続けて編集した場合のため
  * - 更新で `after` にキーがなく `before` にあるものは、未設定に戻す
+ * - 作成した付箋の作成者は `actor`。`authors` に付箋の id があれば、その値にする（他のページから
+ *   移した付箋の作成者を引き継ぐ）。`authors` はサーバーが読んだ値だけを渡すこと
  */
-export function applyDeltas(sql, deltas, actor, now, cleanBefore) {
+export function applyDeltas(sql, deltas, actor, now, cleanBefore, authors) {
     const applied = [];
     const fixups = [];
     for (const d of deltas) {
@@ -218,7 +239,7 @@ export function applyDeltas(sql, deltas, actor, now, cleanBefore) {
                 assertNotPlaced(sql, n, n.id);
                 sql.exec(`INSERT INTO notes (id, x, y, width, height, text, color, z_index, auto_size, foldable, extra,
                               created_by, updated_at, updated_by)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, n.id, n.x, n.y, n.width, n.height, n.text, n.color, n.zIndex, n.autoSize ? 1 : 0, n.foldable ? 1 : 0, metaJson(n.meta), actor, now, actor);
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, n.id, n.x, n.y, n.width, n.height, n.text, n.color, n.zIndex, n.autoSize ? 1 : 0, n.foldable ? 1 : 0, metaJson(n.meta), authors?.has(n.id) ? authors.get(n.id) : actor, now, actor);
                 applied.push(d);
                 break;
             }

package/dist/lib/worker/mcp/board-access.d.ts

@@ -21,8 +21,16 @@ export declare class ServerBoardAccess implements BoardAccess {
         snippet: string | undefined;
     }[]>;
     readBoard(slug: string): Promise<BoardState | null>;
+    parentOf(slug: string): Promise<string | null | undefined>;
+    clearParent(slug: string, parent: string): Promise<void>;
+    createPage(slug: string, title: string): Promise<'created' | 'exists' | 'invalid title'>;
     plainText(html: string): Promise<string>;
     apply(slug: string, deltas: HistoryDelta[], summary: string): Promise<ApplyOutcome>;
+    moveNotes(from: string, to: string, ids: string[], summary: string): Promise<{
+        noteIds: string[];
+        received: number;
+        removed: number | null;
+    }>;
     ownOps(slug: string): Promise<OpSummary[]>;
     revert(slug: string, seq: number, summary: string): Promise<RevertOutcome>;
 }

package/dist/lib/worker/mcp/board-access.js

@@ -1,6 +1,7 @@
 import { ToolError } from '../../shared/tools';
 import { listPages, searchPages } from '../page-queries';
 import { extractContent } from '../plain-text';
+import { transferNotes } from '../transfer';
 /** ops に記録する clientId。MCP にはブラウザのような接続ごとの id がない */
 const MCP_CLIENT_ID = 'mcp';
 export class ServerBoardAccess {
@@ -28,6 +29,17 @@ export class ServerBoardAccess {
     async readBoard(slug) {
         return this.page(slug).getBoardState();
     }
+    async parentOf(slug) {
+        const ref = await this.page(slug).getPageRef();
+        return ref === null ? undefined : ref.parent;
+    }
+    async clearParent(slug, parent) {
+        await this.page(slug).clearParent(parent);
+    }
+    async createPage(slug, title) {
+        const result = await this.page(slug).createPage(title);
+        return result.ok ? 'created' : result.reason;
+    }
     async plainText(html) {
         // ページへのリンクは、書くときと同じ書式（[[slug]]）で残す
         return (await extractContent(html, { siteOrigin: this.env.SITE_ORIGIN })).text;
@@ -47,6 +59,22 @@ export class ServerBoardAccess {
         // すべてのデルタが捨てられた場合、seq は進んでいない（直前の別の操作の番号が入っている）
         return { ok: true, seq: result.deltas.length > 0 ? result.seq : null };
     }
+    async moveNotes(from, to, ids, summary) {
+        const result = await transferNotes(this.env, {
+            actor: this.actor,
+            clientId: MCP_CLIENT_ID,
+            opId: crypto.randomUUID(),
+            from,
+            to,
+            noteIds: ids,
+            copy: false,
+            summary,
+        });
+        if (!result.ok)
+            throw new ToolError(result.reason);
+        const { ok: _, ...moved } = result;
+        return moved;
+    }
     async ownOps(slug) {
         return this.page(slug).listOps({ actor: this.actor });
     }

package/dist/lib/worker/page-do.d.ts

@@ -1,9 +1,10 @@
 import { DurableObject } from 'cloudflare:workers';
 import type { WemaKakeEnv } from './config';
 import { type OpSummary, type PageSummary, type RevertOutcome } from '../shared/api';
-import { type BoardContent, type HistoryDelta, type Snapshot } from '../shared/delta';
+import { type BoardContent, type HistoryDelta, type Snapshot, type WemaEdge } from '../shared/delta';
 import type { BoardState } from '../shared/tools';
 import { type ChildRejectCode } from '../shared/hierarchy';
+import { type TakenNote } from './apply-ops';
 /** Worker が WebSocket の接続要求を DO へ転送するときに、認証済みの主体を入れるヘッダー */
 export declare const ACTOR_HEADER = "X-Wema-Actor";
 /** 同じく、認証の期限（UNIX 秒）を入れるヘッダー。期限がなければ付けない */
@@ -16,7 +17,7 @@ export interface ApplyInput {
     /** 外から来た値をそのまま渡す。検証は applyOps が行う */
     deltas: unknown;
     summary?: string;
-    /** ページがまだ作られていなければ、適用せずに断る（MCP のツールはページを作らない） */
+    /** ページがまだ作られていなければ、適用せずに断る（MCP の書き込みのツールは、ページを作らない。作るのは create_page だけ） */
     mustExist?: boolean;
 }
 /** ページがないときの `reason`。Worker は、これを 404 にする */
@@ -28,6 +29,59 @@ export interface ReceiveInput extends Pick<ApplyInput, 'actor' | 'clientId' | 'o
     /** 付箋が元あったページ（操作の履歴の要約に出す） */
     from: string;
 }
+export interface TakeInput extends Pick<ApplyInput, 'actor' | 'clientId' | 'opId'> {
+    /** 付箋が今あるページ */
+    from: string;
+    /** 移す（写す）付箋の、元のページでの id。呼び出し側（Worker）が検証する */
+    noteIds: string[];
+    /** 付箋の id から、元のページでの位置の代わりに使う位置。呼び出し側（Worker）が検証する */
+    positions: Map<string, {
+        x: number;
+        y: number;
+    }>;
+    /** 付箋の作成者を引き継ぐ（移すとき）。引き継がなければ、作成者は `actor`（写すとき） */
+    keepAuthors: boolean;
+    /** 操作の履歴に出す説明。省略すると、元のページを表す符号 */
+    summary?: string;
+}
+/** 付箋の id から、最後に変更した時刻（notes.updated_at） */
+export type NoteVersions = Record<string, number>;
+/**
+ * `noteIds` は、置いた付箋の id。`TakeInput.noteIds` と同じ順に並ぶ。`versions` は、読んだときの
+ * 元の付箋の版。同じ操作の再送では、読み直さないので null。`notFound` は、このページ、元のページ、
+ * 付箋のどれかがなかった
+ */
+export type TakeResult = {
+    ok: true;
+    seq: number;
+    noteIds: string[];
+    versions: NoteVersions | null;
+} | {
+    ok: false;
+    reason: string;
+    notFound?: true;
+};
+export interface RemoveInput extends Pick<ApplyInput, 'actor' | 'clientId' | 'opId'> {
+    noteIds: string[];
+    /**
+     * takeNotes が読んだときの版。これと違う付箋（読んだ後に変わった、消えた）は消さずに、`kept` で返す
+     * （送り先には、変わる前の付箋が置かれている）。null なら、今ある付箋をそのまま消す
+     */
+    versions: NoteVersions | null;
+    /** 付箋を移した先のページ（操作の履歴の要約に出す） */
+    to: string;
+    /** 操作の履歴に出す説明。省略すると、移した先のページを表す符号 */
+    summary?: string;
+}
+/** `seq` は記録した操作の番号。消した付箋がなければ null。`kept` は、版が違って消さなかった付箋 */
+export type RemoveResult = {
+    ok: true;
+    seq: number | null;
+    kept: string[];
+} | {
+    ok: false;
+    reason: string;
+};
 export type ApplyResult = {
     ok: true;
     seq: number;
@@ -281,8 +335,35 @@ export declare class PageDO extends DurableObject<WemaKakeEnv> {
      * 他のページから移す（写す）付箋と、その間の接続線を受け取って置く。互いの位置関係は保ち、
      * 今ある付箋の下に置く（送る側は、このページの付箋の位置を知らない）。
      * ページがまだ作られていなければ、作らずに断る。
+     *
+     * 付箋の中身を送る側が渡す形なので、作成者は送った人になる。画面は takeNotes（Worker の
+     * transferNotes）を使う。これは、更新の前に開いた画面のタブが使う
      */
     receiveNotes(input: ReceiveInput): Promise<ApplyResult>;
+    /**
+     * 他のページ（`from`）の付箋を読んで、このページに置く。置き方は receiveNotes と同じ。
+     * 付箋の中身と作成者は、元のページの DO から読む（送る側の申告を使わない）。
+     * 元のページからは消さない（消すのは、置けた後に、Worker が removeNotes で行う）。
+     * 子ページを表す付箋は、置かずに断る（ページの親が変わることになる）
+     */
+    takeNotes(input: TakeInput): Promise<TakeResult>;
+    /**
+     * 付箋 `ids` と、その付箋どうしをつなぐ接続線。他のページが、移す付箋を読む（takeNotes）。
+     * ページがまだ作られていなければ null
+     */
+    notesAmong(ids: string[]): {
+        notes: TakenNote[];
+        edges: WemaEdge[];
+    } | null;
+    /** takeNotes で読んだ付箋を、新しい id にして置く */
+    private placeTaken;
+    /**
+     * 他のページへ移した付箋を、このページから消す（takeNotes で置けた後に、Worker が呼ぶ）。
+     * 付箋を読むのは、順番待ちに入ってから。同じ opId で送り直しても、二重には記録しない
+     */
+    removeNotes(input: RemoveInput): Promise<RemoveResult>;
+    /** 作成のデルタの付箋を、互いの位置関係を保ったまま、今ある付箋の下へずらす */
+    private placeBelowNotes;
     /** 前の書き込みが終わってから `run` を始める */
     private inOrder;
     /** 同じ送信元の同じ操作が記録済みなら、その行を返す */
@@ -293,9 +374,10 @@ export declare class PageDO extends DurableObject<WemaKakeEnv> {
      */
     private recordOp;
     /**
-     * @param prepare 検証の済んだデルタを、適用する前に書き換える（今あるボードに合わせた位置決めなど）。
+     * @param options.prepare 検証の済んだデルタを、適用する前に書き換える（今あるボードに合わせた位置決めなど）。
      *   同じ操作の再送（適用済み）では、呼ばない
-     * @param matchColors 適用した後に、子ページの色と、その付箋の色をそろえる（matchChildColors）
+     * @param options.matchColors 適用した後に、子ページの色と、その付箋の色をそろえる（matchChildColors）。既定は true
+     * @param options.authors 作成する付箋の作成者（付箋の id から）。applyDeltas を参照
      */
     private applyOpsInOrder;
     /**