@kanf/wema-kake 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,28 @@
+import { type RootHit } from '../shared/api';
+import type { PageInfo } from '../shared/tools';
+/**
+ * ページ一覧（更新の新しい順）。`updatedAfter`（ミリ秒）より後に更新されたものに絞れる。
+ * `name` を渡すと、表示名かスラッグにその文字を含むページに絞る（本文は見ない。ページへ移るための
+ * 絞り込み用）。長すぎる分は、先頭だけを使う
+ */
+export declare function listPages(db: D1Database, options: {
+    updatedAfter?: unknown;
+    limit?: unknown;
+    name?: unknown;
+}): Promise<PageInfo[]>;
+export interface SearchHit {
+    name: string;
+    title: string | null;
+    updated_at: number;
+    /** 親ページのスラッグ。ルートのページなら null */
+    parent: string | null;
+    snippet?: string;
+}
+/** 全文検索（表示名と本文）。検索語が空か長すぎるときは null を返す */
+export declare function searchPages(db: D1Database, query: string): Promise<SearchHit[] | null>;
+/**
+ * 一覧の絞り込み用の検索。一致したページ（表示名、本文、スラッグ）と、そのルートを返す。
+ * 一覧にはルートのページしか出ないので、子孫のページが一致したときは、ルートを残して知らせる。
+ * 入力のたびに呼ばれるので、抜粋の生成と関連度での並び替えはしない。
+ */
+export declare function searchRoots(db: D1Database, query: string): Promise<RootHit[] | null>;

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

@@ -0,0 +1,88 @@
+// D1 の索引に対する、ページの一覧と検索のクエリ。HTTP の API と MCP のツールの両方が使う。
+import { MAX_LIST_LIMIT, MAX_QUERY_LENGTH } from '../shared/api';
+import { MAX_DEPTH } from '../shared/hierarchy';
+import { clampLimit } from './validate';
+const DEFAULT_LIST_LIMIT = 100;
+/** 一覧の絞り込みに使うので、一覧の上限とそろえる */
+const SEARCH_LIMIT = MAX_LIST_LIMIT;
+/** trigram の FTS が一致を返せる最短の検索語（文字数） */
+const MIN_FTS_QUERY_LENGTH = 3;
+/**
+ * ページ一覧（更新の新しい順）。`updatedAfter`（ミリ秒）より後に更新されたものに絞れる。
+ * `name` を渡すと、表示名かスラッグにその文字を含むページに絞る（本文は見ない。ページへ移るための
+ * 絞り込み用）。長すぎる分は、先頭だけを使う
+ */
+export async function listPages(db, options) {
+    const name = typeof options.name === 'string' ? options.name.trim().slice(0, MAX_QUERY_LENGTH) : '';
+    // LIKE は使わない（D1 は、LIKE のパターンを 50 バイトまでに限っていて、日本語の 16 文字で超える）。
+    // lower() は、LIKE と同じく、英字だけを小文字にする
+    const { results } = await db
+        .prepare(`SELECT name, title, note_count, updated_at, parent FROM pages
+       WHERE updated_at > ?1
+         AND (?3 = '' OR instr(lower(name), lower(?3)) > 0 OR instr(lower(title), lower(?3)) > 0)
+       ORDER BY updated_at DESC LIMIT ?2`)
+        .bind(Number(options.updatedAfter) || 0, clampLimit(options.limit, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT), name)
+        .all();
+    return results;
+}
+/** 検索語を整える。空か長すぎるときは null */
+function normalizeQuery(query) {
+    const q = query.trim();
+    return q === '' || q.length > MAX_QUERY_LENGTH ? null : q;
+}
+/** 3 文字未満の検索語は trigram に一致しないので、LIKE で探す */
+const usesFts = (q) => [...q].length >= MIN_FTS_QUERY_LENGTH;
+/** 検索語全体を 1 つの語句として扱う（FTS5 の演算子として解釈させない） */
+const ftsPhrase = (q) => `"${q.replaceAll('"', '""')}"`;
+const likePattern = (q) => `%${q.replace(/[\\%_]/g, '\\$&')}%`;
+/** 全文検索（表示名と本文）。検索語が空か長すぎるときは null を返す */
+export async function searchPages(db, query) {
+    const q = normalizeQuery(query);
+    if (q === null)
+        return null;
+    if (usesFts(q)) {
+        const { results } = await db
+            .prepare(`SELECT p.name, p.title, p.updated_at, p.parent, snippet(pages_fts, 1, '', '', '…', 24) AS snippet
+         FROM pages_fts JOIN pages p ON p.id = pages_fts.rowid
+         WHERE pages_fts MATCH ? ORDER BY rank LIMIT ?`)
+            .bind(ftsPhrase(q), SEARCH_LIMIT)
+            .all();
+        return results;
+    }
+    const { results } = await db
+        .prepare(`SELECT name, title, updated_at, parent FROM pages
+       WHERE title LIKE ?1 ESCAPE '\\' OR plain_text LIKE ?1 ESCAPE '\\'
+       ORDER BY updated_at DESC LIMIT ?2`)
+        .bind(likePattern(q), SEARCH_LIMIT)
+        .all();
+    return results;
+}
+/**
+ * 一覧の絞り込み用の検索。一致したページ（表示名、本文、スラッグ）と、そのルートを返す。
+ * 一覧にはルートのページしか出ないので、子孫のページが一致したときは、ルートを残して知らせる。
+ * 入力のたびに呼ばれるので、抜粋の生成と関連度での並び替えはしない。
+ */
+export async function searchRoots(db, query) {
+    const q = normalizeQuery(query);
+    if (q === null)
+        return null;
+    const pattern = likePattern(q);
+    const matched = usesFts(q)
+        ? `SELECT p.name FROM pages_fts JOIN pages p ON p.id = pages_fts.rowid WHERE pages_fts MATCH ?1
+       UNION SELECT name FROM pages WHERE name LIKE ?2 ESCAPE '\\'`
+        : `SELECT name FROM pages
+       WHERE title LIKE ?2 ESCAPE '\\' OR plain_text LIKE ?2 ESCAPE '\\' OR name LIKE ?2 ESCAPE '\\'`;
+    const { results } = await db
+        .prepare(`WITH RECURSIVE matched(name) AS (${matched} LIMIT ?3),
+         up(name, cur, parent, depth) AS (
+           SELECT m.name, p.name, p.parent, 1 FROM matched m JOIN pages p ON p.name = m.name
+           UNION ALL
+           SELECT up.name, p.name, p.parent, up.depth + 1
+           FROM up JOIN pages p ON p.name = up.parent WHERE up.depth <= ?4
+         )
+       SELECT name, cur AS root FROM up WHERE parent IS NULL`)
+        // LIKE だけの検索では ?1 を使わないが、番号をそろえるために渡す
+        .bind(usesFts(q) ? ftsPhrase(q) : '', pattern, SEARCH_LIMIT, MAX_DEPTH)
+        .all();
+    return results;
+}

