@kanf/wema-kake 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,34 @@
+import type { ResolvedConfig, WemaKakeEnv } from './config';
+/**
+ * 入口が受け付ける主体の種類。
+ * - user: Access にログインしたブラウザ（画面からの API、WebSocket、画像）
+ * - agent: Access の Managed OAuth で認可された MCP のクライアント（`/mcp`）
+ */
+export type PrincipalKind = 'user' | 'agent';
+export type AuthEnv = {
+    Bindings: WemaKakeEnv;
+    Variables: {
+        /** 利用側が `createWemaKake` に渡した設定（既定の値を埋めたもの） */
+        config: ResolvedConfig;
+        /** `Principal` の `actor` */
+        actor: string;
+        /** `Principal` の `expiresAt` */
+        authExpiresAt?: number;
+    };
+};
+/**
+ * agent の主体を、認可のリダイレクト先から決める。リダイレクト先は、Access の設定
+ * （Allowed redirect URIs）で許可したものに限られるので、クライアントが申告する名前と違って偽れない。
+ * `https://claude.ai/api/mcp/auth_callback` なら `agent:claude.ai`。
+ *
+ * 手元のクライアント（リダイレクト先が localhost やループバックのアドレス）は、どれも
+ * `agent:localhost` になり、互いを区別しない。ホスト名のない独自スキーム（`com.example.app:/cb`）は、
+ * スキームを名前にする
+ */
+export declare function agentActor(redirectUri: unknown): string;
+/**
+ * `kind` の主体だけを通すミドルウェア。**入口（ルート）ごとに、どちらの種類かを宣言して掛ける。**
+ * パスの文字列を見て種類を決める形にしない（ルーターはパスをデコードして照合するので、
+ * `/%6dcp` のようなパスで、判定とルーティングが食い違う）
+ */
+export declare const requireAccess: (kind: PrincipalKind) => import("hono").MiddlewareHandler<AuthEnv, string, {}, Response>;

package/dist/lib/worker/access.js

