@kamilio/wire 0.1.2 → 0.1.4

package/node_modules/provider-google-docs/src/google-docs.ts

@@ -1,4 +1,5 @@
 import { defineService } from "wire-core";
+import { inflateRawSync } from "node:zlib";
 import type { FetchedDocument, JsonObject, JsonValue, RuntimeCapabilities, Source } from "wire-core";
 
 async function cookieHeader(runtime: RuntimeCapabilities): Promise<string> {
@@ -17,7 +18,7 @@ function filenameTitle(value: string, label: string): string {
   const bare = /filename=([^;]+)/i.exec(value);
   if (encoded === null && quoted === null && bare === null) throw new Error(`Google ${label} did not include a filename`);
   const filename = encoded !== null ? decodeURIComponent(encoded[1]!) : quoted !== null ? quoted[1]! : bare![1]!.trim();
-  return filename.replace(/\.(csv|html|md|txt|xlsx)$/i, "");
+  return filename.replace(/\.(csv|html|md|pptx|txt|xlsx)$/i, "");
 }
 
 async function googleExport(runtime: RuntimeCapabilities, url: string, label: string): Promise<Readonly<{ title: string; text: string }>> {
@@ -29,6 +30,15 @@ async function googleExport(runtime: RuntimeCapabilities, url: string, label: st
   return Object.freeze({ title: filenameTitle(disposition, label), text: await response.text() });
 }
 
+async function googleExportBytes(runtime: RuntimeCapabilities, url: string, label: string): Promise<Readonly<{ title: string; bytes: Uint8Array }>> {
+  const response = await runtime.http.request(url, { headers: { Cookie: await cookieHeader(runtime) } });
+  if (response.status === 401 || response.status === 403) throw cookieAuthenticationError();
+  if (!response.ok) throw new Error(`Google ${label} failed: HTTP ${response.status}`);
+  const disposition = response.headers.get("content-disposition");
+  if (disposition === null) throw cookieAuthenticationError();
+  return Object.freeze({ title: filenameTitle(disposition, label), bytes: new Uint8Array(await response.arrayBuffer()) });
+}
+
 async function googleText(runtime: RuntimeCapabilities, url: string, label: string): Promise<string> {
   const response = await runtime.http.request(url, { headers: { Cookie: await cookieHeader(runtime) } });
   if (response.status === 401 || response.status === 403) throw cookieAuthenticationError();
@@ -174,6 +184,268 @@ function documentTab(source: Source): string | null {
   return typeof tab === "string" && tab !== "" ? tab : null;
 }
 
+type XmlChild = XmlNode | string;
+type XmlNode = Readonly<{ name: string; attributes: ReadonlyMap<string, string>; children: readonly XmlChild[] }>;
+
+function decodeXml(value: string): string {
+  return value.replace(/&(#x[0-9a-fA-F]+|#\d+|amp|lt|gt|quot|apos);/g, (_match, entity: string) => {
+    if (entity.startsWith("#x")) return String.fromCodePoint(Number.parseInt(entity.slice(2), 16));
+    if (entity.startsWith("#")) return String.fromCodePoint(Number.parseInt(entity.slice(1), 10));
+    if (entity === "amp") return "&";
+    if (entity === "lt") return "<";
+    if (entity === "gt") return ">";
+    if (entity === "quot") return "\"";
+    if (entity === "apos") return "'";
+    throw new Error(`PPTX XML unknown entity: ${entity}`);
+  });
+}
+
+function xmlTagEnd(xml: string, start: number): number {
+  let quote: string | null = null;
+  for (let index = start + 1; index < xml.length; index += 1) {
+    const char = xml[index]!;
+    if (quote === null && char === ">") return index;
+    if (quote === null && (char === "\"" || char === "'")) quote = char;
+    else if (quote === char) quote = null;
+  }
+  throw new Error("PPTX XML tag is unterminated");
+}
+
+function parseAttributes(value: string): ReadonlyMap<string, string> {
+  const attributes = new Map<string, string>();
+  let index = 0;
+  while (index < value.length) {
+    while (index < value.length && /\s/.test(value[index]!)) index += 1;
+    if (index >= value.length) break;
+    const nameStart = index;
+    while (index < value.length && !/[\s=]/.test(value[index]!)) index += 1;
+    const name = value.slice(nameStart, index);
+    while (index < value.length && /\s/.test(value[index]!)) index += 1;
+    if (value[index] !== "=") throw new Error(`PPTX XML attribute ${name} is invalid`);
+    index += 1;
+    while (index < value.length && /\s/.test(value[index]!)) index += 1;
+    const quote = value[index]!;
+    if (quote !== "\"" && quote !== "'") throw new Error(`PPTX XML attribute ${name} is unquoted`);
+    index += 1;
+    const textStart = index;
+    while (index < value.length && value[index] !== quote) index += 1;
+    attributes.set(name, decodeXml(value.slice(textStart, index)));
+    index += 1;
+  }
+  return attributes;
+}
+
+function parseXml(xml: string): XmlNode {
+  const root: { name: string; attributes: ReadonlyMap<string, string>; children: XmlChild[] } = { name: "#document", attributes: new Map(), children: [] };
+  const stack: { name: string; attributes: ReadonlyMap<string, string>; children: XmlChild[] }[] = [root];
+  let index = 0;
+  while (index < xml.length) {
+    if (xml.startsWith("<?", index)) {
+      index = xml.indexOf("?>", index) + 2;
+    } else if (xml.startsWith("<!--", index)) {
+      index = xml.indexOf("-->", index) + 3;
+    } else if (xml.startsWith("<![CDATA[", index)) {
+      const end = xml.indexOf("]]>", index);
+      stack[stack.length - 1]!.children.push(xml.slice(index + 9, end));
+      index = end + 3;
+    } else if (xml.startsWith("</", index)) {
+      const end = xmlTagEnd(xml, index);
+      const name = xml.slice(index + 2, end).trim();
+      const node = stack.pop()!;
+      if (node.name !== name) throw new Error(`PPTX XML closing tag mismatch: ${name}`);
+      stack[stack.length - 1]!.children.push(Object.freeze({ name: node.name, attributes: node.attributes, children: Object.freeze(node.children) }));
+      index = end + 1;
+    } else if (xml[index] === "<") {
+      const end = xmlTagEnd(xml, index);
+      const raw = xml.slice(index + 1, end).trim();
+      const selfClosing = raw.endsWith("/");
+      const tag = selfClosing ? raw.slice(0, -1).trimEnd() : raw;
+      const nameEnd = tag.search(/\s/);
+      const name = nameEnd === -1 ? tag : tag.slice(0, nameEnd);
+      const attributes = parseAttributes(nameEnd === -1 ? "" : tag.slice(nameEnd + 1));
+      if (selfClosing) stack[stack.length - 1]!.children.push(Object.freeze({ name, attributes, children: Object.freeze([]) }));
+      else stack.push({ name, attributes, children: [] });
+      index = end + 1;
+    } else {
+      const end = xml.indexOf("<", index);
+      const text = decodeXml(xml.slice(index, end === -1 ? xml.length : end));
+      if (text !== "") stack[stack.length - 1]!.children.push(text);
+      index = end === -1 ? xml.length : end;
+    }
+  }
+  if (stack.length !== 1) throw new Error("PPTX XML document is unclosed");
+  return Object.freeze({ name: root.name, attributes: root.attributes, children: Object.freeze(root.children) });
+}
+
+function isXmlNode(value: XmlChild): value is XmlNode {
+  return typeof value !== "string";
+}
+
+function xmlChildren(node: XmlNode, name: string): readonly XmlNode[] {
+  return node.children.filter(isXmlNode).filter((child) => child.name === name);
+}
+
+function xmlDescendants(node: XmlNode, name: string): readonly XmlNode[] {
+  return node.children.filter(isXmlNode).flatMap((child) => child.name === name ? [child, ...xmlDescendants(child, name)] : xmlDescendants(child, name));
+}
+
+function xmlText(node: XmlNode): string {
+  return node.children.map((child) => typeof child === "string" ? child : xmlText(child)).join("");
+}
+
+function xmlAttribute(node: XmlNode, name: string): string {
+  const value = node.attributes.get(name);
+  if (value === undefined) throw new Error(`PPTX XML missing ${name}`);
+  return value;
+}
+
+function zipEndOfCentralDirectory(bytes: Uint8Array): number {
+  for (let index = bytes.length - 22; index >= Math.max(0, bytes.length - 65557); index -= 1) {
+    if (bytes[index] === 0x50 && bytes[index + 1] === 0x4b && bytes[index + 2] === 0x05 && bytes[index + 3] === 0x06) return index;
+  }
+  throw new Error("PPTX ZIP missing central directory");
+}
+
+function unzipFiles(bytes: Uint8Array): ReadonlyMap<string, Uint8Array> {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const end = zipEndOfCentralDirectory(bytes);
+  const totalEntries = view.getUint16(end + 10, true);
+  let centralOffset = view.getUint32(end + 16, true);
+  const files = new Map<string, Uint8Array>();
+  const decoder = new TextDecoder();
+  for (let entryIndex = 0; entryIndex < totalEntries; entryIndex += 1) {
+    if (view.getUint32(centralOffset, true) !== 0x02014b50) throw new Error("PPTX ZIP central directory entry is invalid");
+    const method = view.getUint16(centralOffset + 10, true);
+    const compressedSize = view.getUint32(centralOffset + 20, true);
+    const nameLength = view.getUint16(centralOffset + 28, true);
+    const extraLength = view.getUint16(centralOffset + 30, true);
+    const commentLength = view.getUint16(centralOffset + 32, true);
+    const localOffset = view.getUint32(centralOffset + 42, true);
+    const name = decoder.decode(bytes.subarray(centralOffset + 46, centralOffset + 46 + nameLength));
+    if (view.getUint32(localOffset, true) !== 0x04034b50) throw new Error("PPTX ZIP local file entry is invalid");
+    const localNameLength = view.getUint16(localOffset + 26, true);
+    const localExtraLength = view.getUint16(localOffset + 28, true);
+    const dataStart = localOffset + 30 + localNameLength + localExtraLength;
+    const compressed = bytes.subarray(dataStart, dataStart + compressedSize);
+    if (method === 0) files.set(name, compressed);
+    else if (method === 8) files.set(name, inflateRawSync(compressed));
+    else throw new Error(`PPTX ZIP compression method is unsupported: ${method}`);
+    centralOffset += 46 + nameLength + extraLength + commentLength;
+  }
+  return files;
+}
+
+function zipText(files: ReadonlyMap<string, Uint8Array>, name: string): string {
+  const bytes = files.get(name);
+  if (bytes === undefined) throw new Error(`PPTX missing ${name}`);
+  return new TextDecoder().decode(bytes);
+}
+
+function relationshipTargets(xml: string): ReadonlyMap<string, string> {
+  const relationships = new Map<string, string>();
+  for (const relationship of xmlDescendants(parseXml(xml), "Relationship")) relationships.set(xmlAttribute(relationship, "Id"), xmlAttribute(relationship, "Target"));
+  return relationships;
+}
+
+function resolvePartPath(basePath: string, target: string): string {
+  const parts = basePath.split("/");
+  parts.pop();
+  for (const segment of target.split("/")) {
+    if (segment === "..") parts.pop();
+    else if (segment !== ".") parts.push(segment);
+  }
+  return parts.join("/");
+}
+
+function slidePartPaths(files: ReadonlyMap<string, Uint8Array>): readonly string[] {
+  const presentation = parseXml(zipText(files, "ppt/presentation.xml"));
+  const relationships = relationshipTargets(zipText(files, "ppt/_rels/presentation.xml.rels"));
+  const slides = xmlDescendants(presentation, "p:sldId");
+  if (slides.length === 0) throw new Error("PPTX presentation has no slides");
+  return slides.map((slide) => {
+    const id = xmlAttribute(slide, "r:id");
+    const target = relationships.get(id);
+    if (target === undefined) throw new Error(`PPTX presentation missing slide relationship ${id}`);
+    return resolvePartPath("ppt/presentation.xml", target);
+  });
+}
+
+function slideRelationshipsPath(slidePath: string): string {
+  const parts = slidePath.split("/");
+  const filename = parts.pop();
+  if (filename === undefined) throw new Error("PPTX slide path is invalid");
+  parts.push("_rels", `${filename}.rels`);
+  return parts.join("/");
+}
+
+function markdownSpan(value: string, left: string, right: string): string {
+  const leading = /^[ \t]*/.exec(value)![0];
+  const trailing = /[ \t]*$/.exec(value)![0];
+  const core = value.slice(leading.length, value.length - trailing.length);
+  return core === "" ? value : `${leading}${left}${core}${right}${trailing}`;
+}
+
+function linkMarkdown(value: string, target: string): string {
+  const leading = /^[ \t]*/.exec(value)![0];
+  const trailing = /[ \t]*$/.exec(value)![0];
+  const core = value.slice(leading.length, value.length - trailing.length);
+  return core === "" ? value : `${leading}[${core.replace(/[[\]\\]/g, "\\$&")}](${target.replace(/\)/g, "%29")})${trailing}`;
+}
+
+function formattedRunMarkdown(run: XmlNode, relationships: ReadonlyMap<string, string>): string {
+  const text = xmlDescendants(run, "a:t").map(xmlText).join("");
+  const runProperties = xmlChildren(run, "a:rPr")[0];
+  if (runProperties === undefined) return text;
+  const hyperlink = xmlDescendants(runProperties, "a:hlinkClick")[0];
+  let markdown = text;
+  if (runProperties.attributes.get("u") !== undefined && runProperties.attributes.get("u") !== "none" && hyperlink === undefined) markdown = markdownSpan(markdown, "<u>", "</u>");
+  if (runProperties.attributes.get("strike") !== undefined && runProperties.attributes.get("strike") !== "noStrike") markdown = markdownSpan(markdown, "~~", "~~");
+  if (runProperties.attributes.get("b") === "1" && runProperties.attributes.get("i") === "1") markdown = markdownSpan(markdown, "***", "***");
+  else if (runProperties.attributes.get("b") === "1") markdown = markdownSpan(markdown, "**", "**");
+  else if (runProperties.attributes.get("i") === "1") markdown = markdownSpan(markdown, "_", "_");
+  if (hyperlink !== undefined) {
+    const id = xmlAttribute(hyperlink, "r:id");
+    const target = relationships.get(id);
+    if (target === undefined) throw new Error(`PPTX slide missing hyperlink relationship ${id}`);
+    markdown = linkMarkdown(markdown, target);
+  }
+  return markdown;
+}
+
+function paragraphMarkdown(paragraph: XmlNode, relationships: ReadonlyMap<string, string>): Readonly<{ text: string; list: "bullet" | "number" | null; level: number }> {
+  const pPr = xmlChildren(paragraph, "a:pPr")[0];
+  const list = pPr === undefined || xmlChildren(pPr, "a:buNone").length !== 0 ? null : xmlChildren(pPr, "a:buAutoNum").length !== 0 ? "number" : xmlChildren(pPr, "a:buChar").length !== 0 ? "bullet" : null;
+  const levelValue = pPr === undefined ? undefined : pPr.attributes.get("lvl");
+  const level = levelValue === undefined ? 0 : Number(levelValue);
+  const pieces: string[] = [];
+  for (const child of paragraph.children.filter(isXmlNode)) {
+    if (child.name === "a:br") pieces.push("\n");
+    if (child.name === "a:r" || child.name === "a:fld") pieces.push(formattedRunMarkdown(child, relationships));
+  }
+  return Object.freeze({ text: pieces.join("").replace(/[ \t]+$/gm, ""), list, level });
+}
+
+function slideMarkdown(slide: XmlNode, relationships: ReadonlyMap<string, string>): string {
+  const paragraphs = xmlDescendants(slide, "a:p").map((paragraph) => paragraphMarkdown(paragraph, relationships)).filter((paragraph) => paragraph.text.trim() !== "");
+  const lines = paragraphs.map((paragraph, index) => {
+    if (index === 0 && paragraph.list === null) return `## ${paragraph.text.trim()}`;
+    if (paragraph.list === "bullet") return `${"  ".repeat(paragraph.level)}- ${paragraph.text.trim()}`;
+    if (paragraph.list === "number") return `${"  ".repeat(paragraph.level)}1. ${paragraph.text.trim()}`;
+    return paragraph.text.trim();
+  });
+  return lines.join("\n").replace(/\n{3,}/g, "\n\n");
+}
+
+function slidesMarkdown(bytes: Uint8Array): string {
+  const files = unzipFiles(bytes);
+  const slides = slidePartPaths(files).map((slidePath) => {
+    const slide = parseXml(zipText(files, slidePath));
+    const relationships = relationshipTargets(zipText(files, slideRelationshipsPath(slidePath)));
+    return slideMarkdown(slide, relationships);
+  });
+  return `${slides.join("\n\n---\n\n")}\n`;
+}
+
 function urlParam(url: URL, name: string): string | null {
   const query = url.searchParams.get(name);
   const hash = new URLSearchParams(url.hash.slice(1)).get(name);
@@ -284,20 +556,60 @@ function docMarkdownEqual(left: string, right: string): boolean {
   return comparableDocMarkdown(left) === comparableDocMarkdown(right);
 }
 
-function textEdit(base: string, local: string): Readonly<{ base: string; local: string; before: string; after: string }> {
+type TextEdit = Readonly<{ base: string; local: string; before: string; localBefore: string; after: string; localAfter: string }>;
+type MarkdownSpan = Readonly<{ start: number; end: number }>;
+
+function textEdit(base: string, local: string): TextEdit {
   let start = 0;
   while (start < base.length && start < local.length && base[start] === local[start]) start += 1;
   for (let window = 80; window >= 10; window -= 10) {
     for (let baseEnd = start; baseEnd <= Math.min(base.length - window, start + 2000); baseEnd += 1) {
       const anchor = base.slice(baseEnd, baseEnd + window);
       const localEnd = local.indexOf(anchor, start);
-      if (localEnd !== -1 && localEnd <= start + 2000) return Object.freeze({ base: base.slice(start, baseEnd), local: local.slice(start, localEnd), before: base.slice(0, start), after: base.slice(baseEnd) });
+      if (localEnd !== -1 && localEnd <= start + 2000) return Object.freeze({ base: base.slice(start, baseEnd), local: local.slice(start, localEnd), before: base.slice(0, start), localBefore: "", after: base.slice(baseEnd), localAfter: local.slice(localEnd) });
     }
   }
   let baseEnd = base.length;
   let localEnd = local.length;
   while (baseEnd > start && localEnd > start && base[baseEnd - 1] === local[localEnd - 1]) { baseEnd -= 1; localEnd -= 1; }
-  return Object.freeze({ base: base.slice(start, baseEnd), local: local.slice(start, localEnd), before: base.slice(0, start), after: base.slice(baseEnd) });
+  return Object.freeze({ base: base.slice(start, baseEnd), local: local.slice(start, localEnd), before: base.slice(0, start), localBefore: "", after: base.slice(baseEnd), localAfter: local.slice(localEnd) });
+}
+
+function textEdits(base: string, local: string): readonly TextEdit[] {
+  const edits: TextEdit[] = [];
+  let basePrefix = "";
+  let localPrefix = "";
+  let baseRest = base;
+  let localRest = local;
+  while (baseRest !== localRest) {
+    const edit = textEdit(baseRest, localRest);
+    const before = `${basePrefix}${edit.before}`;
+    const localBefore = `${localPrefix}${edit.before}`;
+    edits.push(Object.freeze({ ...edit, before, localBefore }));
+    basePrefix = base.slice(0, base.length - edit.after.length);
+    localPrefix = local.slice(0, local.length - edit.localAfter.length);
+    baseRest = edit.after;
+    localRest = edit.localAfter;
+  }
+  return edits;
+}
+
+function inlineMarkdownSpans(value: string): readonly MarkdownSpan[] {
+  const spans: MarkdownSpan[] = [];
+  for (const pattern of [/\[[^\]\n]+\]\([^)]+\)/g, /!\[[^\]\n]*\]\([^)]+\)/g, /`[^`\n]+`/g, /~~[^~\n]+~~/g, /\*\*[^*\n]+\*\*/g, /\*[^*\n]+\*/g, /(^|[^\w])__[^_\n]+__(?=[^\w]|$)/g, /(^|[^\w])_[^_\n]+_(?=[^\w]|$)/g, /<((?:https?|mailto):[^>\s]+)>/g, /<\/?(?:u|sup|sub|mark|span)(?:\s+[^>]*)?>/gi]) {
+    let match = pattern.exec(value);
+    while (match !== null) {
+      spans.push(Object.freeze({ start: match.index, end: match.index + match[0]!.length }));
+      match = pattern.exec(value);
+    }
+  }
+  return spans;
+}
+
+function editTouchesMarkdownSpan(before: string, value: string, edited: string): boolean {
+  const start = before.length;
+  const end = start + edited.length;
+  return inlineMarkdownSpans(value).some((span) => start === end ? start > span.start && start < span.end : start < span.end && end > span.start);
 }
 
 function context(value: string, side: "before" | "after", length: number): string {
@@ -368,15 +680,16 @@ function docTextRange(text: string, edit: Readonly<{ base: string; before: strin
 }
 
 async function uploadDocText(runtime: RuntimeCapabilities, documentId: string, key: string | null, tab: string, baseMarkdown: string, localMarkdown: string): Promise<void> {
-  const edit = textEdit(baseMarkdown, localMarkdown);
+  const edits = textEdits(baseMarkdown, localMarkdown);
+  if (edits.some((edit) => editTouchesMarkdownSpan(edit.before, baseMarkdown, edit.base) || editTouchesMarkdownSpan(edit.localBefore, localMarkdown, edit.local))) throw new Error("Google Docs sync cannot preserve formatting in edited text");
   const editUrl = docEditUrl(documentId, key, tab);
   const session = docSession(await googleText(runtime, editUrl, "Docs editor"));
-  const range = docTextRange(session.text, edit);
+  const ranges = edits.map((edit) => ({ edit, range: docTextRange(session.text, edit) })).sort((left, right) => right.range.start - left.range.start);
   const sid = runtime.clock.now().getTime().toString(16).padStart(16, "0").slice(-16);
-  const commands = [
+  const commands = ranges.flatMap(({ edit, range }) => [
     ...(range.start === range.end ? [] : [{ ty: "ds", si: range.start + 1, ei: range.end }]),
     ...(edit.local === "" ? [] : [{ ty: "is", ibi: range.start + 1, s: markdownText(edit.local) }]),
-  ];
+  ]);
   const params = new URLSearchParams({ id: documentId, sid, vc: "1", c: "1", w: "1", flr: "0", smv: "2147483647", smb: "[2147483647, AAE=]", token: session.token, ouid: session.ouid, includes_info_params: "true", cros_files: "false", nded: "false", tab });
   const body = new URLSearchParams({ rev: String(session.revision), bundles: JSON.stringify([{ commands, sid, reqId: 0 }]) });
   const response = await runtime.http.request(`https://docs.google.com/document/d/${encodeURIComponent(documentId)}/save?${params}`, { method: "POST", headers: { Cookie: await cookieHeader(runtime), "content-type": "application/x-www-form-urlencoded;charset=UTF-8", origin: "https://docs.google.com", referer: editUrl }, body: body.toString() });
@@ -401,6 +714,12 @@ async function fetchGoogleDocument(runtime: RuntimeCapabilities, source: Source)
     exportUrl = `https://docs.google.com/spreadsheets/d/${encodeURIComponent(documentId)}/export?${query}`;
     label = "Sheets CSV export";
     sheetGid = gid;
+  } else if (source.type === "presentation") {
+    const query = new URLSearchParams({ format: "pptx" });
+    const key = resourceKey(source);
+    if (key !== null) query.set("resourcekey", key);
+    exportUrl = `https://docs.google.com/presentation/d/${encodeURIComponent(documentId)}/export?${query}`;
+    label = "Slides PPTX export";
   } else {
     const query = new URLSearchParams({ format: "md" });
     const key = resourceKey(source);
@@ -410,6 +729,11 @@ async function fetchGoogleDocument(runtime: RuntimeCapabilities, source: Source)
     exportUrl = `https://docs.google.com/document/d/${encodeURIComponent(documentId)}/export?${query}`;
     label = "Docs Markdown export";
   }
+  if (source.type === "presentation") {
+    const exported = await googleExportBytes(runtime, exportUrl, label);
+    const markdown = slidesMarkdown(exported.bytes);
+    return Object.freeze({ title: exported.title, markdown, data: { document_id: documentId, title: exported.title, output_path: null, sheet_gid: sheetGid, markdown, rows: null, presentation: true } });
+  }
   const exported = await googleExport(runtime, exportUrl, label);
   const rows = source["sheet_gid"] === undefined ? null : parseCsv(exported.text);
   const markdown = rows === null ? exported.text : rowsMarkdown(rows);
@@ -419,6 +743,13 @@ async function fetchGoogleDocument(runtime: RuntimeCapabilities, source: Source)
 
 async function synchronizeGoogleDocument(runtime: RuntimeCapabilities, _url: string, source: Source, base: JsonValue, markdown: string): Promise<FetchedDocument> {
   const remote = await fetchGoogleDocument(runtime, source);
+  if (source.type === "presentation") {
+    const baseMarkdown = objectValue(base)["markdown"];
+    if (typeof baseMarkdown !== "string") throw new Error("Google sync base must include markdown");
+    if (markdown === baseMarkdown || markdown === remote.markdown) return remote;
+    if (remote.markdown === baseMarkdown) throw new Error("Google Slides sync is download-only. Revert local edits or use `wire download <url>` for a fresh copy.");
+    throw new Error("Google Slides changed remotely and locally. Resolve the conflict in Google Slides or the local Markdown file before syncing again.");
+  }
   const baseMarkdown = objectValue(base)["markdown"];
   const label = source["sheet_gid"] === undefined ? "Google Docs" : "Google Sheets";
   if (typeof baseMarkdown !== "string") throw new Error("Google sync base must include markdown");
@@ -448,12 +779,13 @@ async function synchronizeGoogleDocument(runtime: RuntimeCapabilities, _url: str
 
 export const googleDocsService = defineService<RuntimeCapabilities>({
   name: "google-docs",
-  matches: (url) => url.hostname === "docs.google.com" && /^\/(document|spreadsheets)(?:\/u\/\d+)?\/d\/[^/]+(?:\/.*)?$/.test(url.pathname),
+  matches: (url) => url.hostname === "docs.google.com" && /^\/(document|presentation|spreadsheets)(?:\/u\/\d+)?\/d\/[^/]+(?:\/.*)?$/.test(url.pathname),
   parse: (url) => {
-    const match = /^\/(document|spreadsheets)(?:\/u\/\d+)?\/d\/([^/]+)(?:\/.*)?$/.exec(url.pathname)!;
+    const match = /^\/(document|presentation|spreadsheets)(?:\/u\/\d+)?\/d\/([^/]+)(?:\/.*)?$/.exec(url.pathname)!;
     const documentId = match[2]!;
     const key = urlParam(url, "resourcekey");
     const resource_key = key === null || key === "" ? {} : { resource_key: key };
+    if (match[1] === "presentation") return Object.freeze({ service: "google-docs", identifier: documentId, type: "presentation", ...resource_key });
     if (match[1] === "spreadsheets") {
       const queryGid = url.searchParams.get("gid");
       const hashGid = new URLSearchParams(url.hash.slice(1)).get("gid");

package/node_modules/provider-google-docs/src/google-forms.ts

@@ -0,0 +1,179 @@
+import { defineService } from "wire-core";
+import type { FetchedDocument, JsonObject, JsonValue, RuntimeCapabilities, Source } from "wire-core";
+
+type FormAnswer = Readonly<{ questionId: string; text: string }>;
+
+function formId(url: URL): string {
+  return /^\/forms(?:\/u\/\d+)?\/d\/([^/]+)(?:\/.*)?$/.exec(url.pathname)![1]!;
+}
+
+function formUrl(id: string): string {
+  return `https://docs.google.com/forms/d/${encodeURIComponent(id)}/edit`;
+}
+
+function formsAuthError(): Error {
+  return new Error("Google Forms API authentication is missing or expired. Set GOOGLE_FORMS_TOKEN_FILE to an OAuth token with Forms scopes, then retry.");
+}
+
+function apiDisabledError(body: JsonObject): Error | null {
+  const error = body["error"] as JsonObject | undefined;
+  if (error === undefined) return null;
+  const details = Array.isArray(error["details"]) ? error["details"] as readonly JsonObject[] : [];
+  const serviceDisabled = details.find((detail) => {
+    const metadata = detail["metadata"] as JsonObject | undefined;
+    return metadata !== undefined && metadata["service"] === "forms.googleapis.com";
+  });
+  if (serviceDisabled === undefined) return null;
+  const metadata = serviceDisabled["metadata"] as JsonObject;
+  const activationUrl = typeof metadata["activationUrl"] === "string" ? metadata["activationUrl"] : typeof metadata["containerInfo"] === "string" ? `https://console.developers.google.com/apis/api/forms.googleapis.com/overview?project=${metadata["containerInfo"]}` : "https://console.developers.google.com/apis/api/forms.googleapis.com/overview";
+  return new Error(`Google Forms API is disabled. Enable it at ${activationUrl} then retry.`);
+}
+
+async function formsJson(runtime: RuntimeCapabilities, url: string, label: string): Promise<JsonObject> {
+  const token = await runtime.googleFormsTokens.load();
+  const response = await runtime.http.request(url, { headers: { authorization: `Bearer ${token.token}` } });
+  const text = await response.text();
+  const body = text === "" ? {} : JSON.parse(text) as JsonObject;
+  if (response.status === 401) throw formsAuthError();
+  if (!response.ok) {
+    const disabled = apiDisabledError(body);
+    if (disabled !== null) throw disabled;
+    const error = body["error"] as JsonObject | undefined;
+    const message = typeof error?.["message"] === "string" ? error["message"] : text;
+    if (response.status === 403 && /insufficient authentication scopes/i.test(message)) throw new Error("Google Forms API token is missing required scopes. Regenerate GOOGLE_FORMS_TOKEN_FILE with forms.body and forms.responses.readonly scopes.");
+    throw new Error(`Google Forms API ${label} failed: HTTP ${response.status}${message === "" ? "" : ` ${message}`}`);
+  }
+  return body;
+}
+
+function optionalString(value: JsonValue | undefined): string | null {
+  return typeof value === "string" && value !== "" ? value : null;
+}
+
+function jsonObject(value: JsonValue): value is JsonObject {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function optionsMarkdown(options: JsonValue | undefined): string | null {
+  if (!Array.isArray(options)) return null;
+  return options.map((option) => {
+    const object = option as JsonObject;
+    return object["value"] as string;
+  }).join(", ");
+}
+
+function questionMarkdown(item: JsonObject): readonly string[] {
+  const lines = [`- ${item["title"] as string}`];
+  const questionItem = item["questionItem"] as JsonObject | undefined;
+  if (questionItem === undefined) return lines;
+  const question = questionItem["question"] as JsonObject;
+  lines.push(`  - itemId: ${item["itemId"] as string}`);
+  lines.push(`  - questionId: ${question["questionId"] as string}`);
+  if (question["required"] !== undefined) lines.push(`  - required: ${String(question["required"])}`);
+  const textQuestion = question["textQuestion"] as JsonObject | undefined;
+  if (textQuestion !== undefined) lines.push(`  - type: ${textQuestion["paragraph"] === true ? "paragraph" : "short_text"}`);
+  const choiceQuestion = question["choiceQuestion"] as JsonObject | undefined;
+  if (choiceQuestion !== undefined) {
+    lines.push(`  - type: ${choiceQuestion["type"] as string}`);
+    const options = optionsMarkdown(choiceQuestion["options"]);
+    if (options !== null) lines.push(`  - options: ${options}`);
+  }
+  const scaleQuestion = question["scaleQuestion"] as JsonObject | undefined;
+  if (scaleQuestion !== undefined) {
+    lines.push("  - type: scale");
+    lines.push(`  - range: ${String(scaleQuestion["low"])} to ${String(scaleQuestion["high"])}`);
+    const lowLabel = optionalString(scaleQuestion["lowLabel"]);
+    const highLabel = optionalString(scaleQuestion["highLabel"]);
+    if (lowLabel !== null) lines.push(`  - lowLabel: ${lowLabel}`);
+    if (highLabel !== null) lines.push(`  - highLabel: ${highLabel}`);
+  }
+  if (question["dateQuestion"] !== undefined) lines.push("  - type: date");
+  if (question["timeQuestion"] !== undefined) lines.push("  - type: time");
+  const ratingQuestion = question["ratingQuestion"] as JsonObject | undefined;
+  if (ratingQuestion !== undefined) {
+    lines.push("  - type: rating");
+    lines.push(`  - level: ${String(ratingQuestion["ratingScaleLevel"])}`);
+    lines.push(`  - icon: ${String(ratingQuestion["iconType"])}`);
+  }
+  if (question["fileUploadQuestion"] !== undefined) lines.push("  - type: file_upload");
+  if (question["rowQuestion"] !== undefined) lines.push("  - type: row");
+  return lines;
+}
+
+function answerTexts(answer: JsonObject): readonly string[] {
+  const textAnswers = answer["textAnswers"] as JsonObject | undefined;
+  if (textAnswers !== undefined && Array.isArray(textAnswers["answers"])) return (textAnswers["answers"] as readonly JsonObject[]).map((value) => value["value"] as string);
+  return [JSON.stringify(answer)];
+}
+
+function formAnswers(response: JsonObject): readonly FormAnswer[] {
+  const answers = response["answers"] as JsonObject | undefined;
+  if (answers === undefined) return [];
+  return Object.entries(answers).flatMap(([questionId, answer]) => answerTexts(answer as JsonObject).map((text) => ({ questionId, text })));
+}
+
+function formMarkdown(form: JsonObject, responses: readonly JsonObject[]): string {
+  const info = form["info"] as JsonObject;
+  const title = info["title"] as string;
+  const id = form["formId"] as string;
+  const lines = [`# ${title}`, "", `- Form ID: ${id}`, `- Edit: ${formUrl(id)}`];
+  const responder = optionalString(form["responderUri"]);
+  if (responder !== null) lines.push(`- Responder: ${responder}`);
+  const publish = (form["publishSettings"] as JsonObject | undefined)?.["publishState"] as JsonObject | undefined;
+  if (publish !== undefined) {
+    lines.push(`- Published: ${String(publish["isPublished"])}`);
+    lines.push(`- Accepting responses: ${String(publish["isAcceptingResponses"])}`);
+  }
+  lines.push("", "## Items");
+  const items = form["items"] as readonly JsonObject[] | undefined;
+  if (items === undefined || items.length === 0) lines.push("No items.");
+  else for (const item of items) lines.push(...questionMarkdown(item));
+  lines.push("", "## Responses", "", `Response count: ${responses.length}`);
+  for (const response of responses) {
+    lines.push("", `### ${response["responseId"] as string}`);
+    const createTime = optionalString(response["createTime"]);
+    const submitted = optionalString(response["lastSubmittedTime"]);
+    if (createTime !== null) lines.push(`- Created: ${createTime}`);
+    if (submitted !== null) lines.push(`- Submitted: ${submitted}`);
+    for (const answer of formAnswers(response)) lines.push(`- ${answer.questionId}: ${answer.text}`);
+  }
+  return `${lines.join("\n")}\n`;
+}
+
+async function allResponses(runtime: RuntimeCapabilities, id: string): Promise<readonly JsonObject[]> {
+  const responses: JsonObject[] = [];
+  let pageToken: string | undefined;
+  for (;;) {
+    const url = new URL(`https://forms.googleapis.com/v1/forms/${encodeURIComponent(id)}/responses`);
+    if (pageToken !== undefined) url.searchParams.set("pageToken", pageToken);
+    const body = await formsJson(runtime, url.toString(), "responses.list");
+    if (Array.isArray(body["responses"])) responses.push(...body["responses"] as readonly JsonObject[]);
+    if (typeof body["nextPageToken"] !== "string") break;
+    pageToken = body["nextPageToken"];
+  }
+  return responses;
+}
+
+async function fetchGoogleForm(runtime: RuntimeCapabilities, source: Source): Promise<FetchedDocument> {
+  const form = await formsJson(runtime, `https://forms.googleapis.com/v1/forms/${encodeURIComponent(source.identifier)}`, "forms.get");
+  const responses = await allResponses(runtime, source.identifier);
+  const info = form["info"] as JsonObject;
+  const markdown = formMarkdown(form, responses);
+  return Object.freeze({
+    title: info["title"] as string,
+    markdown,
+    data: { form, responses, markdown },
+  });
+}
+
+export const googleFormsService = defineService<RuntimeCapabilities>({
+  name: "google-forms",
+  matches: (url) => url.hostname === "docs.google.com" && /^\/forms(?:\/u\/\d+)?\/d\/[^/]+(?:\/.*)?$/.test(url.pathname),
+  parse: (url) => Object.freeze({ service: "google-forms", identifier: formId(url), type: "form" }),
+  fetch: (runtime, _url, source) => fetchGoogleForm(runtime, source),
+  synchronize: async (runtime, _url, source, base, markdown) => {
+    const baseMarkdown = jsonObject(base) && typeof base["markdown"] === "string" ? base["markdown"] : null;
+    if (baseMarkdown !== null && markdown !== baseMarkdown) throw new Error("Google Forms sync is download-only. Revert local edits or use `wire download <url>` for a fresh copy.");
+    return fetchGoogleForm(runtime, source);
+  },
+});

package/node_modules/provider-google-docs/src/index.ts

@@ -1,6 +1,8 @@
 import { googleDocsService } from "./google-docs.js";
+import { googleFormsService } from "./google-forms.js";
 
 export { googleDocsService } from "./google-docs.js";
+export { googleFormsService } from "./google-forms.js";
 export const googleDocsProvider = Object.freeze({
-  services: [googleDocsService] as const,
+  services: [googleFormsService, googleDocsService] as const,
 });

package/node_modules/provider-notion/dist/notion-sync.d.ts

@@ -34,7 +34,7 @@ export type NotionDiffSummary = Readonly<{
 }>;
 type UserMentions = Readonly<Record<string, string>>;
 export declare function parseNotionMarkdown(markdown: string): readonly NotionBlock[];
-export declare function buildNotionCreateOperations(blocks: readonly NotionBlock[], pageId: string, spaceId: string, userId: string, currentTime: number, createId?: () => string): Readonly<{
+export declare function buildNotionCreateOperations(blocks: readonly NotionBlock[], pageId: string, spaceId: string, userId: string, currentTime: number, createId?: () => string, initialTableColumnOrder?: readonly string[]): Readonly<{
     operations: readonly NotionOperation[];
     topLevelIds: readonly string[];
 }>;
@@ -51,6 +51,6 @@ export declare function diffNotionBlockTrees(remoteTree: NotionTree, localBlocks
 export declare function renderNotionTreeToMarkdown(tree: NotionTree, mentions?: UserMentions): string;
 export declare function fetchNotionDocument(runtime: RuntimeCapabilities, url: string, source: Source): Promise<FetchedDocument>;
 export declare function uploadNotionDocument(runtime: RuntimeCapabilities, markdown: string, _markdownPath: string): Promise<UploadedDocument>;
-export declare function synchronizeNotionDocument(runtime: RuntimeCapabilities, url: string, base: JsonValue, markdown: string, _markdownPath: string): Promise<FetchedDocument>;
+export declare function synchronizeNotionDocument(runtime: RuntimeCapabilities, url: string, source: Source, base: JsonValue, markdown: string, _markdownPath: string): Promise<FetchedDocument>;
 export {};
 //# sourceMappingURL=notion-sync.d.ts.map