package/dist/lib/worker/pages-api.d.ts

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import type { AuthEnv } from './access';
+/** パスの `:slug` が不正なら 400 を返す */
+export declare const validSlug: import("hono").MiddlewareHandler<AuthEnv, string, {}, Response>;
+export declare const pagesApi: Hono<AuthEnv, import("hono/types").BlankSchema, "/">;

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

@@ -0,0 +1,257 @@
+// ページの一覧、検索、バックリンクは D1 の索引から返す。ページの中身と表示名は DO から返す。
+import { Hono } from 'hono';
+import { createMiddleware } from 'hono/factory';
+import { INDEX_EXCERPT_LENGTH, MAX_BOOKMARKS, MAX_LIST_LIMIT } from '../shared/api';
+import { requestLang } from '../shared/i18n';
+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';
+const REVERT_STATUS = {
+    'not-found': 404,
+    conflict: 409,
+    forbidden: 403,
+    invalid: 400,
+};
+/** パスの `:slug` が不正なら 400 を返す */
+export const validSlug = createMiddleware(async (c, next) => {
+    if (!isValidSlug(c.req.param('slug') ?? ''))
+        return c.json({ error: 'invalid slug' }, 400);
+    await next();
+});
+export const pagesApi = new Hono();
+/** 認証が有効かを確かめるための、軽い問い合わせ先（切断中に認証が切れたかをブラウザが調べる） */
+pagesApi.get('/session', (c) => c.json({ actor: c.get('actor') }));
+/**
+ * 一覧のボード用。ルートのページ（親のないページ）を新しい順に返す。子ページと孫ページは、
+ * 親ページの中からたどるので、ここには出さない。`child_count` は、直接の子ページの数。
+ *
+ * リンクは、ルートのページから出ているもののうち、リンク先がルートのページか、存在しない
+ * ページ（未作成。`missing` が 1）のものだけを返す。子孫のページが関わるリンクは、線にしない。
+ */
+pagesApi.get('/index', async (c) => {
+    const db = c.env.DB;
+    const roots = `SELECT name FROM pages WHERE parent IS NULL ORDER BY updated_at DESC LIMIT ?`;
+    const read = () => db.batch([
+        db
+            .prepare(`SELECT name, title, color, note_count, updated_at, substr(plain_text, 1, ?) AS excerpt,
+                  (SELECT count(*) FROM pages c WHERE c.parent = pages.name) AS child_count
+           FROM pages WHERE parent IS NULL ORDER BY updated_at DESC LIMIT ?`)
+            .bind(INDEX_EXCERPT_LENGTH, MAX_LIST_LIMIT),
+        db
+            .prepare(`SELECT l.from_page, l.to_page, p.name IS NULL AS missing
+           FROM links l LEFT JOIN pages p ON p.name = l.to_page
+           WHERE l.from_page IN (${roots}) AND p.parent IS NULL`)
+            .bind(MAX_LIST_LIMIT),
+    ]);
+    let [pages, links] = await read();
+    // ページが 1 つもない環境では、使い方の付箋を置いた最初のページを作る（1 回だけ。設定の firstPage で止められる）
+    const { firstPage, defaultLang } = c.get('config');
+    if (pages.results.length === 0 &&
+        firstPage &&
+        (await createFirstPage(c.env, requestLang(c.req.raw, defaultLang)))) {
+        [pages, links] = await read();
+    }
+    return c.json({ pages: pages.results, links: links.results });
+});
+/** 一度に問い合わせられるページの数 */
+const MAX_INFO_NAMES = 200;
+/**
+ * ページの概要をまとめて返す（本文は `{ "names": ["..."] }`）。子ページの付箋の表示に使う。
+ * 索引にないページ（未作成、削除済み）は、結果に入らない。
+ */
+pagesApi.post('/pages-info', async (c) => {
+    const body = await c.req.json().catch(() => null);
+    const names = Array.isArray(body?.names) ? body.names.filter((n) => typeof n === 'string') : [];
+    if (names.length === 0 || names.length > MAX_INFO_NAMES || !names.every(isValidSlug)) {
+        return c.json({ error: 'invalid names' }, 400);
+    }
+    const { results } = await c.env.DB.prepare(`SELECT name, title, color, note_count, parent, layout FROM pages WHERE name IN (SELECT value FROM json_each(?))`)
+        .bind(JSON.stringify(names))
+        .all();
+    // 索引への反映は、変更の数秒後。作ったばかりのページは、まだ索引にないので、DO から補う
+    // （付箋の配置は、索引ができるまで出さない）
+    const indexed = new Set(results.map((page) => page.name));
+    for (const name of new Set(names)) {
+        if (indexed.has(name))
+            continue;
+        const ref = await c.env.PAGE.getByName(name).getPageRef();
+        if (ref) {
+            const { title, color, parent } = ref;
+            results.push({ name, title, color, note_count: ref.noteCount, parent, layout: null });
+        }
+    }
+    return c.json({ pages: results });
+});
+/** 先祖のページを、ルートから順に返す（パンくず用）。DO をたどるので、直前の変更も反映される */
+pagesApi.get('/pages/:slug/ancestors', validSlug, async (c) => {
+    // DO は、親に近い順で返す
+    const ancestors = await c.env.PAGE.getByName(c.req.param('slug')).ancestors();
+    return c.json({ ancestors: ancestors.reverse() });
+});
+/**
+ * ページ一覧。`updated_after`（ミリ秒）より後に更新されたものに絞れる。`name` を渡すと、表示名か
+ * スラッグにその文字を含むページに絞る
+ */
+pagesApi.get('/pages', async (c) => {
+    const pages = await listPages(c.env.DB, {
+        updatedAfter: c.req.query('updated_after'),
+        limit: c.req.query('limit'),
+        name: c.req.query('name'),
+    });
+    return c.json({ pages });
+});
+/**
+ * 全文検索。`roots=1` なら、一致したページのスラッグと、そのルートのスラッグだけを返す
+ * （一覧の絞り込み用。一覧にはルートのページしか出ない）
+ */
+pagesApi.get('/search', async (c) => {
+    const q = c.req.query('q') ?? '';
+    const pages = c.req.query('roots') === '1' ? await searchRoots(c.env.DB, q) : await searchPages(c.env.DB, q);
+    return pages ? c.json({ pages }) : c.json({ error: 'invalid query' }, 400);
+});
+pagesApi.get('/pages/:slug', validSlug, async (c) => {
+    const slug = c.req.param('slug');
+    return c.json({ slug, ...(await c.env.PAGE.getByName(slug).getSnapshot()) });
+});
+/** ページの新規作成（本文は `{ "title": "..." }`。表示名は省略できる）。すでにあれば 409 */
+pagesApi.post('/pages/:slug', validSlug, async (c) => {
+    const body = await c.req.json().catch(() => null);
+    const result = await c.env.PAGE.getByName(c.req.param('slug')).createPage(body?.title);
+    if (result.ok)
+        return c.json(result, 201);
+    return c.json({ error: result.reason }, result.reason === 'exists' ? 409 : 400);
+});
+/** ページの削除。取り消しはできない */
+pagesApi.delete('/pages/:slug', validSlug, async (c) => {
+    await c.env.PAGE.getByName(c.req.param('slug')).deletePage(c.get('actor'));
+    return c.json({ ok: true });
+});
+/**
+ * 自分のブックマーク（付けた順）。表示名と更新の時刻は索引から取るので、作ったばかりのページ
+ * （索引への反映の前）は null になる
+ */
+pagesApi.get('/bookmarks', async (c) => {
+    const { results } = await c.env.DB.prepare(`SELECT b.page AS name, p.title, p.updated_at FROM bookmarks b LEFT JOIN pages p ON p.name = b.page
+     WHERE b.actor = ? ORDER BY b.created_at, b.page`)
+        .bind(c.get('actor'))
+        .all();
+    return c.json({ pages: results });
+});
+/** ブックマークを付ける。すでに付いていれば、何もしない */
+pagesApi.put('/bookmarks/:slug', validSlug, async (c) => {
+    const slug = c.req.param('slug');
+    const actor = c.get('actor');
+    // 索引への反映を待たずに確かめる（作ったばかりのページにも付けられる）
+    if ((await c.env.PAGE.getByName(slug).getPageRef()) === null)
+        return c.json({ error: 'page not found' }, 404);
+    // 上限は、付ける行の条件にする（数えてから付けると、同時に届いた分で超える）
+    const added = await c.env.DB.prepare(`INSERT OR IGNORE INTO bookmarks (actor, page, created_at)
+     SELECT ?1, ?2, ?3 WHERE (SELECT count(*) FROM bookmarks WHERE actor = ?1) < ?4`)
+        .bind(actor, slug, Date.now(), MAX_BOOKMARKS)
+        .run();
+    // 付かなかったのは、すでに付いているか、上限に達しているか
+    if (added.meta.changes === 0) {
+        const exists = await c.env.DB.prepare(`SELECT 1 FROM bookmarks WHERE actor = ? AND page = ?`)
+            .bind(actor, slug)
+            .first();
+        if (!exists)
+            return c.json({ error: `too many bookmarks (limit ${MAX_BOOKMARKS})` }, 400);
+    }
+    return c.json({ ok: true });
+});
+/** ブックマークを外す。付いていなくても、成功として返す */
+pagesApi.delete('/bookmarks/:slug', validSlug, async (c) => {
+    await c.env.DB.prepare(`DELETE FROM bookmarks WHERE actor = ? AND page = ?`)
+        .bind(c.get('actor'), c.req.param('slug'))
+        .run();
+    return c.json({ ok: true });
+});
+/** このページへリンクしているページ */
+pagesApi.get('/pages/:slug/backlinks', validSlug, async (c) => {
+    const { results } = await c.env.DB.prepare(`SELECT p.name, p.title FROM links l JOIN pages p ON p.name = l.from_page
+     WHERE l.to_page = ? ORDER BY p.updated_at DESC`)
+        .bind(c.req.param('slug'))
+        .all();
+    return c.json({ pages: results });
+});
+/** 最近の操作。`agent=1` で agent（MCP 経由）の操作に絞る */
+pagesApi.get('/pages/:slug/ops', validSlug, async (c) => {
+    const ops = await c.env.PAGE.getByName(c.req.param('slug')).listOps({
+        limit: Number(c.req.query('limit')),
+        agentOnly: c.req.query('agent') === '1',
+    });
+    return c.json({ ops });
+});
+/**
+ * 操作の取り消し。本文は `{ clientId, opId }`（同じ値で送り直しても二重に取り消さない）。
+ * その後に変更されていて取り消さなかったものは `skipped` で返す。
+ */
+pagesApi.post('/pages/:slug/ops/:seq/revert', validSlug, async (c) => {
+    const body = await c.req.json().catch(() => null);
+    const result = await c.env.PAGE.getByName(c.req.param('slug')).revert({
+        seq: Number(c.req.param('seq')),
+        actor: c.get('actor'),
+        clientId: String(body?.clientId ?? ''),
+        opId: String(body?.opId ?? ''),
+    });
+    if (result.ok)
+        return c.json(result);
+    return c.json({ error: result.reason }, REVERT_STATUS[result.code]);
+});
+/**
+ * 他のページから移す（写す）付箋を置く。本文は `{ clientId, opId, from, notes, edges }`
+ * （`from` は、付箋が元あったページ。同じ `opId` で送り直しても、二重には置かない）。
+ * 今ある付箋の下に置く。ページがなければ 404（作らない）
+ */
+pagesApi.post('/pages/:slug/notes', validSlug, async (c) => {
+    const body = await c.req
+        .json()
+        .catch(() => null);
+    const from = body?.from;
+    if (typeof from !== 'string' || !isValidSlug(from))
+        return c.json({ error: 'invalid from' }, 400);
+    const slug = c.req.param('slug');
+    const stub = c.env.PAGE.getByName(slug);
+    const result = await stub.receiveNotes({
+        actor: c.get('actor'),
+        clientId: String(body?.clientId ?? ''),
+        opId: String(body?.opId ?? ''),
+        from,
+        notes: body?.notes,
+        edges: body?.edges,
+    });
+    if (result.ok) {
+        // 置いた後の概要も返す（送った側が、索引への反映を待たずに、子ページの付箋を描き直せる）
+        const summary = await stub.getSummary();
+        return c.json({ ok: true, seq: result.seq, page: summary && { name: slug, ...summary } });
+    }
+    return c.json({ error: result.reason }, result.reason === REASON_PAGE_NOT_FOUND ? 404 : 400);
+});
+/**
+ * 表示名の変更。まだ書き込みのないページに対して呼ぶと、ページが作られる。
+ * 本文に `"mustExist": true` があれば、作らずに 404 を返す
+ */
+pagesApi.put('/pages/:slug/title', validSlug, async (c) => {
+    const body = await c.req.json().catch(() => null);
+    const result = await c.env.PAGE.getByName(c.req.param('slug')).setTitle(body?.title, {
+        mustExist: body?.mustExist === true,
+    });
+    if (result.ok)
+        return c.json(result);
+    return c.json({ error: result.reason }, result.reason === REASON_PAGE_NOT_FOUND ? 404 : 400);
+});
+/**
+ * ページの色の変更（本文は `{ "color": "#BBDEFB" }`。`PAGE_COLORS` のどれか。null で、付けていない
+ * 状態に戻す）。ページがなければ 404（作らない）
+ */
+pagesApi.put('/pages/:slug/color', validSlug, async (c) => {
+    const body = await c.req.json().catch(() => null);
+    // `color` のない本文を、「付けていない状態に戻す」として扱わない
+    if (body?.color === undefined)
+        return c.json({ error: 'invalid color' }, 400);
+    const result = await c.env.PAGE.getByName(c.req.param('slug')).setColor(body.color, c.get('actor'));
+    if (result.ok)
+        return c.json(result);
+    return c.json({ error: result.reason }, result.reason === REASON_PAGE_NOT_FOUND ? 404 : 400);
+});

