@kanf/wema-kake 0.1.2 → 0.1.3

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

@@ -55,6 +55,16 @@ export interface BoardAccess {
      * ページがなければ適用せず、`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

@@ -282,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: '付箋同士を接続線（矢印）でつなぐ。ラベルを付けられる。',

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

@@ -26,6 +26,11 @@ export declare class ServerBoardAccess implements BoardAccess {
     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 {
@@ -58,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 秒）を入れるヘッダー。期限がなければ付けない */
@@ -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;
     /**

package/dist/lib/worker/page-do.js

@@ -4,7 +4,7 @@ import { invertDeltas, } from '../shared/delta';
 import { systemSummary } from '../shared/op-summary';
 import { CLOSE_AUTH_EXPIRED, CLOSE_PAGE_DELETED, PING, PONG, } from '../shared/protocol';
 import { childPageOf, childRejection, MAX_DEPTH, placedPages, touchesChildren, } from '../shared/hierarchy';
-import { applyDeltas, childNoteColors, childPages, readBoard, readBoardWithAuthors, readBoardWithInfos, readNotes, sanitizeDeltas, UNSET_FLAGS, } from './apply-ops';
+import { applyDeltas, childNoteColors, childPages, readBoard, readBoardWithAuthors, readBoardWithInfos, readNotes, readNotesAmong, sanitizeDeltas, UNSET_FLAGS, } from './apply-ops';
 import { buildLayout, buildPageContent, contentHash, indexedChildren, removePage, touchPage, writePage, } from './indexer';
 import { applyRevert } from './revert';
 import { SanitizeError } from './sanitize';
@@ -30,6 +30,9 @@ function isExpired(attachment) {
 }
 /** ページがないときの `reason`。Worker は、これを 404 にする */
 export const REASON_PAGE_NOT_FOUND = 'page not found';
+/** 作成のデルタで作る付箋（デルタの順） */
+const createdNotes = (deltas) => deltas.flatMap((d) => (d.type === 'note:create' ? [d.note] : []));
+const createdNoteIds = (deltas) => createdNotes(deltas).map((note) => note.id);
 /** 受け取った付箋と、今ある付箋の間に空ける幅 */
 const RECEIVE_GAP = 40;
 /**
@@ -519,7 +522,7 @@ export class PageDO extends DurableObject {
             opId: crypto.randomUUID(),
             deltas: notes.map((note) => ({ type: 'note:update', noteId: note.id, before: { color: note.color }, after: { color } })),
             summary: systemSummary.childRecolored(page),
-        }, undefined, false);
+        }, { matchColors: false });
     }
     /**
      * ページを削除する前に、階層から外す。親ページにある自分の付箋を消し、子ページはルートへ戻す
@@ -740,6 +743,9 @@ export class PageDO extends DurableObject {
      * 他のページから移す（写す）付箋と、その間の接続線を受け取って置く。互いの位置関係は保ち、
      * 今ある付箋の下に置く（送る側は、このページの付箋の位置を知らない）。
      * ページがまだ作られていなければ、作らずに断る。
+     *
+     * 付箋の中身を送る側が渡す形なので、作成者は送った人になる。画面は takeNotes（Worker の
+     * transferNotes）を使う。これは、更新の前に開いた画面のタブが使う
      */
     receiveNotes(input) {
         return this.write(async () => {
@@ -755,13 +761,127 @@ export class PageDO extends DurableObject {
                 ],
                 summary: systemSummary.notesReceived(from),
                 mustExist: true,
-            }, (deltas) => placeBelow(deltas.flatMap((d) => (d.type === 'note:create' ? [d.note] : [])), this.sql
-                .exec(`SELECT min(x) AS left, max(y + height) AS bottom FROM notes`)
-                .one()));
+            }, { prepare: (deltas) => this.placeBelowNotes(deltas) });
         }, 
         // 呼び出し側（Worker）は、ページがないときと同じに扱う
         { ok: false, reason: REASON_PAGE_NOT_FOUND });
     }
+    /**
+     * 他のページ（`from`）の付箋を読んで、このページに置く。置き方は receiveNotes と同じ。
+     * 付箋の中身と作成者は、元のページの DO から読む（送る側の申告を使わない）。
+     * 元のページからは消さない（消すのは、置けた後に、Worker が removeNotes で行う）。
+     * 子ページを表す付箋は、置かずに断る（ページの親が変わることになる）
+     */
+    takeNotes(input) {
+        const pageNotFound = { ok: false, reason: REASON_PAGE_NOT_FOUND, notFound: true };
+        return this.write(async () => {
+            const { actor, clientId, opId, from, noteIds } = input;
+            if (this.version === 0)
+                return pageNotFound;
+            // 同じ操作の再送。元のページの付箋は、前の送信で消えていることがあるので、読みに行かない
+            const done = this.findOp(actor, clientId, opId);
+            if (done) {
+                const noteIds = createdNoteIds(JSON.parse(done.body));
+                return { ok: true, seq: done.seq, noteIds, versions: null };
+            }
+            if (from === this.slug())
+                return { ok: false, reason: 'cannot move notes to the same page' };
+            // 元のページの読み取りは、向こうの順番待ちに入らない。向こうの書き込みが、こちらの順番待ちを
+            // 待っていることがあるため（入ると、互いに待って止まる）。読んだ後に向こうで変わった付箋は、
+            // removeNotes が版を比べて、消さずに残す
+            const source = await this.env.PAGE.getByName(from).notesAmong(noteIds);
+            if (!source)
+                return { ok: false, reason: `page not found: ${from}`, notFound: true };
+            return this.placeTaken(input, source);
+        }, pageNotFound);
+    }
+    /**
+     * 付箋 `ids` と、その付箋どうしをつなぐ接続線。他のページが、移す付箋を読む（takeNotes）。
+     * ページがまだ作られていなければ null
+     */
+    notesAmong(ids) {
+        return this.version === 0 ? null : readNotesAmong(this.sql, ids);
+    }
+    /** takeNotes で読んだ付箋を、新しい id にして置く */
+    async placeTaken(input, source) {
+        const { from, noteIds, positions, keepAuthors, summary, ...sender } = input;
+        const byId = new Map(source.notes.map((note) => [note.id, note]));
+        /** 元のページでの id から、このページでの id（同じ付箋を 2 回写しても、重ならない） */
+        const newIds = new Map();
+        const authors = new Map();
+        const versions = {};
+        const notes = [];
+        for (const id of noteIds) {
+            const found = byId.get(id);
+            if (!found)
+                return { ok: false, reason: `note not found: ${id}`, notFound: true };
+            if (childPageOf(found) !== undefined)
+                return { ok: false, reason: `cannot move a child page note: ${id}` };
+            const { createdBy, updatedAt, ...note } = found;
+            const newId = crypto.randomUUID();
+            newIds.set(id, newId);
+            notes.push({ ...note, ...positions.get(id), id: newId });
+            if (keepAuthors)
+                authors.set(newId, createdBy);
+            versions[id] = updatedAt;
+        }
+        // 読んだ接続線は、送る付箋どうしをつなぐものだけ（残る付箋との接続線は、置かない）
+        const edges = source.edges.map((edge) => ({
+            ...edge, id: crypto.randomUUID(), from: newIds.get(edge.from), to: newIds.get(edge.to),
+        }));
+        const result = await this.applyOpsInOrder({
+            ...sender,
+            deltas: [
+                ...notes.map((note) => ({ type: 'note:create', note })),
+                ...edges.map((edge) => ({ type: 'edge:create', edge })),
+            ],
+            summary: summary ?? systemSummary.notesReceived(from),
+            mustExist: true,
+        }, { prepare: (deltas) => this.placeBelowNotes(deltas), authors });
+        if (!result.ok)
+            return { ok: false, reason: result.reason };
+        return { ok: true, seq: result.seq, noteIds: createdNoteIds(result.deltas), versions };
+    }
+    /**
+     * 他のページへ移した付箋を、このページから消す（takeNotes で置けた後に、Worker が呼ぶ）。
+     * 付箋を読むのは、順番待ちに入ってから。同じ opId で送り直しても、二重には記録しない
+     */
+    removeNotes(input) {
+        return this.write(async () => {
+            const { noteIds, versions, to, summary, ...sender } = input;
+            if (this.version === 0)
+                return { ok: false, reason: REASON_PAGE_NOT_FOUND };
+            // 同じ操作の再送。付箋は前の送信で消えている
+            const done = this.findOp(sender.actor, sender.clientId, sender.opId);
+            if (done)
+                return { ok: true, seq: done.seq, kept: [] };
+            const current = new Map(readNotesAmong(this.sql, noteIds).notes.map((note) => [note.id, note]));
+            // 読んだ後に変わった付箋と、誰かが消した付箋（同時に別のページへ移した場合を含む）は消さない
+            const kept = versions ? noteIds.filter((id) => current.get(id)?.updatedAt !== versions[id]) : [];
+            const keptSet = new Set(kept);
+            const notes = [...current.values()]
+                .filter((note) => !keptSet.has(note.id))
+                .map(({ createdBy: _, updatedAt: __, ...note }) => note);
+            // 空のデルタは記録できない
+            if (notes.length === 0)
+                return { ok: true, seq: null, kept };
+            const result = await this.applyOpsInOrder({
+                ...sender,
+                deltas: notes.map((note) => ({ type: 'note:delete', note })),
+                summary: summary ?? systemSummary.notesSent(to),
+                mustExist: true,
+            });
+            if (!result.ok)
+                return { ok: false, reason: result.reason };
+            return { ok: true, seq: result.deltas.length > 0 ? result.seq : null, kept };
+        }, { ok: false, reason: REASON_PAGE_NOT_FOUND });
+    }
+    /** 作成のデルタの付箋を、互いの位置関係を保ったまま、今ある付箋の下へずらす */
+    placeBelowNotes(deltas) {
+        placeBelow(createdNotes(deltas), this.sql
+            .exec(`SELECT min(x) AS left, max(y + height) AS bottom FROM notes`)
+            .one());
+    }
     /** 前の書き込みが終わってから `run` を始める */
     inOrder(run) {
         const result = this.applyQueue.then(run);
@@ -809,11 +929,13 @@ export class PageDO extends DurableObject {
         return { seq, deliver };
     }
     /**
-     * @param prepare 検証の済んだデルタを、適用する前に書き換える（今あるボードに合わせた位置決めなど）。
+     * @param options.prepare 検証の済んだデルタを、適用する前に書き換える（今あるボードに合わせた位置決めなど）。
      *   同じ操作の再送（適用済み）では、呼ばない
-     * @param matchColors 適用した後に、子ページの色と、その付箋の色をそろえる（matchChildColors）
+     * @param options.matchColors 適用した後に、子ページの色と、その付箋の色をそろえる（matchChildColors）。既定は true
+     * @param options.authors 作成する付箋の作成者（付箋の id から）。applyDeltas を参照
      */
-    async applyOpsInOrder(input, prepare, matchColors = true) {
+    async applyOpsInOrder(input, options = {}) {
+        const { prepare, matchColors = true, authors } = options;
         let deltas;
         let sanitized;
         try {
@@ -848,7 +970,7 @@ export class PageDO extends DurableObject {
             try {
                 const result = this.ctx.storage.transactionSync(() => {
                     const now = Date.now();
-                    const applied = applyDeltas(this.sql, deltas, input.actor, now, sanitized.cleanBefore);
+                    const applied = applyDeltas(this.sql, deltas, input.actor, now, sanitized.cleanBefore, authors);
                     const fixups = [...sanitized.fixups, ...applied.fixups];
                     if (applied.deltas.length === 0) {
                         return { ok: true, seq: this.getSeq(), deltas: [], fixups, broadcast: false };

package/dist/lib/worker/pages-api.js

@@ -7,6 +7,7 @@ import { isValidSlug } from '../shared/slug';
 import { createFirstPage } from './first-page';
 import { REASON_PAGE_NOT_FOUND } from './page-do';
 import { listPages, searchPages, searchRoots } from './page-queries';
+import { transferNotes } from './transfer';
 const REVERT_STATUS = {
     'not-found': 404,
     conflict: 409,
@@ -199,10 +200,50 @@ pagesApi.post('/pages/:slug/ops/:seq/revert', validSlug, async (c) => {
         return c.json(result);
     return c.json({ error: result.reason }, REVERT_STATUS[result.code]);
 });
+const TRANSFER_STATUS = {
+    'not-found': 404,
+    invalid: 400,
+    partial: 409,
+};
+/**
+ * このページの付箋を、他のページ（`to`）へ移す（写す）。本文は
+ * `{ clientId, opId, to, noteIds, positions?, copy? }`。付箋の中身はサーバーが読む。
+ * 移すときは、作成者を引き継ぎ、このページから消す。写すときは、作成者は写した人になり、このページに残す。
+ * `positions`（付箋の id から `{ x, y }`）は、このページでの位置の代わりに使う（ドラッグで動かした
+ * 付箋を、動かす前の位置で送る）。送り先では、今ある付箋の下に置く。同じ `opId` で送り直しても、
+ * 二重には置かない。送り先がなければ 404（作らない）
+ */
+pagesApi.post('/pages/:slug/transfer', validSlug, async (c) => {
+    const body = await c.req
+        .json()
+        .catch(() => null);
+    const to = body?.to;
+    // スラッグの形は transferNotes が確かめる
+    if (typeof to !== 'string')
+        return c.json({ error: 'invalid to' }, 400);
+    const result = await transferNotes(c.env, {
+        actor: c.get('actor'),
+        clientId: String(body?.clientId ?? ''),
+        opId: String(body?.opId ?? ''),
+        from: c.req.param('slug'),
+        to,
+        noteIds: body?.noteIds,
+        positions: body?.positions,
+        copy: body?.copy === true,
+    });
+    if (!result.ok)
+        return c.json({ error: result.reason }, TRANSFER_STATUS[result.code]);
+    // 置いた後の送り先の概要も返す（送った側が、索引への反映を待たずに、子ページの付箋を描き直せる）
+    const summary = await c.env.PAGE.getByName(to).getSummary();
+    return c.json({ ok: true, page: summary && { name: to, ...summary } });
+});
 /**
  * 他のページから移す（写す）付箋を置く。本文は `{ clientId, opId, from, notes, edges }`
  * （`from` は、付箋が元あったページ。同じ `opId` で送り直しても、二重には置かない）。
- * 今ある付箋の下に置く。ページがなければ 404（作らない）
+ * 今ある付箋の下に置く。ページがなければ 404（作らない）。
+ *
+ * 付箋の中身を送る側が渡すので、作成者は送った人になる。今の画面は `/transfer` を使う。これは、
+ * 更新の前に開いた画面のタブのために残している
  */
 pagesApi.post('/pages/:slug/notes', validSlug, async (c) => {
     const body = await c.req

package/dist/lib/worker/transfer.d.ts

@@ -0,0 +1,39 @@
+import type { WemaKakeEnv } from './config';
+export interface TransferInput {
+    /** 変更の主体。呼び出し側が認証結果から決める */
+    actor: string;
+    clientId: string;
+    /** 同じ値で送り直しても、二重には置かない（消す操作も同じ値で記録する） */
+    opId: string;
+    from: string;
+    to: string;
+    /** 外から来た値をそのまま渡す。検証はここで行う */
+    noteIds: unknown;
+    /** 付箋の id から、元のページでの位置の代わりに使う `{ x, y }`。外から来た値 */
+    positions?: unknown;
+    /** 写す（元のページに残す。作成者は `actor`）。偽なら移す（作成者を引き継ぐ） */
+    copy: boolean;
+    /** 操作の履歴に出す説明。省略すると、相手のページを表す符号 */
+    summary?: string;
+}
+/**
+ * - `not-found`: 送り先か元のページ、または付箋がない
+ * - `invalid`: 入力が不正か、置けなかった
+ * - `partial`: 送り先には置けたが、元のページから消せなかった付箋がある（消せなかった、または
+ *   読んだ後に元のページで変わったか消えたので、消さなかった）
+ */
+export type TransferFailure = 'not-found' | 'invalid' | 'partial';
+export type TransferResult = {
+    ok: true;
+    /** 送り先に置いた付箋の id（`noteIds` と同じ順） */
+    noteIds: string[];
+    /** 送り先で記録した操作の番号 */
+    received: number;
+    /** 元のページで記録した操作の番号。写したとき、消す付箋がもうなかったときは null */
+    removed: number | null;
+} | {
+    ok: false;
+    code: TransferFailure;
+    reason: string;
+};
+export declare function transferNotes(env: WemaKakeEnv, input: TransferInput): Promise<TransferResult>;