@kamilio/wire 0.1.0

package/node_modules/provider-notion/src/notion-sync.ts

@@ -0,0 +1,968 @@
+import { createHash, randomUUID } from "node:crypto";
+
+import type { FetchedDocument, JsonObject, JsonValue, Source, UploadedDocument } from "wire-core";
+import { stableJsonCompact, stableJsonPretty } from "wire-core";
+import type { RuntimeCapabilities } from "wire-core";
+
+export type NotionRichText = JsonValue[][];
+export type NotionBlock = Readonly<{ type: string; content: string; properties: JsonObject; rich_text: NotionRichText; indent: number }>;
+export type NotionTree = Readonly<{ id: string; block: JsonObject; children: readonly NotionTree[] }>;
+export type NotionOperation = Readonly<{ pointer: JsonObject; path: readonly JsonValue[]; command: string; args: JsonValue }>;
+export type NotionSidecarBlock = Readonly<{ id: string; path: readonly number[]; type: string; hash: string; snapshot: JsonObject }>;
+export type NotionDiffSummary = Readonly<{ inserted: number; updated: number; deleted: number; moved: number }>;
+type UserMentions = Readonly<Record<string, string>>;
+
+function object(value: JsonValue): JsonObject { return value as JsonObject; }
+function array(value: JsonValue): JsonValue[] { return value as JsonValue[]; }
+function text(value: JsonValue): string { return value as string; }
+function notionAuthError(): Error { return new Error("notion cookie authentication is missing or expired. Run `wire notion login` once; other commands reuse saved cookies."); }
+function richTextText(value: JsonValue): string { return (value as JsonValue[][]).map((segment) => segment[0] as string).join(""); }
+function titleRichText(value: string): NotionRichText { return value === "" ? [] : [[value]]; }
+function pointer(id: string, spaceId: string): JsonObject { return { table: "block", id, spaceId }; }
+function formatBlockId(id: string): string { return id.length === 32 ? `${id.slice(0, 8)}-${id.slice(8, 12)}-${id.slice(12, 16)}-${id.slice(16, 20)}-${id.slice(20)}` : id; }
+function compact(value: JsonValue): string { return stableJsonCompact(value); }
+function hash(value: JsonValue): string { return `sha256:${createHash("sha256").update(compact(value)).digest("hex")}`; }
+function clone<T extends JsonValue>(value: T): T { return JSON.parse(JSON.stringify(value)) as T; }
+function escapeHtml(value: string): string { return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;"); }
+function unescapeHtml(value: string): string { return value.replace(/&quot;/g, "\"").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&"); }
+function escapeRegExp(value: string): string { return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); }
+function inlineCode(value: string): string {
+  const longest = Math.max(0, ...[...value.matchAll(/`+/g)].map((match) => match[0].length));
+  const ticks = "`".repeat(longest + 1);
+  return `${ticks}${value}${ticks}`;
+}
+
+function escapeInlineMarkdown(value: string): string {
+  return value.replace(/\\/g, "\\\\").replace(/\*/g, "\\*").replace(/~/g, "\\~").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+}
+
+function unescapeInlineMarkdown(value: string): string {
+  return value.replace(/\\([\\*~[\]()])/g, "$1");
+}
+
+function escaped(value: string, index: number): boolean {
+  let count = 0;
+  for (let position = index - 1; position >= 0 && value[position] === "\\"; position -= 1) count += 1;
+  return count % 2 === 1;
+}
+
+function closingDelimiter(value: string, start: number, delimiter: string): number {
+  for (let index = start; index < value.length; index += 1) if (!escaped(value, index) && value.startsWith(delimiter, index)) return index;
+  return -1;
+}
+
+function markdownLink(value: string): { label: string; url: string; length: number } | null {
+  if (!value.startsWith("[")) return null;
+  const labelEnd = closingDelimiter(value, 1, "]");
+  if (labelEnd === -1 || value[labelEnd + 1] !== "(") return null;
+  let depth = 0;
+  for (let index = labelEnd + 2; index < value.length; index += 1) {
+    if (escaped(value, index)) continue;
+    if (value[index] === "(") depth += 1;
+    else if (value[index] === ")") {
+      if (depth === 0) return { label: value.slice(1, labelEnd), url: value.slice(labelEnd + 2, index), length: index + 1 };
+      depth -= 1;
+    }
+  }
+  return null;
+}
+
+function normalizeMarks(marks: readonly JsonValue[]): JsonValue[] {
+  return marks.filter((mark) => Array.isArray(mark) && mark.length > 0 && array(mark)[0] !== "m").map((mark) => clone(mark)).sort((left, right) => compact(left).localeCompare(compact(right)));
+}
+
+function normalizeRichText(value: JsonValue): JsonValue {
+  const output: JsonValue[][] = [];
+  for (const raw of value as JsonValue[][]) {
+    const content = text(raw[0]!).replace(/\r\n?/g, "\n");
+    if (content === "") continue;
+    const marks = raw.length > 1 ? normalizeMarks(raw[1] as JsonValue[]) : [];
+    if (marks.length > 0 && content.match(/^ +/) !== null) output.push([content.match(/^ +/)![0]]);
+    const trimmedContent = marks.length === 0 ? content : content.replace(/^ +| +$/g, "");
+    const segment: JsonValue[] = marks.length === 0 ? [trimmedContent] : [trimmedContent, marks];
+    if (trimmedContent === "") continue;
+    const previous = output[output.length - 1];
+    if (previous !== undefined && compact(previous[1] ?? []) === compact(segment[1] ?? [])) previous[0] = `${previous[0] as string}${trimmedContent}`;
+    else output.push(segment);
+    if (marks.length > 0 && content.match(/ +$/) !== null) output.push([content.match(/ +$/)![0]]);
+  }
+  while (output.length > 0 && text(output[0]![0]!).trim() === "") output.shift();
+  while (output.length > 0 && text(output[output.length - 1]![0]!).trim() === "") output.pop();
+  if (output.length > 0) output[0]![0] = text(output[0]![0]!).replace(/^ +/, "");
+  if (output.length > 0) output[output.length - 1]![0] = text(output[output.length - 1]![0]!).replace(/ +$/, "");
+  return output;
+}
+
+function parseInline(value: string): NotionRichText {
+  const segments: NotionRichText = [];
+  let rest = value;
+  const push = (content: string, marks: JsonValue[] = []) => { if (content !== "") segments.push(marks.length === 0 ? [content] : [content, marks]); };
+  const pushMarked = (content: string, mark: JsonValue) => {
+    for (const segment of parseInline(content)) {
+      const marks = normalizeMarks([...((segment[1] as JsonValue[] | undefined) ?? []), mark]);
+      push(segment[0] as string, marks);
+    }
+  };
+  while (rest.length > 0) {
+    if (rest.startsWith("\\")) {
+      push(rest.length === 1 ? "\\" : rest[1]!);
+      rest = rest.slice(rest.length === 1 ? 1 : 2);
+      continue;
+    }
+    const link = markdownLink(rest);
+    if (link !== null) {
+      pushMarked(link.label, ["a", link.url]);
+      rest = rest.slice(link.length);
+      continue;
+    }
+    const dateSpan = /^<span data-notion-date="([^"]+)">(.*?)<\/span>/.exec(rest);
+    if (dateSpan !== null) {
+      pushMarked(dateSpan[2]!, ["d", JSON.parse(unescapeHtml(dateSpan[1]!)) as JsonValue]);
+      rest = rest.slice(dateSpan[0].length);
+      continue;
+    }
+    const equationSpan = /^<span data-notion-equation="([^"]+)">(.*?)<\/span>/.exec(rest);
+    if (equationSpan !== null) {
+      pushMarked(equationSpan[2]!, ["e", unescapeHtml(equationSpan[1]!)]);
+      rest = rest.slice(equationSpan[0].length);
+      continue;
+    }
+    const mentionSpan = /^<span data-notion-mention="([pu])" data-notion-id="([^"]+)"(?: data-notion-space-id="([^"]+)")?>(.*?)<\/span>/.exec(rest);
+    if (mentionSpan !== null) {
+      pushMarked(mentionSpan[4]!, mentionSpan[1] === "p" ? ["p", unescapeHtml(mentionSpan[2]!), unescapeHtml(mentionSpan[3]!)] : ["u", unescapeHtml(mentionSpan[2]!)]);
+      rest = rest.slice(mentionSpan[0].length);
+      continue;
+    }
+    if (rest.startsWith("**")) {
+      const end = closingDelimiter(rest, 2, "**");
+      if (end !== -1) {
+        pushMarked(rest.slice(2, end), ["b"]);
+        rest = rest.slice(end + 2);
+        continue;
+      }
+    }
+    if (rest.startsWith("*")) {
+      const end = closingDelimiter(rest, 1, "*");
+      if (end !== -1) {
+        pushMarked(rest.slice(1, end), ["i"]);
+        rest = rest.slice(end + 1);
+        continue;
+      }
+    }
+    if (rest.startsWith("~~")) {
+      const end = closingDelimiter(rest, 2, "~~");
+      if (end !== -1) {
+        pushMarked(rest.slice(2, end), ["s"]);
+        rest = rest.slice(end + 2);
+        continue;
+      }
+    }
+    const patterns = [
+      { match: /^`([^`]+)`/, mark: ["c"] as JsonValue },
+      { match: /^<u>(.*?)<\/u>/, mark: ["_"] as JsonValue },
+      { match: /^<span data-notion-color="([^"]+)">(.*?)<\/span>/, mark: null },
+    ];
+    let matched = false;
+    for (const pattern of patterns) {
+      const match = pattern.match.exec(rest);
+      if (match === null) continue;
+      if (pattern.mark !== null) {
+        const mark = pattern.mark as JsonValue[];
+        push(mark[0] === "c" ? match[1]! : unescapeInlineMarkdown(match[1]!), [pattern.mark]);
+      }
+      else push(unescapeInlineMarkdown(match[2]!), [["h", match[1]!]]);
+      rest = rest.slice(match[0].length);
+      matched = true;
+      break;
+    }
+    if (matched) continue;
+    const next = rest.search(/(\\|\*\*|\*|~~|`|\[|<u>|<span data-notion-(?:color|date|equation|mention)=)/);
+    if (next === -1) {
+      push(rest);
+      rest = "";
+    } else if (next === 0) {
+      push(rest[0]!);
+      rest = rest.slice(1);
+    } else {
+      push(rest.slice(0, next));
+      rest = rest.slice(next);
+    }
+  }
+  return segments;
+}
+
+function renderSegment(content: string, marks: readonly JsonValue[]): string {
+  let rendered = marks.some((raw) => (raw as JsonValue[])[0] === "c") ? content : escapeInlineMarkdown(content);
+  let link: string | null = null;
+  for (const raw of marks) {
+    const mark = raw as JsonValue[];
+    if (mark[0] === "c") rendered = inlineCode(rendered);
+    else if (mark[0] === "s") rendered = `~~${rendered}~~`;
+    else if (mark[0] === "i") rendered = `*${rendered}*`;
+    else if (mark[0] === "b") rendered = `**${rendered}**`;
+    else if (mark[0] === "a") link = mark[1] as string;
+    else if (mark[0] === "_") rendered = `<u>${rendered}</u>`;
+    else if (mark[0] === "h") rendered = `<span data-notion-color="${escapeHtml(mark[1] as string)}">${rendered}</span>`;
+    else if (mark[0] === "e") rendered = `<span data-notion-equation="${escapeHtml(mark[1] as string)}">${rendered}</span>`;
+    else if (mark[0] === "p" || mark[0] === "u") rendered = `<span data-notion-mention="${mark[0] as string}" data-notion-id="${escapeHtml(mark[1] as string)}"${mark[0] === "p" ? ` data-notion-space-id="${escapeHtml(mark[2] as string)}"` : ""}>${rendered}</span>`;
+    else if (mark[0] === "d") rendered = `<span data-notion-date="${escapeHtml(compact(mark[1]!))}">${rendered}</span>`;
+  }
+  return link === null ? rendered : `[${rendered}](${link})`;
+}
+
+function renderRichText(value: JsonValue): string {
+  return (normalizeRichText(value) as JsonValue[][]).map((segment) => renderSegment(text(segment[0]!), (segment[1] as JsonValue[] | undefined) ?? [])).join("");
+}
+
+function renderUserMentions(markdownText: string, mentions: UserMentions): string {
+  let output = markdownText;
+  for (const [userId, handle] of Object.entries(mentions)) {
+    output = output.replace(new RegExp(`<span data-notion-mention="u" data-notion-id="${escapeRegExp(escapeHtml(userId))}">(.*?)</span>`, "g"), (_match, content: string) => content.replaceAll("‣", `@${handle}`));
+  }
+  return output;
+}
+
+function hydrateUserMentions(markdownText: string, mentions: UserMentions): string {
+  let output = markdownText;
+  for (const [userId, handle] of Object.entries(mentions)) {
+    output = output.replace(new RegExp(`(?<![A-Za-z0-9_])@${escapeRegExp(handle)}(?![A-Za-z0-9_])`, "g"), `<span data-notion-mention="u" data-notion-id="${escapeHtml(userId)}">‣</span>`);
+  }
+  return output;
+}
+
+function baseUserMentions(base: JsonObject): UserMentions | undefined {
+  return base["user_mentions"] as UserMentions | undefined;
+}
+
+function notionData(pageId: string, markdown: string, tree: NotionTree, mentions: UserMentions | undefined): JsonObject {
+  return mentions === undefined ? { page_id: pageId, markdown, blocks: sidecarBlocksFromNotionTree(tree) } : { page_id: pageId, markdown, blocks: sidecarBlocksFromNotionTree(tree), user_mentions: mentions };
+}
+
+function lineIndent(line: string): number { return Math.floor(line.match(/^ */)![0].length / 2); }
+function stripIndent(line: string): string { return line.replace(/^ +/, ""); }
+
+function tableCellText(value: string): string {
+  return value.trim().replace(/(^|[^\\])<br>/g, "$1\n").replace(/\\<br>/g, "<br>");
+}
+
+function tableCells(line: string): readonly string[] {
+  const raw = line.replace(/^\||\|$/g, "");
+  const cells: string[] = [];
+  let current = "";
+  for (let index = 0; index < raw.length; index += 1) {
+    const character = raw[index]!;
+    if (character === "\\" && index + 1 < raw.length && ["\\", "|"].includes(raw[index + 1]!)) {
+      current += raw[index + 1]!;
+      index += 1;
+    } else if (character === "|") {
+      cells.push(tableCellText(current));
+      current = "";
+    } else {
+      current += character;
+    }
+  }
+  cells.push(tableCellText(current));
+  return cells;
+}
+
+function isTableSeparator(row: readonly string[]): boolean {
+  return row.every((cell) => /^:?-{3,}:?$/.test(cell.trim()));
+}
+
+function markdownBlockStart(stripped: string): boolean {
+  return /^(#{1,6})\s+|^[-*]\s+|^\d+\.\s+|^-\s+\[[ xX]\]\s+|^```|^---$|^!\[|^>|^\||^:::/.test(stripped);
+}
+
+function colonFenceBody(lines: readonly string[], index: number): Readonly<{ body: readonly string[]; index: number }> {
+  const body: string[] = [];
+  let depth = 0;
+  while (true) {
+    const stripped = stripIndent(lines[index]!);
+    if (stripped === ":::") {
+      if (depth === 0) return { body, index: index + 1 };
+      depth -= 1;
+    } else if (stripped.startsWith(":::") && !stripped.startsWith(":::checked ") && !stripped.startsWith(":::format ")) depth += 1;
+    body.push(lines[index]!);
+    index += 1;
+  }
+}
+
+function listContinuation(lines: readonly string[], index: number, baseIndent: number, indent: number, firstLine: string): Readonly<{ content: string; index: number }> {
+  const content = [firstLine];
+  while (index < lines.length && lines[index]!.trim() !== "" && baseIndent + lineIndent(lines[index]!) === indent + 1 && !markdownBlockStart(stripIndent(lines[index]!))) {
+    content.push(stripIndent(lines[index]!));
+    index += 1;
+  }
+  return { content: content.join("\n"), index };
+}
+
+function parseLines(lines: readonly string[], baseIndent = 0): NotionBlock[] {
+  const blocks: NotionBlock[] = [];
+  let index = 0;
+  while (index < lines.length) {
+    const line = lines[index]!;
+    if (line.trim() === "") { index += 1; continue; }
+    const indent = baseIndent + lineIndent(line);
+    const stripped = stripIndent(line);
+    const heading = /^(#{1,6})\s+(.+?)(?:\s+\{toggle\})?$/.exec(stripped);
+    if (heading !== null) {
+      if (heading[1]!.length > 3) throw new Error("lossless Markdown headings deeper than level 3 are not supported");
+      const type = ["header", "sub_header", "sub_sub_header"][heading[1]!.length - 1]!;
+      const properties: Record<string, JsonValue> = stripped.endsWith("{toggle}") ? { format: { toggleable: true } } : {};
+      blocks.push({ type, content: heading[2]!.replace(/\s+\{toggle\}$/, ""), properties, rich_text: parseInline(heading[2]!.replace(/\s+\{toggle\}$/, "")), indent });
+      index += 1;
+      continue;
+    }
+    const list = /^([-*])\s+(.+)$/.exec(stripped);
+    const numbered = /^\d+\.\s+(.+)$/.exec(stripped);
+    const todo = /^-\s+\[([ xX])\]\s+(.+)$/.exec(stripped);
+    if (todo !== null) {
+      index += 1;
+      const continued = listContinuation(lines, index, baseIndent, indent, todo[2]!);
+      index = continued.index;
+      blocks.push({ type: "to_do", content: continued.content, properties: { checked: todo[1]!.toLowerCase() === "x" }, rich_text: parseInline(continued.content), indent });
+      continue;
+    }
+    if (list !== null) {
+      index += 1;
+      const continued = listContinuation(lines, index, baseIndent, indent, list[2]!);
+      index = continued.index;
+      blocks.push({ type: "bulleted_list", content: continued.content, properties: {}, rich_text: parseInline(continued.content), indent });
+      continue;
+    }
+    if (numbered !== null) {
+      index += 1;
+      const continued = listContinuation(lines, index, baseIndent, indent, numbered[1]!);
+      index = continued.index;
+      blocks.push({ type: "numbered_list", content: continued.content, properties: {}, rich_text: parseInline(continued.content), indent });
+      continue;
+    }
+    if (stripped === "---") {
+      blocks.push({ type: "divider", content: "", properties: {}, rich_text: [], indent });
+      index += 1;
+      continue;
+    }
+    const image = stripped.startsWith("![") ? markdownLink(stripped.slice(1)) : null;
+    if (image !== null && image.length + 1 === stripped.length) {
+      blocks.push({ type: "image", content: "", properties: { alt_text: unescapeInlineMarkdown(image.label), source: decodeURI(image.url) }, rich_text: [], indent });
+      index += 1;
+      continue;
+    }
+    const codeFence = /^(`{3,})(.*)$/.exec(stripped);
+    if (codeFence !== null) {
+      const fence = codeFence[1]!;
+      const fenceIndent = line.match(/^ */)![0].length;
+      const language = codeFence[2]!.trim();
+      const body: string[] = [];
+      index += 1;
+      while (index < lines.length && !stripIndent(lines[index]!).startsWith(fence)) {
+        body.push(lines[index]!.slice(fenceIndent));
+        index += 1;
+      }
+      index += 1;
+      blocks.push({ type: "code", content: body.join("\n"), properties: { language: language === "" ? "Plain Text" : language }, rich_text: [], indent });
+      continue;
+    }
+    if (stripped.startsWith("> ")) {
+      blocks.push({ type: "quote", content: stripped.slice(2), properties: {}, rich_text: parseInline(stripped.slice(2)), indent });
+      index += 1;
+      continue;
+    }
+    if (stripped.startsWith("|")) {
+      const tableLines: string[] = [];
+      while (index < lines.length && stripIndent(lines[index]!).startsWith("|")) {
+        tableLines.push(stripIndent(lines[index]!));
+        index += 1;
+      }
+      const rows = tableLines.map((row) => tableCells(row)).filter((row) => !isTableSeparator(row));
+      const columnIds = rows[0]!.map((_, column) => `column_${column}`);
+      blocks.push({ type: "table", content: "", properties: { column_ids: columnIds, has_header: true, has_row_header: false }, rich_text: [], indent });
+      for (const row of rows) blocks.push({ type: "table_row", content: "", properties: { cells: Object.fromEntries(columnIds.map((column, columnIndex) => [column, parseInline(row[columnIndex] ?? "")])) }, rich_text: [], indent: indent + 1 });
+      continue;
+    }
+    if (stripped === ":::to-do") {
+      index += 1;
+      const checked = /^:::checked (true|false)$/.exec(stripIndent(lines[index]!))!;
+      blocks.push({ type: "to_do", content: "", properties: { checked: checked[1] === "true" }, rich_text: [], indent });
+      index += 1;
+      const fenced = colonFenceBody(lines, index);
+      index = fenced.index;
+      blocks.push(...parseLines(fenced.body, baseIndent));
+      continue;
+    }
+    if (stripped === ":::callout" || stripped === ":::toggle") {
+      const type = stripped.slice(3);
+      index += 1;
+      const title = stripIndent(lines[index]!);
+      blocks.push({ type, content: title, properties: {}, rich_text: parseInline(title), indent });
+      index += 1;
+      const fenced = colonFenceBody(lines, index);
+      index = fenced.index;
+      blocks.push(...parseLines(fenced.body, baseIndent));
+      continue;
+    }
+    if (stripped === ":::equation") {
+      index += 1;
+      const fenced = colonFenceBody(lines, index);
+      index = fenced.index;
+      const content = fenced.body.map((bodyLine) => stripIndent(bodyLine)).join("\n");
+      blocks.push({ type: "equation", content, properties: {}, rich_text: parseInline(content), indent });
+      continue;
+    }
+    if (stripped === ":::text") {
+      index += 1;
+      const fenced = colonFenceBody(lines, index);
+      index = fenced.index;
+      const content = fenced.body.map((bodyLine) => stripIndent(bodyLine)).join("\n");
+      blocks.push({ type: "text", content, properties: {}, rich_text: parseInline(content), indent });
+      continue;
+    }
+    if (stripped === ":::page") {
+      index += 1;
+      const title = stripIndent(lines[index]!);
+      blocks.push({ type: "page", content: title, properties: {}, rich_text: parseInline(title), indent });
+      index += 1;
+      const fenced = colonFenceBody(lines, index);
+      index = fenced.index;
+      blocks.push(...parseLines(fenced.body, baseIndent));
+      continue;
+    }
+    if (stripped === ":::columns" || stripped === ":::synced") {
+      const type = stripped === ":::columns" ? "column_list" : "transclusion_container";
+      index += 1;
+      blocks.push({ type, content: "", properties: {}, rich_text: [], indent });
+      const fenced = colonFenceBody(lines, index);
+      index = fenced.index;
+      blocks.push(...parseLines(fenced.body, baseIndent));
+      continue;
+    }
+    if (stripped === ":::column") {
+      index += 1;
+      const properties: Record<string, JsonValue> = {};
+      if (index < lines.length && lineIndent(lines[index]!) === lineIndent(line) && /^-?\d+(?:\.\d+)?$/.test(stripIndent(lines[index]!))) {
+        properties["format"] = { column_ratio: Number(stripIndent(lines[index]!)) };
+        index += 1;
+      }
+      blocks.push({ type: "column", content: "", properties, rich_text: [], indent });
+      const fenced = colonFenceBody(lines, index);
+      index = fenced.index;
+      blocks.push(...parseLines(fenced.body, baseIndent));
+      continue;
+    }
+    if (stripped === ":::notion-format") {
+      index += 1;
+      const fenced = colonFenceBody(lines, index);
+      index = fenced.index;
+      blocks.push(...parseLines(fenced.body.slice(1), baseIndent));
+      continue;
+    }
+    if (stripped === ":::notion-opaque") {
+      index += 1;
+      const fenced = colonFenceBody(lines, index);
+      index = fenced.index;
+      const snapshot = JSON.parse(fenced.body.map((bodyLine) => stripIndent(bodyLine)).join("\n")) as JsonObject;
+      blocks.push({ type: snapshot["type"] as string, content: "", properties: { notion_opaque: snapshot }, rich_text: [], indent });
+      continue;
+    }
+    const paragraph: string[] = [stripped];
+    index += 1;
+    while (index < lines.length && lines[index]!.trim() !== "" && !markdownBlockStart(stripIndent(lines[index]!))) {
+      paragraph.push(stripIndent(lines[index]!));
+      index += 1;
+    }
+    const content = paragraph.join("\n");
+    blocks.push({ type: "text", content, properties: {}, rich_text: parseInline(content), indent });
+  }
+  return blocks;
+}
+
+export function parseNotionMarkdown(markdown: string): readonly NotionBlock[] {
+  return parseLines(markdown.replace(/^\ufeff/, "").split("\n"));
+}
+
+function parserBlockToNotionBlock(block: NotionBlock, id: string, parentId: string, parentTable: string, spaceId: string, userId: string, currentTime: number): JsonObject {
+  const base: Record<string, JsonValue> = { id, type: block.type, space_id: spaceId, parent_id: parentId, parent_table: parentTable, alive: true, created_time: currentTime, created_by_table: "notion_user", created_by_id: userId, last_edited_time: currentTime, last_edited_by_table: "notion_user", last_edited_by_id: userId };
+  if (block.properties["notion_opaque"] !== undefined) return { ...object(block.properties["notion_opaque"]!), ...base };
+  if (block.type === "divider") return base;
+  if (block.type === "toggle") return { ...base, type: "text", properties: { title: block.rich_text }, format: { toggleable: true } };
+  if (block.type === "code") return { ...base, properties: { title: [[block.content]], language: [[block.properties["language"]!]] } };
+  if (block.type === "to_do") return { ...base, properties: { title: block.rich_text, checked: [[block.properties["checked"] === true ? "Yes" : "No"]] } };
+  if (block.type === "image") return { ...base, properties: { source: [[block.properties["source"]!]], alt_text: [[block.properties["alt_text"]!]], ...(block.properties["caption"] === undefined ? {} : { caption: block.properties["caption"]! }) } };
+  if (block.type === "table") return { ...base, properties: {}, format: { table_block_column_order: block.properties["column_ids"]!, table_block_column_header: block.properties["has_header"]!, table_block_row_header: block.properties["has_row_header"]! } };
+  if (block.type === "table_row") return { ...base, properties: block.properties["cells"]! };
+  if (block.type === "column_list" || block.type === "transclusion_container") return { ...base, properties: {} };
+  if (block.type === "column") return { ...base, properties: {}, ...(block.properties["format"] === undefined ? {} : { format: block.properties["format"]! }) };
+  if (block.type === "callout") return { ...base, properties: { title: block.rich_text }, ...(block.properties["format"] === undefined ? {} : { format: block.properties["format"]! }) };
+  if (["header", "sub_header", "sub_sub_header"].includes(block.type)) return { ...base, properties: { title: block.rich_text }, ...(block.properties["format"] === undefined ? {} : { format: block.properties["format"]! }) };
+  return { ...base, properties: { title: block.rich_text } };
+}
+
+export function buildNotionCreateOperations(blocks: readonly NotionBlock[], pageId: string, spaceId: string, userId: string, currentTime: number, createId: () => string = () => randomUUID()): Readonly<{ operations: readonly NotionOperation[]; topLevelIds: readonly string[] }> {
+  const operations: NotionOperation[] = [];
+  const topLevelIds: string[] = [];
+  const lastAtIndent = new Map<number, string>();
+  const lastChildByParent = new Map<string, string>();
+  let lastTableId: string | null = null;
+  for (const block of blocks) {
+    const blockId = formatBlockId(createId().replaceAll("-", ""));
+    let parentId = pageId;
+    if (block.type === "table_row") parentId = lastTableId!;
+    else if (block.indent > 0) {
+      const parent = lastAtIndent.get(block.indent - 1);
+      if (parent === undefined) throw new Error(`Indented Notion Markdown block has no parent at indent ${block.indent - 1}`);
+      parentId = parent;
+    }
+    if (block.type !== "table_row" && block.indent === 0) topLevelIds.push(blockId);
+    const parentTable = "block";
+    operations.push({ pointer: pointer(blockId, spaceId), path: [], command: "set", args: parserBlockToNotionBlock(block, blockId, parentId, parentTable, spaceId, userId, currentTime) });
+    const after = lastChildByParent.get(parentId);
+    operations.push({ pointer: pointer(parentId, spaceId), path: ["content"], command: after === undefined ? "listBefore" : "listAfter", args: after === undefined ? { id: blockId } : { id: blockId, after } });
+    lastChildByParent.set(parentId, blockId);
+    if (["bulleted_list", "numbered_list", "to_do", "quote", "callout", "toggle", "header", "sub_header", "sub_sub_header", "table", "page", "column_list", "column", "transclusion_container"].includes(block.type)) lastAtIndent.set(block.indent, blockId);
+    if (block.type === "table") lastTableId = blockId;
+  }
+  if (operations.length > 0) operations.push({ pointer: pointer(pageId, spaceId), path: ["last_edited_time"], command: "set", args: currentTime });
+  return { operations, topLevelIds };
+}
+
+function canonicalBlock(value: JsonObject, columnOrder?: readonly string[]): JsonObject {
+  const type = value["type"] as string;
+  if (type === "text" && object(value["format"] ?? {})["toggleable"] === true) return { type: "toggle", title: normalizeRichText(object(value["properties"]!)["title"]!) };
+  if (type === "code") return { type, title: normalizeRichText(object(value["properties"]!)["title"]!), language: object(value["properties"]!)["language"]! };
+  if (type === "to_do") return { type, title: normalizeRichText(object(value["properties"]!)["title"]!), checked: object(value["properties"]!)["checked"] ?? [["No"]] };
+  if (type === "table") return { type, column_count: (object(value["format"]!)["table_block_column_order"] as JsonValue[]).length };
+  if (type === "table_row") return { type, cells: columnOrder!.map((column) => normalizeRichText(object(value["properties"]!)[column]!)) };
+  if (type === "image") return { type, source: object(value["properties"]!)["source"]!, alt_text: object(value["properties"]!)["alt_text"]!, caption: object(value["properties"]!)["caption"] ?? null };
+  if (["divider", "column_list", "transclusion_container"].includes(type)) return { type };
+  if (type === "column") return { type, column_ratio: object(value["format"] ?? {})["column_ratio"] ?? null };
+  if (["header", "sub_header", "sub_sub_header"].includes(type)) return { type, title: normalizeRichText(object(value["properties"] ?? { title: [] })["title"] ?? []), toggleable: object(value["format"] ?? {})["toggleable"] === true };
+  return { type, title: normalizeRichText(object(value["properties"] ?? { title: [] })["title"] ?? []) };
+}
+
+function canonicalParserBlock(block: NotionBlock, columnOrder?: readonly string[]): JsonObject {
+  if (block.properties["notion_opaque"] !== undefined) return canonicalBlock(object(block.properties["notion_opaque"]!), columnOrder);
+  if (block.type === "header" || block.type === "sub_header" || block.type === "sub_sub_header") return { type: block.type, title: normalizeRichText(block.rich_text), toggleable: object(block.properties["format"] ?? {})["toggleable"] === true };
+  if (block.type === "text" || block.type === "bulleted_list" || block.type === "numbered_list" || block.type === "quote" || block.type === "callout" || block.type === "toggle") return { type: block.type, title: normalizeRichText(block.rich_text) };
+  if (block.type === "code") return { type: "code", title: normalizeRichText([[block.content]]), language: [[block.properties["language"]!]] };
+  if (block.type === "to_do") return { type: "to_do", title: normalizeRichText(block.rich_text), checked: [[block.properties["checked"] === true ? "Yes" : "No"]] };
+  if (block.type === "table") return { type: "table", column_count: (block.properties["column_ids"] as JsonValue[]).length };
+  if (block.type === "table_row") return { type: "table_row", cells: columnOrder!.map((column) => normalizeRichText(object(block.properties["cells"]!)[column]!)) };
+  if (block.type === "image") return { type: "image", source: [[block.properties["source"]!]], alt_text: [[block.properties["alt_text"]!]], caption: block.properties["caption"] ?? null };
+  if (block.type === "column") return { type: "column", column_ratio: object(block.properties["format"] ?? {})["column_ratio"] ?? null };
+  if (block.type === "column_list" || block.type === "transclusion_container") return { type: block.type };
+  return { type: block.type };
+}
+
+export function notionBlockContentHash(block: NotionBlock | JsonObject, columnOrder?: readonly string[]): string {
+  return hash("rich_text" in block ? canonicalParserBlock(block as NotionBlock, columnOrder) : canonicalBlock(block as JsonObject, columnOrder));
+}
+
+export function sidecarBlocksFromNotionTree(tree: NotionTree): readonly NotionSidecarBlock[] {
+  const blocks: NotionSidecarBlock[] = [];
+  const walk = (node: NotionTree, path: readonly number[], columnOrder?: readonly string[]) => {
+    const type = node.block["type"] as string;
+    const nextColumnOrder = type === "table" ? object(node.block["format"]!)["table_block_column_order"] as readonly string[] : columnOrder;
+    blocks.push({ id: node.id, path, type, hash: notionBlockContentHash(node.block, columnOrder), snapshot: canonicalBlock(node.block, columnOrder) });
+    node.children.forEach((child, index) => walk(child, [...path, index], nextColumnOrder));
+  };
+  walk(tree, []);
+  return blocks;
+}
+
+type LocalNotionNode = { block: NotionBlock; children: LocalNotionNode[] };
+
+function localTree(blocks: readonly NotionBlock[]): LocalNotionNode[] {
+  const roots: LocalNotionNode[] = [];
+  const stack: Array<{ indent: number; children: LocalNotionNode[] }> = [{ indent: -1, children: roots }];
+  for (const block of blocks) {
+    const node: LocalNotionNode = { block, children: [] };
+    while (stack[stack.length - 1]!.indent >= block.indent) stack.pop();
+    stack[stack.length - 1]!.children.push(node);
+    if (["bulleted_list", "numbered_list", "to_do", "quote", "callout", "toggle", "header", "sub_header", "sub_sub_header", "table", "page", "column_list", "column", "transclusion_container"].includes(block.type)) stack.push({ indent: block.indent, children: node.children });
+  }
+  return roots;
+}
+
+function outputNode(node: LocalNotionNode, remoteNode: NotionTree | undefined, parentId: string, remote: Readonly<{ spaceId: string; userId: string }>, currentTime: number): NotionTree {
+  const id = remoteNode?.id ?? formatBlockId(randomUUID().replaceAll("-", ""));
+  return { id, block: parserBlockToNotionBlock(node.block, id, parentId, "block", remote.spaceId, remote.userId, currentTime), children: node.children.map((child, index) => outputNode(child, remoteNode?.children[index], id, remote, currentTime)) };
+}
+
+function emitUpdates(remote: JsonObject, local: NotionBlock, blockId: string, spaceId: string): NotionOperation[] {
+  const operations: NotionOperation[] = [];
+  const remoteType = remote["type"] === "text" && object(remote["format"] ?? {})["toggleable"] === true ? "toggle" : remote["type"] as string;
+  const localType = local.type === "toggle" ? "text" : local.type;
+  const typeChanged = remoteType !== local.type;
+  if (typeChanged) operations.push({ pointer: pointer(blockId, spaceId), path: ["type"], command: "set", args: localType });
+  const args = parserBlockToNotionBlock(local, blockId, remote["parent_id"] as string ?? "", "block", spaceId, "", 0);
+  const remoteProperties = object(remote["properties"] ?? {});
+  const nextProperties = object(args["properties"] ?? {});
+  if (typeChanged) {
+    if (compact(remoteProperties) !== compact(nextProperties)) operations.push({ pointer: pointer(blockId, spaceId), path: ["properties"], command: "set", args: nextProperties });
+  } else {
+    for (const key of Object.keys(nextProperties)) if (compact(remoteProperties[key] ?? null) !== compact(nextProperties[key]!)) operations.push({ pointer: pointer(blockId, spaceId), path: ["properties", key], command: "set", args: nextProperties[key]! });
+  }
+  const nextFormat = object(args["format"] ?? {});
+  if ((typeChanged || args["format"] !== undefined || remote["format"] !== undefined) && compact(remote["format"] ?? {}) !== compact(nextFormat)) operations.push({ pointer: pointer(blockId, spaceId), path: ["format"], command: "set", args: nextFormat });
+  return operations;
+}
+
+function flattenLocalSubtree(node: LocalNotionNode): readonly NotionBlock[] {
+  const blocks: NotionBlock[] = [];
+  const walk = (value: LocalNotionNode, indent: number) => {
+    blocks.push({ ...value.block, indent });
+    for (const child of value.children) walk(child, indent + 1);
+  };
+  walk(node, 0);
+  return blocks;
+}
+
+function buildNotionCreateSubtreeOperations(node: LocalNotionNode, parentId: string, ambient: Readonly<{ spaceId: string; userId: string; currentTime: number }>): Readonly<{ operations: readonly NotionOperation[]; topLevelIds: readonly string[] }> {
+  return buildNotionCreateOperations(flattenLocalSubtree(node), parentId, ambient.spaceId, ambient.userId, ambient.currentTime);
+}
+
+function positionRootCreateOperations(operations: readonly NotionOperation[], parentId: string, spaceId: string, previousId: string | undefined): readonly NotionOperation[] {
+  return operations.map((operation) => {
+    if (operation.pointer["id"] === parentId && operation.pointer["spaceId"] === spaceId && operation.path.length === 1 && operation.path[0] === "content") return { ...operation, command: previousId === undefined ? "listBefore" : "listAfter", args: previousId === undefined ? { id: object(operation.args)["id"]! } : { id: object(operation.args)["id"]!, after: previousId } };
+    return operation;
+  });
+}
+
+function localSubtreeSize(node: LocalNotionNode): number {
+  return 1 + node.children.reduce((total, child) => total + localSubtreeSize(child), 0);
+}
+
+function remoteSubtreeSize(node: NotionTree): number {
+  return 1 + node.children.reduce((total, child) => total + remoteSubtreeSize(child), 0);
+}
+
+function deleteRemoteSubtreeOperations(node: NotionTree, parentId: string, spaceId: string): readonly NotionOperation[] {
+  return [
+    ...node.children.flatMap((child) => deleteRemoteSubtreeOperations(child, node.id, spaceId)),
+    { pointer: pointer(node.id, spaceId), path: ["alive"], command: "set", args: false },
+    { pointer: pointer(parentId, spaceId), path: ["content"], command: "listRemove", args: { id: node.id } },
+  ];
+}
+
+function diffNotionChildLists(remoteParent: NotionTree, localChildren: readonly LocalNotionNode[], ambient: Readonly<{ spaceId: string; userId: string; currentTime: number }>, summary: { inserted: number; updated: number; deleted: number; moved: number }, columnOrder?: readonly string[]): NotionOperation[] {
+  const operations: NotionOperation[] = [];
+  const remoteChildren = [...remoteParent.children];
+  const nextColumnOrder = remoteParent.block["type"] === "table" ? object(remoteParent.block["format"]!)["table_block_column_order"] as readonly string[] : columnOrder;
+  const remoteHash = (index: number) => notionBlockContentHash(remoteChildren[index]!.block, nextColumnOrder);
+  const localHash = (index: number) => notionBlockContentHash(localChildren[index]!.block, nextColumnOrder);
+  let remoteIndex = 0;
+  let localIndex = 0;
+  let previousId: string | undefined;
+  while (remoteIndex < remoteChildren.length && localIndex < localChildren.length) {
+    const remoteNode = remoteChildren[remoteIndex]!;
+    const localNode = localChildren[localIndex]!;
+    if (remoteHash(remoteIndex) === localHash(localIndex)) {
+      operations.push(...diffNotionChildLists(remoteNode, localNode.children, ambient, summary, nextColumnOrder));
+      previousId = remoteNode.id;
+      remoteIndex += 1;
+      localIndex += 1;
+      continue;
+    }
+    const remoteNodeAppearsLaterLocally = localChildren.some((child, index) => index > localIndex && notionBlockContentHash(child.block, nextColumnOrder) === remoteHash(remoteIndex));
+    const movedRemoteIndex = remoteNodeAppearsLaterLocally ? remoteChildren.findIndex((child, index) => index > remoteIndex && notionBlockContentHash(child.block, nextColumnOrder) === localHash(localIndex)) : -1;
+    if (movedRemoteIndex !== -1) {
+      const moved = remoteChildren[movedRemoteIndex]!;
+      operations.push({ pointer: pointer(remoteParent.id, ambient.spaceId), path: ["content"], command: previousId === undefined ? "listBefore" : "listAfter", args: previousId === undefined ? { id: moved.id } : { id: moved.id, after: previousId } });
+      remoteChildren.splice(movedRemoteIndex, 1);
+      remoteChildren.splice(remoteIndex, 0, moved);
+      summary.moved += 1;
+      continue;
+    }
+    if (localIndex + 1 < localChildren.length && remoteHash(remoteIndex) === localHash(localIndex + 1)) {
+      const built = buildNotionCreateSubtreeOperations(localNode, remoteParent.id, ambient);
+      operations.push(...positionRootCreateOperations(built.operations, remoteParent.id, ambient.spaceId, previousId));
+      summary.inserted += localSubtreeSize(localNode);
+      previousId = built.topLevelIds[0]!;
+      localIndex += 1;
+      continue;
+    }
+    if (remoteIndex + 1 < remoteChildren.length && remoteHash(remoteIndex + 1) === localHash(localIndex)) {
+      operations.push(...deleteRemoteSubtreeOperations(remoteNode, remoteParent.id, ambient.spaceId));
+      summary.deleted += remoteSubtreeSize(remoteNode);
+      remoteIndex += 1;
+      continue;
+    }
+    const before = operations.length;
+    operations.push(...emitUpdates(remoteNode.block, localNode.block, remoteNode.id, ambient.spaceId));
+    operations.push(...diffNotionChildLists(remoteNode, localNode.children, ambient, summary, nextColumnOrder));
+    if (operations.length > before) summary.updated += 1;
+    previousId = remoteNode.id;
+    remoteIndex += 1;
+    localIndex += 1;
+  }
+  while (localIndex < localChildren.length) {
+    const localNode = localChildren[localIndex]!;
+    const built = buildNotionCreateSubtreeOperations(localNode, remoteParent.id, ambient);
+    operations.push(...positionRootCreateOperations(built.operations, remoteParent.id, ambient.spaceId, previousId ?? remoteChildren[remoteChildren.length - 1]?.id));
+    summary.inserted += localSubtreeSize(localNode);
+    previousId = built.topLevelIds[0]!;
+    localIndex += 1;
+  }
+  while (remoteIndex < remoteChildren.length) {
+    const child = remoteChildren[remoteIndex]!;
+    operations.push(...deleteRemoteSubtreeOperations(child, remoteParent.id, ambient.spaceId));
+    summary.deleted += remoteSubtreeSize(child);
+    remoteIndex += 1;
+  }
+  return operations;
+}
+
+export function diffNotionBlockTrees(remoteTree: NotionTree, localBlocks: readonly NotionBlock[], _sidecarBlocks: readonly NotionSidecarBlock[], ambient: Readonly<{ spaceId: string; userId: string; currentTime: number }>): Readonly<{ operations: readonly NotionOperation[]; summary: NotionDiffSummary }> {
+  const summary = { inserted: 0, updated: 0, deleted: 0, moved: 0 };
+  const locals = localTree(localBlocks);
+  const operations = diffNotionChildLists(remoteTree, locals, ambient, summary);
+  if (operations.length > 0 && !operations.some((operation) => operation.path.length === 1 && operation.path[0] === "last_edited_time")) operations.push({ pointer: pointer(remoteTree.id, ambient.spaceId), path: ["last_edited_time"], command: "set", args: ambient.currentTime });
+  return { operations, summary };
+}
+
+function renderNode(tree: NotionTree, indent: number, parentType = ""): string[] {
+  const prefix = "  ".repeat(indent);
+  const type = tree.block["type"] === "text" && object(tree.block["format"] ?? {})["toggleable"] === true ? "toggle" : tree.block["type"] as string;
+  const properties = object(tree.block["properties"] ?? {});
+  const title = properties["title"] === undefined ? "" : renderRichText(properties["title"]!);
+  const format = object(tree.block["format"] ?? {});
+  if (["header", "sub_header", "sub_sub_header"].includes(type)) {
+    const marker = type === "header" ? "#" : type === "sub_header" ? "##" : "###";
+    return [`${prefix}${marker} ${title}${format["toggleable"] === true ? " {toggle}" : ""}`, ...tree.children.flatMap((child) => renderNode(child, indent + 1, type))];
+  }
+  if (type === "bulleted_list") {
+    const lines = title.split("\n");
+    return [`${prefix}- ${lines[0]}`, ...lines.slice(1).map((line) => `${prefix}  ${line}`), ...tree.children.flatMap((child) => renderNode(child, indent + 1, type))];
+  }
+  if (type === "numbered_list") {
+    const lines = title.split("\n");
+    return [`${prefix}1. ${lines[0]}`, ...lines.slice(1).map((line) => `${prefix}   ${line}`), ...tree.children.flatMap((child) => renderNode(child, indent + 1, type))];
+  }
+  if (type === "to_do") {
+    const checked = richTextText(properties["checked"] ?? [["No"]]) === "Yes";
+    if (title === "") return [`${prefix}:::to-do`, `${prefix}:::checked ${JSON.stringify(checked)}`, prefix, ...tree.children.flatMap((child) => renderNode(child, indent + 1, type)), `${prefix}:::`];
+    const lines = title.split("\n");
+    return [`${prefix}- [${checked ? "x" : " "}] ${lines[0]}`, ...lines.slice(1).map((line) => `${prefix}  ${line}`), ...tree.children.flatMap((child) => renderNode(child, indent + 1, type))];
+  }
+  if (type === "quote") return [`${prefix}> ${title}`, ...tree.children.flatMap((child) => renderNode(child, indent + 1, type))];
+  if (type === "divider") return [`${prefix}---`];
+  if (type === "code") {
+    const code = richTextText(properties["title"]!);
+    const longest = Math.max(0, ...[...code.matchAll(/`+/g)].map((match) => match[0].length));
+    const fence = "`".repeat(Math.max(3, longest + 1));
+    const language = richTextText(properties["language"]!).replace("Plain Text", "");
+    return [`${prefix}${fence}${language}`, ...code.split("\n").map((line) => `${prefix}${line}`), `${prefix}${fence}`];
+  }
+  if (type === "image") return [`${prefix}![${escapeInlineMarkdown(richTextText(properties["alt_text"]!))}](${encodeURI(richTextText(properties["source"]!))})`];
+  if (type === "equation") return [`${prefix}:::equation`, ...title.split("\n").map((line) => `${prefix}${line}`), `${prefix}:::`];
+  if (type === "page") return [`${prefix}:::page`, `${prefix}${title}`, ...tree.children.flatMap((child) => renderNode(child, indent + 1, type)), `${prefix}:::`];
+  if (type === "column_list") return [`${prefix}:::columns`, ...tree.children.flatMap((child) => renderNode(child, indent + 1, type)), `${prefix}:::`];
+  if (type === "column") return [`${prefix}:::column`, ...(format["column_ratio"] === undefined ? [] : [`${prefix}${format["column_ratio"] as number}`]), ...tree.children.flatMap((child) => renderNode(child, indent + 1, type)), `${prefix}:::`];
+  if (type === "transclusion_container") return [`${prefix}:::synced`, ...tree.children.flatMap((child) => renderNode(child, indent + 1, type)), `${prefix}:::`];
+  if (type === "callout" || type === "toggle") return [`${prefix}:::${type}`, `${prefix}${title}`, ...tree.children.flatMap((child) => renderNode(child, indent + 1, type)), `${prefix}:::`];
+  if (type === "table") {
+    const columns = object(tree.block["format"]!)["table_block_column_order"] as string[];
+    const rows = tree.children.map((child) => columns.map((column) => renderRichText(object(child.block["properties"]!)[column]!).replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/<br>/g, "\\<br>").replace(/\n/g, "<br>")));
+    return rows.flatMap((row, index) => index === 0 ? [`${prefix}| ${row.join(" | ")} |`, `${prefix}| ${columns.map(() => "---").join(" | ")} |`] : [`${prefix}| ${row.join(" | ")} |`]);
+  }
+  if (type !== "text") {
+    const opaque = [`${prefix}:::notion-opaque`, ...stableJsonPretty(tree.block).split("\n").map((line) => `${prefix}${line}`), `${prefix}:::`];
+    if (tree.block["format"] !== undefined) return [`${prefix}:::notion-format`, `${prefix}:::format ${compact(tree.block["format"]!)}`, ...opaque, `${prefix}:::`];
+    return opaque;
+  }
+  if (title === "") return [`${prefix}:::text`, `${prefix}:::`];
+  if (["bulleted_list", "numbered_list", "to_do"].includes(parentType)) return [`${prefix}:::text`, ...title.split("\n").map((line) => `${prefix}${line}`), `${prefix}:::`];
+  return [`${prefix}${title}`];
+}
+
+export function renderNotionTreeToMarkdown(tree: NotionTree, mentions?: UserMentions): string {
+  const title = renderRichText(object(tree.block["properties"]!)["title"]!);
+  const compactTypes = new Set(["bulleted_list", "numbered_list", "to_do"]);
+  const body = tree.children.flatMap((child, index) => [
+    ...(index === 0 || (tree.children[index - 1]!.block["type"] === child.block["type"] && compactTypes.has(child.block["type"] as string)) ? [] : [""]),
+    ...renderNode(child, 0),
+  ]);
+  const markdown = [`# ${title}`, ...body.length === 0 ? [] : ["", ...body]].join("\n").trim();
+  return mentions === undefined ? markdown : renderUserMentions(markdown, mentions);
+}
+
+async function notionPost(runtime: RuntimeCapabilities, path: string, cookie: string, body: JsonObject, headers: HeadersInit): Promise<JsonObject> {
+  const response = await runtime.http.request(`https://www.notion.so/api/v3/${path}`, { method: "POST", headers: { cookie, "content-type": "application/json", ...headers }, body: JSON.stringify(body) });
+  if (!response.ok) throw new Error(`POST ${path} failed: ${response.status} ${await response.text()}`);
+  return await response.json() as JsonObject;
+}
+
+async function fetchTree(runtime: RuntimeCapabilities, url: string, source: Source): Promise<Readonly<{ tree: NotionTree; userId: string; spaceId: string; cookie: string; headers: HeadersInit }>> {
+  const cookies = await runtime.cookies.loadSaved("notion");
+  if (cookies === null) throw notionAuthError();
+  const cookie = cookies.map((value) => `${value.name}=${value.value}`).join("; ");
+  const userId = cookies.find((value) => value.name === "notion_user_id")!.value;
+  const csrf = cookies.find((value) => value.name === "csrf")?.value;
+  await runtime.http.request(url, { headers: { cookie } });
+  const spaces = await notionPost(runtime, "getSpaces", cookie, {}, {});
+  const spaceView = object(object(spaces[userId]!)["space_view"]!);
+  const spaceId = object(spaceView[Object.keys(spaceView)[0]!]!)["spaceId"] as string;
+  const pageId = formatBlockId(source.identifier);
+  const headers = { "x-notion-active-user-header": userId, "x-notion-space-id": spaceId, referer: url, ...(csrf === undefined ? {} : { "x-csrf-token": csrf }) };
+  const blocks = new Map<string, JsonObject>();
+  let stack: JsonValue[] = [];
+  let chunkNumber = 0;
+  do {
+    const data = await notionPost(runtime, "loadCachedPageChunkV2", cookie, { page: { id: pageId }, limit: 100, cursor: { stack }, chunkNumber, verticalColumns: false }, headers);
+    for (const [blockId, wrapper] of Object.entries(object(object(data["recordMap"]!)["block"]!))) blocks.set(blockId, object(object(object(wrapper)["value"]!)["value"]!));
+    const cursors = data["cursors"] as readonly JsonObject[];
+    stack = cursors.length === 0 ? [] : cursors[0]!["stack"] as JsonValue[];
+    chunkNumber += 1;
+  } while (stack.length > 0);
+  while (true) {
+    const missing = new Set<string>();
+    const pending = [pageId];
+    const visited = new Set<string>();
+    while (pending.length > 0) {
+      const idValue = pending.pop()!;
+      if (visited.has(idValue)) continue;
+      visited.add(idValue);
+      const block = blocks.get(idValue);
+      if (block === undefined) {
+        missing.add(idValue);
+        continue;
+      }
+      if (idValue !== pageId && block["type"] === "page") continue;
+      for (const child of block["content"] as readonly string[] | undefined ?? []) pending.push(child);
+    }
+    if (missing.size === 0) break;
+    const missingIds = [...missing];
+    const data = await notionPost(runtime, "getRecordValues", cookie, { requests: missingIds.map((idValue) => ({ table: "block", id: idValue })) }, headers);
+    for (const [index, result] of (data["results"] as readonly JsonObject[]).entries()) {
+      const block = object(result["value"]!);
+      blocks.set((block["id"] as string | undefined) ?? missingIds[index]!, block);
+    }
+  }
+  const build = (idValue: string): NotionTree => {
+    const block = blocks.get(idValue)!;
+    if (idValue !== pageId && block["type"] === "page") return { id: idValue, block, children: [] };
+    return { id: idValue, block, children: (block["content"] as readonly string[] | undefined ?? []).filter((child) => blocks.get(child)?.["alive"] !== false).map(build) };
+  };
+  return { tree: build(pageId), userId, spaceId, cookie, headers };
+}
+
+export async function fetchNotionDocument(runtime: RuntimeCapabilities, url: string, source: Source): Promise<FetchedDocument> {
+  const { tree } = await fetchTree(runtime, url, source);
+  const markdown = renderNotionTreeToMarkdown(tree);
+  return { title: markdown.split("\n")[0]!.replace(/^# */, ""), markdown, data: notionData(source.identifier, markdown, tree, undefined) };
+}
+
+export async function uploadNotionDocument(runtime: RuntimeCapabilities, markdown: string, _markdownPath: string): Promise<UploadedDocument> {
+  const split = splitTitle(markdown);
+  if (split.title === "") throw new Error("Markdown document requires a first heading");
+  const cookies = await runtime.cookies.loadSaved("notion");
+  if (cookies === null) throw notionAuthError();
+  const cookie = cookies.map((value) => `${value.name}=${value.value}`).join("; ");
+  const userId = cookies.find((value) => value.name === "notion_user_id")!.value;
+  const csrf = cookies.find((value) => value.name === "csrf")?.value;
+  const spaces = await notionPost(runtime, "getSpaces", cookie, {}, {});
+  const spaceView = object(object(spaces[userId]!)["space_view"]!);
+  const spaceId = object(spaceView[Object.keys(spaceView)[0]!]!)["spaceId"] as string;
+  const pageId = randomUUID();
+  const compactPageId = pageId.replaceAll("-", "");
+  const currentTime = runtime.clock.now().getTime();
+  const headers = { "x-notion-active-user-header": userId, "x-notion-space-id": spaceId, referer: `https://www.notion.so/${compactPageId}`, ...(csrf === undefined ? {} : { "x-csrf-token": csrf }) };
+  const pageOperation: NotionOperation = {
+    pointer: pointer(pageId, spaceId),
+    path: [],
+    command: "set",
+    args: {
+      id: pageId,
+      type: "page",
+      properties: { title: titleRichText(split.title) },
+      space_id: spaceId,
+      created_time: currentTime,
+      created_by_table: "notion_user",
+      created_by_id: userId,
+      last_edited_time: currentTime,
+      last_edited_by_table: "notion_user",
+      last_edited_by_id: userId,
+      parent_id: spaceId,
+      parent_table: "space",
+      alive: true,
+      permissions: [{ type: "user_permission", role: "editor", user_id: userId }],
+    },
+  };
+  const localBlocks = parseNotionMarkdown(split.body);
+  const operations = [pageOperation, ...buildNotionCreateOperations(localBlocks, pageId, spaceId, userId, currentTime).operations];
+  await notionPost(runtime, "saveTransactionsFanout", cookie, { requestId: randomUUID(), transactions: [{ id: randomUUID(), spaceId, operations }] }, headers);
+  const pageTree: NotionTree = {
+    id: pageId,
+    block: pageOperation.args as JsonObject,
+    children: localTree(localBlocks).map((node) => outputNode(node, undefined, pageId, { spaceId, userId }, currentTime)),
+  };
+  const output = renderNotionTreeToMarkdown(pageTree);
+  return { url: `https://www.notion.so/${compactPageId}`, title: split.title, markdown: output, data: notionData(compactPageId, output, pageTree, undefined) };
+}
+
+function splitTitle(markdown: string): Readonly<{ title: string; body: string }> {
+  const lines = markdown.replace(/^\ufeff/, "").split("\n");
+  const first = lines[0]!.trimStart();
+  if (first === "#") return { title: "", body: lines.slice(1).join("\n") };
+  if (/^#{1,6}\s+\S/.test(first)) return { title: first.replace(/^#+\s+/, "").trim(), body: lines.slice(1).join("\n") };
+  return { title: "", body: markdown };
+}
+
+export async function synchronizeNotionDocument(runtime: RuntimeCapabilities, url: string, base: JsonValue, markdown: string, _markdownPath: string): Promise<FetchedDocument> {
+  const source: Source = { service: "notion", identifier: /([a-f0-9]{32})/.exec(url)![1]!, type: "document" };
+  const remote = await fetchTree(runtime, url, source);
+  const baseObject = object(base);
+  const mentions = baseUserMentions(baseObject);
+  const currentMarkdown = renderNotionTreeToMarkdown(remote.tree, mentions);
+  const baseMarkdown = baseObject["markdown"] as string | undefined;
+  let split = splitTitle(markdown);
+  const currentSplit = splitTitle(currentMarkdown);
+  const baseSplit = baseMarkdown === undefined ? undefined : splitTitle(baseMarkdown);
+  let fieldMerged = false;
+  if (baseSplit !== undefined) {
+    const localTitleChanged = baseSplit.title !== split.title;
+    const remoteTitleChanged = baseSplit.title !== currentSplit.title;
+    const localBodyChanged = baseSplit.body !== split.body;
+    const remoteBodyChanged = baseSplit.body !== currentSplit.body;
+    if (localTitleChanged && remoteTitleChanged && split.title !== currentSplit.title) throw new Error("Markdown and Notion changed since last sync");
+    if (localBodyChanged && remoteBodyChanged && split.body !== currentSplit.body) throw new Error("Markdown and Notion changed since last sync");
+    if ((localTitleChanged || localBodyChanged) && (remoteTitleChanged || remoteBodyChanged)) {
+      split = { title: localTitleChanged ? split.title : currentSplit.title, body: localBodyChanged ? split.body : currentSplit.body };
+      fieldMerged = true;
+    }
+  }
+  const targetMarkdown = split.title === "" ? split.body : `# ${split.title}\n${split.body}`;
+  if (mentions === undefined && split.body === currentSplit.body && (baseSplit === undefined || baseSplit.body === currentSplit.body)) {
+    if (baseSplit !== undefined) {
+      const localTitleChanged = baseSplit.title !== split.title;
+      const remoteTitleChanged = baseSplit.title !== currentSplit.title;
+      if (!localTitleChanged && remoteTitleChanged) return { title: currentSplit.title, markdown: currentMarkdown, data: notionData(remote.tree.id, currentMarkdown, remote.tree, mentions) };
+      if (localTitleChanged && remoteTitleChanged && split.title !== currentSplit.title) throw new Error("Markdown and Notion changed since last sync");
+      if (localTitleChanged && remoteTitleChanged) return { title: currentSplit.title, markdown: currentMarkdown, data: notionData(remote.tree.id, currentMarkdown, remote.tree, mentions) };
+    }
+    const titleRich = split.title === "" ? object(remote.tree.block["properties"]!)["title"]! as NotionRichText : titleRichText(split.title);
+    const titleChanged = split.title !== "" && compact(object(remote.tree.block["properties"]!)["title"]!) !== compact(titleRich);
+    if (titleChanged) await notionPost(runtime, "saveTransactionsFanout", remote.cookie, { requestId: randomUUID(), transactions: [{ id: randomUUID(), spaceId: remote.spaceId, operations: [{ pointer: pointer(remote.tree.id, remote.spaceId), path: ["properties", "title"], command: "set", args: titleRich }, { pointer: pointer(remote.tree.id, remote.spaceId), path: ["last_edited_time"], command: "set", args: runtime.clock.now().getTime() }] }] }, remote.headers);
+    const outputTree: NotionTree = { ...remote.tree, block: { ...remote.tree.block, properties: { ...object(remote.tree.block["properties"]!), title: titleRich } } };
+    const output = renderNotionTreeToMarkdown(outputTree, mentions);
+    return { title: output.split("\n")[0]!.replace(/^# */, ""), markdown: output, data: notionData(remote.tree.id, output, outputTree, mentions) };
+  }
+  if (baseMarkdown !== undefined) {
+    const localChanged = baseMarkdown !== targetMarkdown;
+    const remoteChanged = baseMarkdown !== currentMarkdown;
+    if (!localChanged && remoteChanged) return { title: currentMarkdown.split("\n")[0]!.replace(/^# */, ""), markdown: currentMarkdown, data: notionData(remote.tree.id, currentMarkdown, remote.tree, mentions) };
+    if (localChanged && remoteChanged && targetMarkdown !== currentMarkdown && !fieldMerged) throw new Error("Markdown and Notion changed since last sync");
+    if (localChanged && remoteChanged && targetMarkdown === currentMarkdown) return { title: currentMarkdown.split("\n")[0]!.replace(/^# */, ""), markdown: currentMarkdown, data: notionData(remote.tree.id, currentMarkdown, remote.tree, mentions) };
+  }
+  const localBody = mentions === undefined ? split.body : hydrateUserMentions(split.body, mentions);
+  const localBlocks = parseNotionMarkdown(localBody);
+  const ambient = { spaceId: remote.spaceId, userId: remote.userId, currentTime: runtime.clock.now().getTime() };
+  const diffResult = diffNotionBlockTrees(remote.tree, localBlocks, sidecarBlocksFromNotionTree(remote.tree), ambient);
+  const operations = [...diffResult.operations];
+  const titleRich = split.title === "" ? object(remote.tree.block["properties"]!)["title"]! as NotionRichText : titleRichText(split.title);
+  if (split.title !== "" && compact(object(remote.tree.block["properties"]!)["title"]!) !== compact(titleRich)) operations.unshift({ pointer: pointer(remote.tree.id, remote.spaceId), path: ["properties", "title"], command: "set", args: titleRich });
+  if (operations.length > 0) await notionPost(runtime, "saveTransactionsFanout", remote.cookie, { requestId: randomUUID(), transactions: [{ id: randomUUID(), spaceId: remote.spaceId, operations }] }, remote.headers);
+  const outputTree: NotionTree = { id: remote.tree.id, block: { ...remote.tree.block, properties: { ...object(remote.tree.block["properties"]!), title: titleRich } }, children: localTree(localBlocks).map((node, index) => outputNode(node, remote.tree.children[index], remote.tree.id, remote, ambient.currentTime)) };
+  const output = renderNotionTreeToMarkdown(outputTree, mentions);
+  return { title: output.split("\n")[0]!.replace(/^# */, ""), markdown: output, data: notionData(remote.tree.id, output, outputTree, mentions) };
+}