package/dist/lib/worker/plain-text.d.ts

@@ -0,0 +1,22 @@
+export interface NoteContent {
+    /** タグを除いたテキスト。ブロックの区切りは改行にする */
+    text: string;
+    /** `<a>` の href（エンティティを復号したもの） */
+    hrefs: string[];
+}
+/**
+ * 付箋の text（サニタイズ済みの HTML）から、テキストとリンク先を取り出す。
+ *
+ * `pageLinks` を渡すと、ページへのリンクを `[[slug]]` の書式でテキストに残す（LLM に渡すとき。
+ * 書くときの書式は src/shared/note-text.ts）。リンクの文字がスラッグと違えば、文字の後ろに付ける。
+ * 外部へのリンク（http / https）は、URL を文字として残す（文字が URL と違えば、山かっこで後ろに付ける）。
+ * 渡さなければ、リンクの文字だけが残る（検索の索引を作るとき）
+ */
+export declare function extractContent(html: string, pageLinks?: {
+    siteOrigin: string | undefined;
+}): Promise<NoteContent>;
+/**
+ * href がこのサイトのページ（`/p/<slug>`）を指していれば、そのスラッグを返す。
+ * 対象は相対 URL と、`siteOrigin` を持つ絶対 URL。
+ */
+export declare function linkedSlug(href: string, siteOrigin: string | undefined): string | null;