@@ -0,0 +1,114 @@
+import { createMiddleware } from 'hono/factory';
+import { createRemoteJWKSet, jwksCache, jwtVerify } from 'jose';
+const LOCAL_HOSTS = new Set(['localhost', '127.0.0.1', '[::1]']);
+/**
+ * ローカル開発のホスト名か。`.localhost` で終わる名前も含める（ローカルのリバースプロキシが
+ * 付ける `<名前>.localhost`）。`.localhost` はループバック専用の予約名（RFC 6761）なので、
+ * デプロイ先のホスト名がこれに当たることはない
+ */
+const isLocalHost = (hostname) => LOCAL_HOSTS.has(hostname) || hostname.endsWith('.localhost');
+/**
+ * 取得済みの公開鍵（データ）を、鍵の取得元の URL ごとに isolate 内で使い回す。
+ * createRemoteJWKSet そのものはリクエストごとに作る。使い回すと取得中の Promise が
+ * リクエスト間で共有され、Workers では別のリクエストが作った Promise を待つと止まることがある。
+ * 鍵の期限、ローテーション時の取り直し、取り直しの間隔の制限は jose が行う。
+ */
+const keyCaches = new Map();
+function remoteKeys(certsUrl) {
+    let cache = keyCaches.get(certsUrl.href);
+    if (!cache) {
+        cache = {};
+        keyCaches.set(certsUrl.href, cache);
+    }
+    return createRemoteJWKSet(certsUrl, { [jwksCache]: cache });
+}
+/**
+ * agent の主体を、認可のリダイレクト先から決める。リダイレクト先は、Access の設定
+ * （Allowed redirect URIs）で許可したものに限られるので、クライアントが申告する名前と違って偽れない。
+ * `https://claude.ai/api/mcp/auth_callback` なら `agent:claude.ai`。
+ *
+ * 手元のクライアント（リダイレクト先が localhost やループバックのアドレス）は、どれも
+ * `agent:localhost` になり、互いを区別しない。ホスト名のない独自スキーム（`com.example.app:/cb`）は、
+ * スキームを名前にする
+ */
+export function agentActor(redirectUri) {
+    let host = '';
+    try {
+        const url = new URL(typeof redirectUri === 'string' ? redirectUri : '');
+        host = LOCAL_HOSTS.has(url.hostname) ? 'localhost' : url.hostname || url.protocol;
+    }
+    catch {
+        // 下で unknown にする
+    }
+    const name = host.toLowerCase().replace(/[^a-z0-9.-]+/g, '-');
+    return `agent:${name.replace(/^[-.]+|[-.]+$/g, '').slice(0, 64) || 'unknown'}`;
+}
+/**
+ * Access が付けた JWT を検証し、主体とその種類を返す。検証できなければ null。
+ *
+ * MCP のクライアントは、Access の Managed OAuth で認可される。そのトークンで届いたリクエストの
+ * JWT には `oauth`（`client_id` と `client_redirect_uri`）が入り、ブラウザのログインでは入らない。
+ * `oauth` があれば、形がどうであれ agent として扱う（人の入口を通さない）
+ */
+async function verifyAccessJwt(token, teamDomain, aud) {
+    try {
+        const keys = remoteKeys(new URL('/cdn-cgi/access/certs', teamDomain));
+        const { payload } = await jwtVerify(token, keys, {
+            issuer: teamDomain,
+            audience: aud,
+            requiredClaims: ['exp'],
+        });
+        if (typeof payload.email !== 'string' || payload.email === '')
+            return null;
+        const { email, exp: expiresAt, oauth } = payload;
+        if (oauth === undefined)
+            return { kind: 'user', actor: `user:${email}`, expiresAt };
+        const redirectUri = oauth?.client_redirect_uri;
+        return { kind: 'agent', actor: agentActor(redirectUri), expiresAt };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * リクエストの主体を決める。画面からのリクエストも MCP も、ここを通す。
+ *
+ * Cloudflare Access の JWT（`Cf-Access-Jwt-Assertion`）を検証する。画面も `/mcp` も Access の
+ * アプリケーションで保護する前提だが、Access の設定を誤っても未認証のリクエストを通さないよう、
+ * Worker でも検証する。
+ *
+ * Access はパスを区別しないので、OAuth のトークンでも `/api` などを呼べてしまう。`kind` と
+ * 合わない主体は、ここで断る。
+ *
+ * `ACCESS_TEAM_DOMAIN` と `ACCESS_AUD` が未設定のときは、ローカル開発に限り `DEV_USER_EMAIL` を
+ * 使う。どちらもなければ拒否する。
+ */
+async function authenticate(request, env, kind) {
+    const { ACCESS_TEAM_DOMAIN: teamDomain, ACCESS_AUD: aud, DEV_USER_EMAIL: devEmail } = env;
+    if (teamDomain && aud) {
+        const token = request.headers.get('Cf-Access-Jwt-Assertion');
+        const verified = token ? await verifyAccessJwt(token, teamDomain, aud) : null;
+        if (!verified)
+            return { status: 401, error: 'unauthorized' };
+        if (verified.kind !== kind)
+            return { status: 403, error: 'forbidden' };
+        return { principal: verified };
+    }
+    if (devEmail && isLocalHost(new URL(request.url).hostname)) {
+        return { principal: { actor: kind === 'user' ? `user:${devEmail}` : 'agent:local' } };
+    }
+    return { status: 500, error: 'authentication is not configured' };
+}
+/**
+ * `kind` の主体だけを通すミドルウェア。**入口（ルート）ごとに、どちらの種類かを宣言して掛ける。**
+ * パスの文字列を見て種類を決める形にしない（ルーターはパスをデコードして照合するので、
+ * `/%6dcp` のようなパスで、判定とルーティングが食い違う）
+ */
+export const requireAccess = (kind) => createMiddleware(async (c, next) => {
+    const result = await authenticate(c.req.raw, c.env, kind);
+    if ('error' in result)
+        return c.json({ error: result.error }, result.status);
+    c.set('actor', result.principal.actor);
+    c.set('authExpiresAt', result.principal.expiresAt);
+    await next();
+});

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

@@ -0,0 +1,75 @@
+import type { BoardData, HistoryDelta, WemaEdge, WemaNote } from '../shared/delta';
+import type { NoteInfos } from '../shared/note-info';
+import type { BoardState } from '../shared/tools';
+import { type Obj } from './validate';
+/**
+ * 真偽値のフィールドを、すべて未設定（false）にした値。「未設定」と false が同じ意味で、
+ * 列には 0 / 1 で保存する。読んだ付箋には true のものしか入らないので、付箋の内容に合わせる
+ * デルタを作るときは、これを下に敷く
+ */
+export declare const UNSET_FLAGS: {
+    autoSize: false;
+    foldable: false;
+};
+/**
+ * 付箋のフィールドの値が同じか。autoSize と foldable は「未設定」と false が同じ意味。
+ * meta は全体を比べる（キーがないことと、空は同じ）
+ */
+export declare function sameNoteValue(key: string, a: unknown, b: unknown): boolean;
+/** このページに置いてある子ページ（子ページの付箋が指すページ） */
+export declare function childPages(sql: SqlStorage): Set<string>;
+/** 子ページの付箋の、id、色、指している子ページ（本文は読まない） */
+export declare function childNoteColors(sql: SqlStorage): {
+    id: string;
+    color: string;
+    page: string;
+}[];
+export declare function exists(sql: SqlStorage, table: 'notes' | 'edges', id: string): boolean;
+export declare function readNote(sql: SqlStorage, id: string): WemaNote | undefined;
+/**
+ * 付箋の、指定したフィールドだけを読む（`keys` のうち更新できるフィールド以外は無視する）。
+ * 移動だけの更新で大きな text を読まないようにするためのもの。autoSize と foldable は真偽値で返す。
+ */
+export declare function readNoteFields(sql: SqlStorage, id: string, keys: string[]): Obj | undefined;
+export declare function readEdge(sql: SqlStorage, id: string): WemaEdge | undefined;
+/** 付箋だけを読む（接続線は読まない） */
+export declare const readNotes: (sql: SqlStorage) => WemaNote[];
+/** ボードと、付箋ごとの付加情報（作成者、更新日時）。画面に渡す */
+export declare function readBoardWithInfos(sql: SqlStorage): {
+    data: BoardData;
+    info: NoteInfos;
+};
+/** 付箋（作成者つき）と接続線。agent に渡す */
+export declare function readBoardWithAuthors(sql: SqlStorage): Pick<BoardState, 'notes' | 'edges'>;
+export declare const readBoard: (sql: SqlStorage) => BoardData;
+export interface Sanitized {
+    /** サニタイズで text が変わった付箋について、送信元の手元の状態を直すためのデルタ */
+    fixups: HistoryDelta[];
+    /** text を更新するデルタ → サニタイズした `before.text`（競合の判定に使う） */
+    cleanBefore: Map<HistoryDelta, string>;
+}
+/**
+ * デルタ中の text をサニタイズする（`note.text` と `after.text` を書き換える）。
+ * `cleanBefore: false` なら `before.text` のサニタイズを省く（競合の判定に使わない場合）。
+ */
+export declare function sanitizeDeltas(deltas: HistoryDelta[], options?: {
+    cleanBefore: boolean;
+}): Promise<Sanitized>;
+export interface Applied {
+    /** 実際に適用したデルタ。before と削除対象はサーバーの保存値で置き換えてある */
+    deltas: HistoryDelta[];
+    /** 送信元が送っていないのにサーバーが足したデルタ（付箋の削除に伴う接続線の削除） */
+    fixups: HistoryDelta[];
+}
+/**
+ * デルタを順に適用する。`transactionSync` の中で呼ぶこと（RejectError で全体を巻き戻す）。
+ *
+ * - 作成: id が使用済み、または接続線の両端がなければ拒否する
+ * - 更新と削除: 対象がすでになければ、そのデルタを捨てる（他の人が先に消した場合）
+ * - text の更新: `before.text` が現在値と違えば拒否する。`before.text` はそのままの値か、
+ *   サニタイズした値（`cleanBefore`）のどちらかが一致すればよい。前者は、サニタイズの規則を
+ *   変える前に保存した text を編集できるようにするため。後者は、送信元がサニタイズ前の
+ *   text を手元に持ったまま続けて編集した場合のため
+ * - 更新で `after` にキーがなく `before` にあるものは、未設定に戻す
+ */
+export declare function applyDeltas(sql: SqlStorage, deltas: HistoryDelta[], actor: string, now: number, cleanBefore?: Map<HistoryDelta, string>): Applied;

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

@@ -0,0 +1,335 @@
+import { CHILD_PAGE_KEY, childPageOf, childRejection } from '../shared/hierarchy';
+import { REASON_TEXT_CONFLICT } from '../shared/protocol';
+import { sanitizeHtml } from './sanitize';
+import { RejectError, REQUIRED_EDGE_FIELDS } from './validate';
+/** WemaNote のフィールド名 → notes の列名（更新できるもの） */
+const NOTE_COLUMNS = {
+    x: 'x',
+    y: 'y',
+    width: 'width',
+    height: 'height',
+    text: 'text',
+    color: 'color',
+    autoSize: 'auto_size',
+    foldable: 'foldable',
+    // meta は JSON の文字列で保存する。空なら NULL
+    meta: 'extra',
+    // wema が付箋にフィールドを足したら、ここで型エラーになる（知らないフィールドを黙って捨てないため）
+};
+/**
+ * 真偽値のフィールドを、すべて未設定（false）にした値。「未設定」と false が同じ意味で、
+ * 列には 0 / 1 で保存する。読んだ付箋には true のものしか入らないので、付箋の内容に合わせる
+ * デルタを作るときは、これを下に敷く
+ */
+export const UNSET_FLAGS = { autoSize: false, foldable: false };
+const FLAG_FIELDS = Object.keys(UNSET_FLAGS);
+/** meta を、保存する形（JSON の文字列。空なら null）にする。キーは検証のときに並べ替えてある */
+function metaJson(meta) {
+    return meta && Object.keys(meta).length > 0 ? JSON.stringify(meta) : null;
+}
+/**
+ * 付箋のフィールドの値が同じか。autoSize と foldable は「未設定」と false が同じ意味。
+ * meta は全体を比べる（キーがないことと、空は同じ）
+ */
+export function sameNoteValue(key, a, b) {
+    if (FLAG_FIELDS.includes(key))
+        return (a === true) === (b === true);
+    if (key === 'meta')
+        return metaJson(a) === metaJson(b);
+    return a === b;
+}
+/** 保存した列の値を、付箋のフィールドの値にする */
+function fromColumn(key, value) {
+    if (FLAG_FIELDS.includes(key))
+        return Boolean(value);
+    if (key === 'meta')
+        return value === null ? undefined : JSON.parse(value);
+    return value;
+}
+/** 付箋のフィールドの値を、保存する列の値にする */
+function toColumn(key, value) {
+    if (FLAG_FIELDS.includes(key))
+        return value === true ? 1 : 0;
+    if (key === 'meta')
+        return metaJson(value);
+    return value;
+}
+function rowToNote(row) {
+    const note = {
+        id: row.id,
+        x: row.x,
+        y: row.y,
+        width: row.width,
+        height: row.height,
+        text: row.text,
+        color: row.color,
+        zIndex: row.z_index,
+    };
+    if (row.auto_size)
+        note.autoSize = true;
+    if (row.foldable)
+        note.foldable = true;
+    if (row.extra !== null)
+        note.meta = JSON.parse(row.extra);
+    return note;
+}
+/** このページに置いてある子ページ（子ページの付箋が指すページ） */
+export function childPages(sql) {
+    const rows = sql
+        .exec(`SELECT json_extract(extra, '$.${CHILD_PAGE_KEY}') AS page FROM notes WHERE extra IS NOT NULL`)
+        .toArray();
+    return new Set(rows.map((row) => row.page).filter((page) => typeof page === 'string'));
+}
+/** 子ページの付箋の、id、色、指している子ページ（本文は読まない） */
+export function childNoteColors(sql) {
+    return sql
+        .exec(`SELECT id, color, json_extract(extra, '$.${CHILD_PAGE_KEY}') AS page FROM notes WHERE extra IS NOT NULL`)
+        .toArray()
+        .filter((row) => typeof row.page === 'string');
+}
+/** `page` を指す子ページの付箋が、`exceptId` 以外にあるか */
+function hasChildNote(sql, page, exceptId) {
+    return (sql
+        .exec(`SELECT 1 FROM notes WHERE json_extract(extra, '$.${CHILD_PAGE_KEY}') = ? AND id <> ? LIMIT 1`, page, exceptId)
+        .toArray().length > 0);
+}
+/** 同じ子ページを、1 つのページに 2 つ置くことはできない */
+function assertNotPlaced(sql, note, noteId) {
+    const page = childPageOf(note);
+    if (page !== undefined && hasChildNote(sql, page, noteId)) {
+        throw new RejectError(childRejection('duplicate', page));
+    }
+}
+function rowToEdge(row) {
+    return {
+        ...JSON.parse(row.props),
+        id: row.id,
+        from: row.from_id,
+        to: row.to_id,
+    };
+}
+function edgeProps(edge) {
+    const { id: _id, from: _from, to: _to, ...props } = edge;
+    return JSON.stringify(props);
+}
+export function exists(sql, table, id) {
+    return sql.exec(`SELECT 1 FROM ${table} WHERE id = ?`, id).toArray().length > 0;
+}
+export function readNote(sql, id) {
+    const row = sql.exec(`SELECT * FROM notes WHERE id = ?`, id).toArray()[0];
+    return row && rowToNote(row);
+}
+/**
+ * 付箋の、指定したフィールドだけを読む（`keys` のうち更新できるフィールド以外は無視する）。
+ * 移動だけの更新で大きな text を読まないようにするためのもの。autoSize と foldable は真偽値で返す。
+ */
+export function readNoteFields(sql, id, keys) {
+    const fields = keys.filter((k) => k in NOTE_COLUMNS);
+    const columns = fields.length > 0 ? fields.map((k) => NOTE_COLUMNS[k]).join(', ') : '1';
+    const row = sql.exec(`SELECT ${columns} FROM notes WHERE id = ?`, id).toArray()[0];
+    if (!row)
+        return undefined;
+    const out = {};
+    for (const k of fields) {
+        // 未設定のフィールド（meta）は、キーごと入れない
+        const value = fromColumn(k, row[NOTE_COLUMNS[k]]);
+        if (value !== undefined)
+            out[k] = value;
+    }
+    return out;
+}
+export function readEdge(sql, id) {
+    const row = sql.exec(`SELECT * FROM edges WHERE id = ?`, id).toArray()[0];
+    return row && rowToEdge(row);
+}
+const noteRows = (sql) => sql.exec(`SELECT * FROM notes ORDER BY rowid`).toArray();
+/** 付箋だけを読む（接続線は読まない） */
+export const readNotes = (sql) => noteRows(sql).map(rowToNote);
+const readEdges = (sql) => sql.exec(`SELECT * FROM edges ORDER BY rowid`).toArray().map(rowToEdge);
+/** ボードと、付箋ごとの付加情報（作成者、更新日時）。画面に渡す */
+export function readBoardWithInfos(sql) {
+    const rows = noteRows(sql);
+    // 代入で組み立てない。`__proto__` という id の付箋が、表から落ちる
+    const info = Object.fromEntries(rows.map((row) => [
+        row.id,
+        { createdBy: row.created_by, updatedAt: row.updated_at },
+    ]));
+    return { data: { version: 1, notes: rows.map(rowToNote), edges: readEdges(sql) }, info };
+}
+/** 付箋（作成者つき）と接続線。agent に渡す */
+export function readBoardWithAuthors(sql) {
+    return {
+        notes: noteRows(sql).map((row) => ({ ...rowToNote(row), createdBy: row.created_by })),
+        edges: readEdges(sql),
+    };
+}
+export const readBoard = (sql) => readBoardWithInfos(sql).data;
+/**
+ * デルタ中の text をサニタイズする（`note.text` と `after.text` を書き換える）。
+ * `cleanBefore: false` なら `before.text` のサニタイズを省く（競合の判定に使わない場合）。
+ */
+export async function sanitizeDeltas(deltas, options = { cleanBefore: true }) {
+    const fixups = [];
+    const cleanBefore = new Map();
+    const fix = (noteId, sent, clean) => {
+        // 送信元は after を適用するだけなので、送られてきた text は記録に残さない
+        if (sent !== clean) {
+            fixups.push({ type: 'note:update', noteId, before: {}, after: { text: clean } });
+        }
+    };
+    for (const d of deltas) {
+        if (d.type === 'note:create') {
+            const sent = d.note.text;
+            d.note.text = await sanitizeHtml(sent);
+            fix(d.note.id, sent, d.note.text);
+        }
+        else if (d.type === 'note:update' && d.after.text !== undefined) {
+            const sent = d.after.text;
+            d.after.text = await sanitizeHtml(sent);
+            fix(d.noteId, sent, d.after.text);
+            const before = d.before.text;
+            if (options.cleanBefore && before !== undefined) {
+                cleanBefore.set(d, before === sent ? d.after.text : await sanitizeHtml(before));
+            }
+        }
+    }
+    return { fixups, cleanBefore };
+}
+/**
+ * デルタを順に適用する。`transactionSync` の中で呼ぶこと（RejectError で全体を巻き戻す）。
+ *
+ * - 作成: id が使用済み、または接続線の両端がなければ拒否する
+ * - 更新と削除: 対象がすでになければ、そのデルタを捨てる（他の人が先に消した場合）
+ * - text の更新: `before.text` が現在値と違えば拒否する。`before.text` はそのままの値か、
+ *   サニタイズした値（`cleanBefore`）のどちらかが一致すればよい。前者は、サニタイズの規則を
+ *   変える前に保存した text を編集できるようにするため。後者は、送信元がサニタイズ前の
+ *   text を手元に持ったまま続けて編集した場合のため
+ * - 更新で `after` にキーがなく `before` にあるものは、未設定に戻す
+ */
+export function applyDeltas(sql, deltas, actor, now, cleanBefore) {
+    const applied = [];
+    const fixups = [];
+    for (const d of deltas) {
+        switch (d.type) {
+            case 'note:create': {
+                const n = d.note;
+                if (exists(sql, 'notes', n.id))
+                    throw new RejectError(`note already exists: ${n.id}`);
+                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);
+                applied.push(d);
+                break;
+            }
+            case 'note:update': {
+                const next = { ...d.after };
+                // autoSize と foldable は「未設定」と false が同じ意味
+                for (const flag of FLAG_FIELDS) {
+                    if (flag in d.before || flag in next)
+                        next[flag] = next[flag] === true;
+                }
+                // meta は全体を置き換える。after になく before にあれば、取り除く（空の meta にする）
+                if (!('meta' in next) && 'meta' in d.before)
+                    next.meta = {};
+                const keys = Object.keys(NOTE_COLUMNS).filter((k) => next[k] !== undefined);
+                if (keys.length === 0)
+                    break;
+                const cur = readNoteFields(sql, d.noteId, keys);
+                if (!cur)
+                    break;
+                if (next.text !== undefined &&
+                    d.before.text !== cur.text &&
+                    cleanBefore?.get(d) !== cur.text) {
+                    throw new RejectError(REASON_TEXT_CONFLICT, { notes: [readNote(sql, d.noteId)], edges: [] });
+                }
+                const changed = keys.filter((k) => !sameNoteValue(k, next[k], cur[k]));
+                if (changed.length === 0)
+                    break;
+                if (changed.includes('meta'))
+                    assertNotPlaced(sql, next, d.noteId);
+                sql.exec(`UPDATE notes SET ${changed.map((k) => `${NOTE_COLUMNS[k]} = ?`).join(', ')},
+                            updated_at = ?, updated_by = ?
+           WHERE id = ?`, ...changed.map((k) => toColumn(k, next[k])), now, actor, d.noteId);
+                // 未設定の値（取り除いた meta、もともとなかった meta）は、キーごと入れない
+                const fieldsOf = (values) => Object.fromEntries(changed.filter((k) => toColumn(k, values[k]) !== null).map((k) => [k, values[k]]));
+                applied.push({ type: 'note:update', noteId: d.noteId, before: fieldsOf(cur), after: fieldsOf(next) });
+                break;
+            }
+            case 'note:delete': {
+                const cur = readNote(sql, d.note.id);
+                if (!cur)
+                    break;
+                // wema は接続線の削除を先に送ってくる。残っているのは他の人が同時に足したものか、
+                // 接続線を指定しない呼び出し（MCP）なので、ここで削除のデルタを作って記録に残す
+                const rest = sql
+                    .exec(`SELECT * FROM edges WHERE from_id = ? OR to_id = ? ORDER BY rowid`, cur.id, cur.id)
+                    .toArray()
+                    .map(rowToEdge);
+                for (const edge of rest) {
+                    const del = { type: 'edge:delete', edge };
+                    applied.push(del);
+                    fixups.push(del);
+                }
+                if (rest.length > 0) {
+                    sql.exec(`DELETE FROM edges WHERE from_id = ? OR to_id = ?`, cur.id, cur.id);
+                }
+                sql.exec(`DELETE FROM notes WHERE id = ?`, cur.id);
+                applied.push({ type: 'note:delete', note: cur });
+                break;
+            }
+            case 'edge:create': {
+                const e = d.edge;
+                if (exists(sql, 'edges', e.id))
+                    throw new RejectError(`edge already exists: ${e.id}`);
+                if (!exists(sql, 'notes', e.from) || !exists(sql, 'notes', e.to)) {
+                    throw new RejectError(`edge endpoint not found: ${e.id}`);
+                }
+                sql.exec(`INSERT INTO edges (id, from_id, to_id, props, created_by, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?)`, e.id, e.from, e.to, edgeProps({ ...e }), actor, now);
+                applied.push(d);
+                break;
+            }
+            case 'edge:update': {
+                const cur = readEdge(sql, d.edgeId);
+                if (!cur)
+                    break;
+                const next = { ...cur };
+                const patch = d.after;
+                const before = {};
+                const after = {};
+                for (const key of new Set([...Object.keys(d.before), ...Object.keys(patch)])) {
+                    const value = patch[key];
+                    if (value === undefined && REQUIRED_EDGE_FIELDS.includes(key))
+                        continue;
+                    const prev = next[key];
+                    if (value === prev)
+                        continue;
+                    if (prev !== undefined)
+                        before[key] = prev;
+                    if (value === undefined) {
+                        delete next[key];
+                    }
+                    else {
+                        after[key] = value;
+                        next[key] = value;
+                    }
+                }
+                if (Object.keys(before).length === 0 && Object.keys(after).length === 0)
+                    break;
+                sql.exec(`UPDATE edges SET props = ?, updated_at = ? WHERE id = ?`, edgeProps(next), now, d.edgeId);
+                applied.push({ type: 'edge:update', edgeId: d.edgeId, before, after });
+                break;
+            }
+            case 'edge:delete': {
+                const cur = readEdge(sql, d.edge.id);
+                if (!cur)
+                    break;
+                sql.exec(`DELETE FROM edges WHERE id = ?`, cur.id);
+                applied.push({ type: 'edge:delete', edge: cur });
+                break;
+            }
+        }
+    }
+    return { deltas: applied, fixups };
+}

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

@@ -0,0 +1,4 @@
+import { type SiteConfig } from '../shared/site';
+import type { WemaKakeEnv } from './config';
+/** アセットを返す関数を作る。設定は変わらないので、埋め込む `<meta>` はここで 1 回だけ作る */
+export declare function assetServer(site: SiteConfig): (request: Request, env: WemaKakeEnv) => Promise<Response>;

package/dist/lib/worker/assets.js

@@ -0,0 +1,35 @@
+// 画面のアセット（ビルド済みの dist/web）を返す。`run_worker_first: true` なので、API に当たらない
+// リクエストもすべて Worker に届き、ここから ASSETS バインディングへ渡す。
+//
+// HTML（index.html。SPA なので、/p/<slug> などにもこれが返る）には、サイトの設定を `<meta>` で
+// 埋め込み、`<title>` をサイトの名前にする（src/shared/site.ts）。
+import { SITE_META_NAME } from '../shared/site';
+const escapeAttr = (value) => value.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+/** アセットを返す関数を作る。設定は変わらないので、埋め込む `<meta>` はここで 1 回だけ作る */
+export function assetServer(site) {
+    // 画面に要る項目だけを出す（設定のほかの項目を、画面に見せない）
+    const content = { siteName: site.siteName, defaultLang: site.defaultLang };
+    const meta = `<meta name="${SITE_META_NAME}" content="${escapeAttr(JSON.stringify(content))}">`;
+    const title = { element: (el) => void el.setInnerContent(site.siteName) };
+    const head = { element: (el) => void el.prepend(meta, { html: true }) };
+    return async (request, env) => {
+        // ページの読み込み（HTML を取りに来るリクエスト）は、条件付きの取得にしない。アセットの ETag は
+        // ファイルの中身だけで決まるので、設定だけを変えてデプロイしたときに、304 で古い設定の HTML が
+        // 使われ続ける。index.html は小さいので、毎回送る
+        let forward = request;
+        if (request.headers.get('Accept')?.includes('text/html')) {
+            const headers = new Headers(request.headers);
+            headers.delete('If-None-Match');
+            headers.delete('If-Modified-Since');
+            forward = new Request(request, { headers });
+        }
+        const res = await env.ASSETS.fetch(forward);
+        if (!res.headers.get('Content-Type')?.startsWith('text/html'))
+            return res;
+        const headers = new Headers(res.headers);
+        // 書き換えた本文は、元の ETag と中身が合わない
+        headers.delete('ETag');
+        headers.delete('Content-Length');
+        return new HTMLRewriter().on('title', title).on('head', head).transform(new Response(res.body, { status: res.status, statusText: res.statusText, headers }));
+    };
+}

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

@@ -0,0 +1,52 @@
+import { type Lang } from '../shared/i18n';
+import { type SiteConfig } from '../shared/site';
+import type { PageDO } from './page-do';
+/** `createWemaKake` に渡す設定。どの項目も省ける */
+export interface WemaKakeConfig {
+    /** 画面に出すサイトの名前（一覧の見出しと、タブの表示名）。既定は `wema-kake` */
+    siteName?: string;
+    /**
+     * 既定の言語。その端末で選んだ言語（Cookie）も、ブラウザの言語の設定も、対応する言語に
+     * 当たらないときに使う。既定は `en`
+     */
+    defaultLang?: Lang;
+    /** リモート MCP サーバー（`/mcp`）を有効にするか。`false` なら `/mcp` は 404 を返す。既定は `true` */
+    mcp?: boolean;
+    /**
+     * ページが 1 つもない環境で、一覧を最初に開いたときに、使い方の付箋を置いたページを作るか。
+     * 既定は `true`
+     */
+    firstPage?: boolean;
+}
+/** 既定の値を埋めた設定 */
+export type ResolvedConfig = SiteConfig & {
+    mcp: boolean;
+    firstPage: boolean;
+};
+/**
+ * 既定の値を埋める。不正な値は、Worker の起動時（モジュールの読み込み時）に例外にする。
+ * リクエストを受けてから気付く形にしない
+ */
+export declare function resolveConfig(config?: WemaKakeConfig): ResolvedConfig;
+/**
+ * Worker が受け取るバインディングと変数。**名前は固定**で、利用側の `wrangler.jsonc` に
+ * この名前で書く（template/wrangler.jsonc）
+ */
+export interface WemaKakeEnv {
+    /** ページごとの Durable Object。クラスは、利用側の入口が再 export する `PageDO` */
+    PAGE: DurableObjectNamespace<PageDO>;
+    /** 横断索引（ページの一覧、全文検索、リンク）。スキーマはパッケージの `migrations/` */
+    DB: D1Database;
+    /** 付箋に貼った画像 */
+    IMAGES: R2Bucket;
+    /** 画面のビルド済みのアセット（`assets.binding`） */
+    ASSETS: Fetcher;
+    /** Cloudflare Access のチームドメイン（`https://<team>.cloudflareaccess.com`） */
+    ACCESS_TEAM_DOMAIN?: string;
+    /** Access アプリケーションの AUD タグ */
+    ACCESS_AUD?: string;
+    /** このサイトのオリジン。付箋内の絶対 URL のリンクを、ページ間リンクとして拾うのに使う */
+    SITE_ORIGIN?: string;
+    /** ローカル開発で Access の代わりに使う email。ローカルのホスト名へのリクエストでだけ有効 */
+    DEV_USER_EMAIL?: string;
+}