package/dist/lib/worker/plain-text.js

@@ -0,0 +1,113 @@
+import { BLOCK_TAGS, decodeEntities } from '../shared/note-html';
+import { pageLink, TRAILING_PUNCTUATION, URL_CHARS } from '../shared/note-text';
+import { isValidSlug } from '../shared/slug';
+/**
+ * 付箋の text（サニタイズ済みの HTML）から、テキストとリンク先を取り出す。
+ *
+ * `pageLinks` を渡すと、ページへのリンクを `[[slug]]` の書式でテキストに残す（LLM に渡すとき。
+ * 書くときの書式は src/shared/note-text.ts）。リンクの文字がスラッグと違えば、文字の後ろに付ける。
+ * 外部へのリンク（http / https）は、URL を文字として残す（文字が URL と違えば、山かっこで後ろに付ける）。
+ * 渡さなければ、リンクの文字だけが残る（検索の索引を作るとき）
+ */
+export async function extractContent(html, pageLinks) {
+    if (!html.includes('<'))
+        return { text: decodeEntities(html).trim(), hrefs: [] };
+    const parts = [];
+    const hrefs = [];
+    const rewritten = new HTMLRewriter()
+        .on('a[href]', {
+        element(el) {
+            const href = decodeEntities(el.getAttribute('href') ?? '');
+            hrefs.push(href);
+            if (!pageLinks)
+                return;
+            const slug = linkedSlug(href, pageLinks.siteOrigin);
+            // 外部へのリンクは、リンク先の URL を文字として残す。それ以外（mailto など）は、文字だけ
+            const url = slug ? null : writableUrl(href);
+            if (!slug && !url)
+                return;
+            // リンクの文字を集めておき、閉じタグで、書式に直して置き換える
+            const start = parts.length;
+            el.onEndTag(() => {
+                // 文字は復号しないまま戻す（最後に、全体をまとめて復号する。ここで復号すると 2 回になる）
+                const raw = parts.splice(start).join('').trim();
+                const label = decodeEntities(raw);
+                if (slug) {
+                    parts.push(label === '' || label === slug ? pageLink(slug) : `${raw} ${pageLink(slug)}`);
+                }
+                else if (url) {
+                    // 人が貼ったリンクは、文字とリンク先が違うことがある。そのときは、URL を山かっこで後ろに付ける
+                    // （山かっこは URL に使えない文字なので、書き戻したときに、URL の一部にならない）
+                    const escaped = url.replace(/&/g, '&amp;');
+                    parts.push(label === '' || label === href || label === url ? escaped : `${raw} &lt;${escaped}&gt;`);
+                }
+            });
+        },
+    })
+        .on(BLOCK_TAGS.join(', '), {
+        element(el) {
+            parts.push('\n');
+            if (el.tagName !== 'br')
+                el.onEndTag(() => void parts.push('\n'));
+        },
+    })
+        .onDocument({
+        text(chunk) {
+            parts.push(chunk.text);
+        },
+    })
+        .transform(new Response(html));
+    // 変換後の HTML は使わない。読み捨てて、ハンドラだけを走らせる
+    await rewritten.body.pipeTo(new WritableStream());
+    const text = decodeEntities(parts.join(''))
+        .replace(/[ \t]*\n\s*/g, '\n')
+        .trim();
+    return { text, hrefs };
+}
+const UNWRITABLE_CHAR_RE = new RegExp(`[^${URL_CHARS}]`, 'g');
+const percentEncode = (char) => `%${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0')}`;
+/**
+ * 外部へのリンク（http / https）の href を、本文に書き戻しても同じリンク先になる形の URL にする
+ * （src/shared/note-text.ts は、URL に使える文字の並びだけをリンクにし、末尾の句読点と、余った
+ * 閉じかっこを外す）。外部へのリンクでなければ null
+ */
+function writableUrl(href) {
+    let url;
+    try {
+        url = new URL(href);
+    }
+    catch {
+        return null;
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:')
+        return null;
+    // 解釈した後の URL は、ASCII だけになる（日本語のパスは、パーセントエンコードされる）
+    let text = url.href.replace(UNWRITABLE_CHAR_RE, percentEncode);
+    // かっこの対が取れていなければ、かっこをすべてエンコードする
+    if (text.split('(').length !== text.split(')').length)
+        text = text.replace(/[()]/g, percentEncode);
+    // 末尾の句読点は、エンコードする。空のクエリの `?` は、外しても同じリンク先なので、そのまま
+    const last = text.at(-1);
+    if (last !== '?' && TRAILING_PUNCTUATION.includes(last))
+        text = text.slice(0, -1) + percentEncode(last);
+    return text;
+}
+/** 相対 URL を解決するための仮のオリジン */
+const RELATIVE_BASE = 'https://relative.invalid';
+/**
+ * href がこのサイトのページ（`/p/<slug>`）を指していれば、そのスラッグを返す。
+ * 対象は相対 URL と、`siteOrigin` を持つ絶対 URL。
+ */
+export function linkedSlug(href, siteOrigin) {
+    let url;
+    try {
+        url = new URL(href, RELATIVE_BASE);
+    }
+    catch {
+        return null;
+    }
+    if (url.origin !== RELATIVE_BASE && url.origin !== siteOrigin)
+        return null;
+    const slug = /^\/p\/([^/]+)\/?$/.exec(url.pathname)?.[1];
+    return slug && isValidSlug(slug) ? slug : null;
+}

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

@@ -0,0 +1,21 @@
+import type { Skipped } from '../shared/api';
+import type { HistoryDelta } from '../shared/delta';
+/**
+ * 逆向きのデルタ（`invertDeltas` の結果）を、取り消してよいものだけ順に適用する。
+ * `transactionSync` の中で呼ぶこと。
+ *
+ * 取り消してよいかは、対象が「取り消す操作が残した状態」のままかで決める。
+ *
+ * - 更新: フィールドごとに判定し、その後に変更されたフィールドは戻さない
+ * - 作成（付箋）: text が変わっていたら消さない。位置、大きさ、色だけの変更なら消す
+ *   （agent が貼った付箋を動かしただけで取り消せなくなるのを避ける）。
+ *   取り消さない接続線がつながっている付箋も消さない
+ * - 作成（接続線）: label が変わっていたら消さない
+ * - 削除: 同じ id のものがすでにあるか、接続線の両端がなければ戻さない
+ *
+ * 対象がすでにない作成の取り消しは、することがないので `skipped` にも入れない。
+ */
+export declare function applyRevert(sql: SqlStorage, inverse: HistoryDelta[], actor: string, now: number): {
+    deltas: HistoryDelta[];
+    skipped: Skipped[];
+};

package/dist/lib/worker/revert.js

@@ -0,0 +1,126 @@
+import { applyDeltas, exists, readEdge, readNote, readNoteFields, sameNoteValue } from './apply-ops';
+/**
+ * 更新の取り消しのうち、現在値が「取り消す操作が書いた値」のままのキーだけを残す。
+ * `expected` は取り消す操作が書いた値、`restore` は戻す値。キーがないことは未設定を表す。
+ */
+function unchangedKeys(current, expected, restore, same) {
+    const before = {};
+    const after = {};
+    let conflicted = false;
+    for (const key of new Set([...Object.keys(expected), ...Object.keys(restore)])) {
+        if (!same(key, current[key], expected[key])) {
+            conflicted = true;
+            continue;
+        }
+        if (key in expected)
+            before[key] = expected[key];
+        if (key in restore)
+            after[key] = restore[key];
+    }
+    return { before, after, conflicted };
+}
+const sameEdgeValue = (_key, a, b) => a === b;
+/**
+ * 逆向きのデルタ（`invertDeltas` の結果）を、取り消してよいものだけ順に適用する。
+ * `transactionSync` の中で呼ぶこと。
+ *
+ * 取り消してよいかは、対象が「取り消す操作が残した状態」のままかで決める。
+ *
+ * - 更新: フィールドごとに判定し、その後に変更されたフィールドは戻さない
+ * - 作成（付箋）: text が変わっていたら消さない。位置、大きさ、色だけの変更なら消す
+ *   （agent が貼った付箋を動かしただけで取り消せなくなるのを避ける）。
+ *   取り消さない接続線がつながっている付箋も消さない
+ * - 作成（接続線）: label が変わっていたら消さない
+ * - 削除: 同じ id のものがすでにあるか、接続線の両端がなければ戻さない
+ *
+ * 対象がすでにない作成の取り消しは、することがないので `skipped` にも入れない。
+ */
+export function applyRevert(sql, inverse, actor, now) {
+    const deltas = [];
+    const skipped = [];
+    // 1 つずつ適用する。後のデルタの判定が、先のデルタの結果（復活した付箋など）を見られるようにする
+    const apply = (d) => {
+        deltas.push(...applyDeltas(sql, [d], actor, now).deltas);
+    };
+    /** 更新の取り消しで、戻してよいフィールドだけの before / after を返す。戻さない分は skipped に入れる */
+    const restorable = (target, id, current, d, same) => {
+        if (!current) {
+            skipped.push({ target, id, reason: 'deleted' });
+            return undefined;
+        }
+        const { before, after, conflicted } = unchangedKeys(current, d.before, d.after, same);
+        if (conflicted)
+            skipped.push({ target, id, reason: 'modified' });
+        return { before, after };
+    };
+    for (const d of inverse) {
+        switch (d.type) {
+            case 'note:delete': {
+                const cur = readNote(sql, d.note.id);
+                if (!cur)
+                    break;
+                // 付箋を消すと、つながっている接続線も消える。この時点で残っている接続線は、
+                // この取り消しで戻さなかったもの（変更されていた）か、他の人が後からつないだものなので、
+                // 付箋ごと残す
+                const connected = sql.exec(`SELECT 1 FROM edges WHERE from_id = ? OR to_id = ? LIMIT 1`, cur.id, cur.id)
+                    .toArray().length > 0;
+                if (cur.text !== d.note.text)
+                    skipped.push({ target: 'note', id: cur.id, reason: 'modified' });
+                else if (connected)
+                    skipped.push({ target: 'note', id: cur.id, reason: 'connected' });
+                else
+                    apply(d);
+                break;
+            }
+            case 'note:create': {
+                if (exists(sql, 'notes', d.note.id)) {
+                    skipped.push({ target: 'note', id: d.note.id, reason: 'exists' });
+                }
+                else {
+                    apply(d);
+                }
+                break;
+            }
+            case 'note:update': {
+                // 関わるフィールドだけを読む（移動の取り消しで大きな text を読まない）
+                const keys = [...Object.keys(d.before), ...Object.keys(d.after)];
+                const cur = readNoteFields(sql, d.noteId, keys);
+                const patch = restorable('note', d.noteId, cur, d, sameNoteValue);
+                if (patch)
+                    apply({ type: 'note:update', noteId: d.noteId, ...patch });
+                break;
+            }
+            case 'edge:delete': {
+                const cur = readEdge(sql, d.edge.id);
+                if (!cur)
+                    break;
+                if (cur.label !== d.edge.label)
+                    skipped.push({ target: 'edge', id: cur.id, reason: 'modified' });
+                else
+                    apply(d);
+                break;
+            }
+            case 'edge:create': {
+                const e = d.edge;
+                if (exists(sql, 'edges', e.id)) {
+                    skipped.push({ target: 'edge', id: e.id, reason: 'exists' });
+                }
+                else if (!exists(sql, 'notes', e.from) || !exists(sql, 'notes', e.to)) {
+                    skipped.push({ target: 'edge', id: e.id, reason: 'endpoint-missing' });
+                }
+                else {
+                    apply(d);
+                }
+                break;
+            }
+            case 'edge:update': {
+                const cur = readEdge(sql, d.edgeId);
+                const patch = restorable('edge', d.edgeId, cur && { ...cur }, d, sameEdgeValue);
+                if (patch)
+                    apply({ type: 'edge:update', edgeId: d.edgeId, ...patch });
+                break;
+            }
+        }
+    }
+    return { deltas, skipped };
+}