@seed-hypermedia/client 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -2,23 +2,21 @@ import {
   HMActionSchema,
   HMRequestSchema,
   HYPERMEDIA_SCHEME,
+  codePointLength,
   entityQueryPathToHmIdPath,
   getHMQueryString,
   hmIdPathToEntityQueryPath,
+  isSurrogate,
   packBaseId,
   packHmId,
-  serializeBlockRange
-} from "./chunk-YUKHBJYL.mjs";
-
-// src/change.ts
-import { decode as cborDecode, encode as cborEncode3 } from "@ipld/dag-cbor";
-import { CID as CID2 } from "multiformats";
-import * as Block from "multiformats/block";
-import { sha256 } from "multiformats/hashes/sha2";
+  parseCustomURL,
+  parseFragment,
+  serializeBlockRange,
+  unpackHmId
+} from "./chunk-PPK3SKPV.mjs";
 
-// src/ref.ts
+// src/capability.ts
 import { encode as cborEncode2 } from "@ipld/dag-cbor";
-import { CID } from "multiformats";
 import { base58btc } from "multiformats/bases/base58";
 
 // src/signing.ts
@@ -48,7 +46,38 @@ function toPublishInput(blobData, extraBlobs) {
   };
 }
 
+// src/capability.ts
+async function createCapability(input, signer) {
+  const signerKey = await signer.getPublicKey();
+  const ts = BigInt(Date.now());
+  const unsigned = {
+    type: "Capability",
+    signer: new Uint8Array(signerKey),
+    sig: new Uint8Array(64),
+    ts,
+    delegate: new Uint8Array(base58btc.decode(input.delegateUid)),
+    role: input.role
+  };
+  if (input.path) {
+    unsigned.path = input.path;
+  }
+  if (input.label) {
+    unsigned.label = input.label;
+  }
+  unsigned.sig = await signObject(signer, unsigned);
+  return toPublishInput(cborEncode2(unsigned));
+}
+
+// src/change.ts
+import { decode as cborDecode, encode as cborEncode4 } from "@ipld/dag-cbor";
+import { CID as CID2 } from "multiformats";
+import * as Block from "multiformats/block";
+import { sha256 } from "multiformats/hashes/sha2";
+
 // src/ref.ts
+import { encode as cborEncode3 } from "@ipld/dag-cbor";
+import { CID } from "multiformats";
+import { base58btc as base58btc2 } from "multiformats/bases/base58";
 function bytesEqual(a, b) {
   if (a.length !== b.length) return false;
   for (let i = 0; i < a.length; i++) {
@@ -62,10 +91,11 @@ function buildUnsignedRef({
   path,
   genesis,
   generation,
-  capability
+  capability,
+  visibility
 }) {
   const signerBytes = new Uint8Array(signerKey);
-  const spaceBytes = new Uint8Array(base58btc.decode(space));
+  const spaceBytes = new Uint8Array(base58btc2.decode(space));
   const unsigned = {
     type: "Ref",
     signer: signerBytes,
@@ -83,6 +113,9 @@ function buildUnsignedRef({
   if (capability) {
     unsigned.capability = CID.parse(capability);
   }
+  if (visibility) {
+    unsigned.visibility = visibility;
+  }
   return unsigned;
 }
 async function createVersionRef(input, signer) {
@@ -93,11 +126,12 @@ async function createVersionRef(input, signer) {
     path: input.path,
     genesis: input.genesis,
     generation: input.generation,
-    capability: input.capability
+    capability: input.capability,
+    visibility: input.visibility
   });
   unsigned.heads = input.version.split(".").map((v) => CID.parse(v));
   unsigned.sig = await signObject(signer, unsigned);
-  return toPublishInput(cborEncode2(unsigned));
+  return toPublishInput(cborEncode3(unsigned));
 }
 async function createTombstoneRef(input, signer) {
   const signerKey = await signer.getPublicKey();
@@ -111,7 +145,7 @@ async function createTombstoneRef(input, signer) {
   });
   unsigned.heads = [];
   unsigned.sig = await signObject(signer, unsigned);
-  return toPublishInput(cborEncode2(unsigned));
+  return toPublishInput(cborEncode3(unsigned));
 }
 async function createRedirectRef(input, signer) {
   const signerKey = await signer.getPublicKey();
@@ -128,14 +162,14 @@ async function createRedirectRef(input, signer) {
     path: input.targetPath
   };
   if (input.targetSpace && input.targetSpace !== input.space) {
-    redirect.space = new Uint8Array(base58btc.decode(input.targetSpace));
+    redirect.space = new Uint8Array(base58btc2.decode(input.targetSpace));
   }
   if (input.republish) {
     redirect.republish = true;
   }
   unsigned.redirect = redirect;
   unsigned.sig = await signObject(signer, unsigned);
-  return toPublishInput(cborEncode2(unsigned));
+  return toPublishInput(cborEncode3(unsigned));
 }
 
 // src/change.ts
@@ -154,14 +188,14 @@ function createChangeOps(input) {
     deps: input.deps,
     depth: input.depth
   };
-  return { unsignedBytes: cborEncode3(unsigned), ts };
+  return { unsignedBytes: cborEncode4(unsigned), ts };
 }
 async function createChange(unsignedBytes, signer) {
   const change = cborDecode(unsignedBytes);
   const genesis = change.genesis instanceof CID2 ? change.genesis : null;
   change.signer = new Uint8Array(await signer.getPublicKey());
   change.sig = new Uint8Array(64);
-  change.sig = await signer.sign(cborEncode3(change));
+  change.sig = await signer.sign(cborEncode4(change));
   const block = await Block.encode({ value: change, codec: cborCodec, hasher: sha256 });
   return { bytes: block.bytes, cid: block.cid, genesis };
 }
@@ -177,7 +211,7 @@ async function createGenesisChange(signer) {
     sig: new Uint8Array(64),
     ts: BigInt(0)
   };
-  unsigned.sig = await signer.sign(cborEncode3(unsigned));
+  unsigned.sig = await signer.sign(cborEncode4(unsigned));
   const block = await Block.encode({ value: unsigned, codec: cborCodec, hasher: sha256 });
   return { bytes: block.bytes, cid: block.cid };
 }
@@ -209,6 +243,10 @@ function protoChangesToOps(changes) {
     }
   });
 }
+var RESOURCE_VISIBILITY_PRIVATE = 2;
+function visibilityToCbor(protoVisibility) {
+  return protoVisibility === RESOURCE_VISIBILITY_PRIVATE ? "Private" : void 0;
+}
 async function signDocumentChange(input, signer) {
   const { bytes: signedBytes, cid: changeCid, genesis: changeGenesis } = await createChange(input.unsignedChange, signer);
   const effectiveGenesis = input.genesis || (changeGenesis ? changeGenesis.toString() : changeCid.toString());
@@ -220,7 +258,8 @@ async function signDocumentChange(input, signer) {
       genesis: effectiveGenesis,
       version: changeCid.toString(),
       generation: effectiveGeneration,
-      capability: input.capability
+      capability: input.capability,
+      visibility: visibilityToCbor(input.visibility)
     },
     signer
   );
@@ -233,7 +272,7 @@ async function signDocumentChange(input, signer) {
 }
 
 // src/client.ts
-import { encode as cborEncode4 } from "@ipld/dag-cbor";
+import { encode as cborEncode5 } from "@ipld/dag-cbor";
 import { deserialize } from "superjson";
 
 // src/errors.ts
@@ -331,7 +370,7 @@ function createSeedClient(baseUrl, options) {
             "Content-Type": "application/cbor",
             ...defaultHeaders
           },
-          body: new Uint8Array(cborEncode4(stripUndefined(validatedInput)))
+          body: new Uint8Array(cborEncode5(stripUndefined(validatedInput)))
         });
       } catch (err) {
         throw new SeedNetworkError(
@@ -387,7 +426,7 @@ function createSeedClient(baseUrl, options) {
     return request("PublishBlobs", input);
   }
   async function publishDocument(input, signer) {
-    if (!input.genesis && !input.baseVersion) {
+    if (!input.genesis && !input.baseVersion && !input.path) {
       const genesisChange = await createGenesisChange(signer);
       const contentChange = await createDocumentChange(
         {
@@ -401,7 +440,7 @@ function createSeedClient(baseUrl, options) {
       const ref = await createVersionRef(
         {
           space: input.account,
-          path: input.path ?? "",
+          path: "",
           genesis: genesisChange.cid.toString(),
           version: contentChange.cid.toString(),
           generation: input.generation != null ? Number(input.generation) : 1,
@@ -433,7 +472,8 @@ function createSeedClient(baseUrl, options) {
         unsignedChange,
         genesis: input.genesis,
         generation: input.generation,
-        capability: input.capability
+        capability: input.capability,
+        visibility: input.visibility
       },
       signer
     );
@@ -459,9 +499,9 @@ function stripUndefined(obj) {
 }
 
 // src/comment.ts
-import { encode as cborEncode5 } from "@ipld/dag-cbor";
+import { decode as cborDecode2, encode as cborEncode6 } from "@ipld/dag-cbor";
 import { CID as CID3 } from "multiformats";
-import { base58btc as base58btc2 } from "multiformats/bases/base58";
+import { base58btc as base58btc3 } from "multiformats/bases/base58";
 function trimTrailingEmptyBlocks(blocks) {
   let end = blocks.length;
   while (end > 0) {
@@ -619,7 +659,7 @@ function createUnsignedComment({
   const unsignedComment = {
     type: "Comment",
     body: blocksToPublishable(content),
-    space: new Uint8Array(base58btc2.decode(docId.uid)),
+    space: new Uint8Array(base58btc3.decode(docId.uid)),
     version: docVersion,
     signer: new Uint8Array(signerKey),
     ts: BigInt(Date.now()),
@@ -664,7 +704,7 @@ async function createCommentBlob({
     visibility
   });
   const signedComment = await createSignedComment(unsignedComment, signer);
-  return cborEncode5(signedComment);
+  return cborEncode6(signedComment);
 }
 function generateBlockId(length = 8) {
   const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
@@ -740,7 +780,7 @@ async function deleteComment(input, signer) {
     type: "Comment",
     id: tsid,
     body: [],
-    space: new Uint8Array(base58btc2.decode(input.targetAccount)),
+    space: new Uint8Array(base58btc3.decode(input.targetAccount)),
     path: input.targetPath,
     version: input.targetVersion.split(".").map((v) => CID3.parse(v)),
     signer: new Uint8Array(signerKey),
@@ -749,13 +789,32 @@ async function deleteComment(input, signer) {
   };
   if (input.visibility) tombstone.visibility = input.visibility;
   tombstone.sig = await signObject(signer, tombstone);
-  const encoded = cborEncode5(tombstone);
+  const encoded = cborEncode6(tombstone);
   return toPublishInput(encoded, []);
 }
+async function commentRecordIdFromBlob(blobData) {
+  const decoded = cborDecode2(blobData);
+  if (decoded.type !== "Comment") {
+    throw new Error(`Expected Comment blob, got "${decoded.type}"`);
+  }
+  const signerBytes = decoded.signer;
+  const ts = BigInt(decoded.ts);
+  const authority = base58btc3.encode(new Uint8Array(signerBytes));
+  const buf = new ArrayBuffer(8);
+  new DataView(buf).setBigUint64(0, ts, false);
+  const tsBytes = new Uint8Array(buf, 2, 6);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", blobData);
+  const hashBytes = new Uint8Array(hashBuffer, 0, 4);
+  const tsidBytes = new Uint8Array(10);
+  tsidBytes.set(tsBytes, 0);
+  tsidBytes.set(hashBytes, 6);
+  const tsid = base58btc3.encode(tsidBytes);
+  return `${authority}/${tsid}`;
+}
 
 // src/contact.ts
-import { encode as cborEncode6, decode as cborDecode2 } from "@ipld/dag-cbor";
-import { base58btc as base58btc3 } from "multiformats/bases/base58";
+import { decode as cborDecode3, encode as cborEncode7 } from "@ipld/dag-cbor";
+import { base58btc as base58btc4 } from "multiformats/bases/base58";
 function extractTsid(contactId) {
   const parts = contactId.split("/");
   const tsid = parts[1];
@@ -764,6 +823,14 @@ function extractTsid(contactId) {
   }
   return tsid;
 }
+function extractAuthority(contactId) {
+  const parts = contactId.split("/");
+  const authority = parts[0];
+  if (!authority || parts.length !== 2) {
+    throw new Error(`Invalid contact ID format: ${contactId}. Expected "authority/tsid".`);
+  }
+  return authority;
+}
 async function computeTSID(timestampMs, blobData) {
   const buf = new ArrayBuffer(8);
   new DataView(buf).setBigUint64(0, timestampMs, false);
@@ -773,22 +840,32 @@ async function computeTSID(timestampMs, blobData) {
   const tsidBytes = new Uint8Array(10);
   tsidBytes.set(tsBytes, 0);
   tsidBytes.set(hashBytes, 6);
-  return base58btc3.encode(tsidBytes);
+  return base58btc4.encode(tsidBytes);
 }
 async function createContact(input, signer) {
   const signerKey = await signer.getPublicKey();
   const ts = BigInt(Date.now());
+  const signerUid = base58btc4.encode(new Uint8Array(signerKey));
+  const authority = input.accountUid || signerUid;
   const unsigned = {
     type: "Contact",
     signer: new Uint8Array(signerKey),
     sig: new Uint8Array(64),
     ts,
-    subject: new Uint8Array(base58btc3.decode(input.subjectUid)),
-    name: input.name
+    subject: new Uint8Array(base58btc4.decode(input.subjectUid))
   };
+  if (input.name) {
+    unsigned.name = input.name;
+  }
+  if (input.accountUid) {
+    unsigned.account = new Uint8Array(base58btc4.decode(input.accountUid));
+  }
+  if (input.subscribe) {
+    unsigned.subscribe = input.subscribe;
+  }
+  console.log("SIGNING BLOB", unsigned);
   unsigned.sig = await signObject(signer, unsigned);
-  const encoded = cborEncode6(unsigned);
-  const authority = base58btc3.encode(new Uint8Array(signerKey));
+  const encoded = cborEncode7(unsigned);
   const tsid = await computeTSID(ts, encoded);
   return {
     ...toPublishInput(encoded),
@@ -798,21 +875,31 @@ async function createContact(input, signer) {
 async function updateContact(input, signer) {
   const signerKey = await signer.getPublicKey();
   const tsid = extractTsid(input.contactId);
+  const accountUid = input.accountUid || extractAuthority(input.contactId);
   const unsigned = {
     type: "Contact",
     signer: new Uint8Array(signerKey),
     sig: new Uint8Array(64),
     ts: BigInt(Date.now()),
     id: tsid,
-    subject: new Uint8Array(base58btc3.decode(input.subjectUid)),
-    name: input.name
+    subject: new Uint8Array(base58btc4.decode(input.subjectUid))
   };
+  if (input.name) {
+    unsigned.name = input.name;
+  }
+  if (accountUid) {
+    unsigned.account = new Uint8Array(base58btc4.decode(accountUid));
+  }
+  if (input.subscribe) {
+    unsigned.subscribe = input.subscribe;
+  }
   unsigned.sig = await signObject(signer, unsigned);
-  return toPublishInput(cborEncode6(unsigned));
+  return toPublishInput(cborEncode7(unsigned));
 }
 async function deleteContact(input, signer) {
   const signerKey = await signer.getPublicKey();
   const tsid = extractTsid(input.contactId);
+  const accountUid = input.accountUid || extractAuthority(input.contactId);
   const unsigned = {
     type: "Contact",
     signer: new Uint8Array(signerKey),
@@ -820,50 +907,2253 @@ async function deleteContact(input, signer) {
     ts: BigInt(Date.now()),
     id: tsid
   };
+  if (accountUid) {
+    unsigned.account = new Uint8Array(base58btc4.decode(accountUid));
+  }
   unsigned.sig = await signObject(signer, unsigned);
-  return toPublishInput(cborEncode6(unsigned));
+  return toPublishInput(cborEncode7(unsigned));
 }
 async function contactRecordIdFromBlob(blobData) {
-  const decoded = cborDecode2(blobData);
+  const decoded = cborDecode3(blobData);
   if (decoded.type !== "Contact") {
     throw new Error(`Expected Contact blob, got "${decoded.type}"`);
   }
   const signerBytes = decoded.signer;
   const ts = BigInt(decoded.ts);
-  const authority = base58btc3.encode(new Uint8Array(signerBytes));
+  const accountBytes = decoded.account;
+  const authority = base58btc4.encode(new Uint8Array(accountBytes || signerBytes));
   const tsid = await computeTSID(ts, blobData);
   return `${authority}/${tsid}`;
 }
 
-// src/capability.ts
-import { encode as cborEncode7 } from "@ipld/dag-cbor";
-import { base58btc as base58btc4 } from "multiformats/bases/base58";
-async function createCapability(input, signer) {
-  const signerKey = await signer.getPublicKey();
-  const ts = BigInt(Date.now());
-  const unsigned = {
-    type: "Capability",
-    signer: new Uint8Array(signerKey),
-    sig: new Uint8Array(64),
-    ts,
-    delegate: new Uint8Array(base58btc4.decode(input.delegateUid)),
-    role: input.role
+// src/tei-to-blocks.ts
+function generateBlockId2() {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-";
+  let id = "";
+  for (let i = 0; i < 8; i++) {
+    id += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return id;
+}
+function makeBlock(type, text, extra = {}) {
+  return {
+    block: {
+      id: generateBlockId2(),
+      type,
+      text,
+      revision: "",
+      link: "",
+      attributes: {},
+      annotations: [],
+      ...extra
+    },
+    children: []
   };
-  if (input.path) {
-    unsigned.path = input.path;
+}
+function makeHeading(text) {
+  return makeBlock("Heading", text, {
+    attributes: { childrenType: "Group" }
+  });
+}
+function makeParagraph(text, annotations = []) {
+  return makeBlock("Paragraph", text, { annotations });
+}
+function makeMath(text) {
+  return makeBlock("Math", text);
+}
+function makeCode(text, language = "") {
+  return makeBlock("Code", text, {
+    attributes: language ? { language } : {}
+  });
+}
+function makeImage(link, caption = "") {
+  return makeBlock("Image", caption, { link });
+}
+function makeList(items, listType) {
+  const container = makeBlock("Paragraph", "", {
+    attributes: { childrenType: listType }
+  });
+  container.children = items;
+  return container;
+}
+function parseInlineContent(_$, el) {
+  const annotations = [];
+  let text = "";
+  function walk(node, active) {
+    var _a, _b, _c;
+    if (node.type === "text") {
+      const raw = node.data || "";
+      const normalized = raw.replace(/\s+/g, " ");
+      text += normalized;
+      return;
+    }
+    if (node.type !== "tag") return;
+    let isBold = active.bold || false;
+    let isItalic = active.italic || false;
+    let isCode = active.code || false;
+    let linkHref = active.link;
+    const tagName = ((_a = node.name) == null ? void 0 : _a.toLowerCase()) || "";
+    if (tagName === "hi") {
+      const rend = ((_b = node.attribs) == null ? void 0 : _b.rend) || "";
+      if (rend === "bold" || rend === "b") isBold = true;
+      if (rend === "italic" || rend === "i") isItalic = true;
+      if (rend === "monospace" || rend === "code") isCode = true;
+    }
+    if (tagName === "ref") {
+      const target = (_c = node.attribs) == null ? void 0 : _c.target;
+      if (target && target.startsWith("http")) {
+        linkHref = target;
+      }
+    }
+    const start = codePointLength(text);
+    for (const child of node.children || []) {
+      walk(child, { bold: isBold, italic: isItalic, code: isCode, link: linkHref });
+    }
+    const end = codePointLength(text);
+    if (end <= start) return;
+    if (isBold && !active.bold && tagName === "hi") {
+      annotations.push({ type: "Bold", starts: [start], ends: [end] });
+    }
+    if (isItalic && !active.italic && tagName === "hi") {
+      annotations.push({ type: "Italic", starts: [start], ends: [end] });
+    }
+    if (isCode && !active.code && tagName === "hi") {
+      annotations.push({ type: "Code", starts: [start], ends: [end] });
+    }
+    if (linkHref && !active.link && tagName === "ref") {
+      annotations.push({
+        type: "Link",
+        starts: [start],
+        ends: [end],
+        link: linkHref
+      });
+    }
   }
-  if (input.label) {
-    unsigned.label = input.label;
+  for (const child of el.contents().toArray()) {
+    walk(child, {});
   }
-  unsigned.sig = await signObject(signer, unsigned);
-  return toPublishInput(cborEncode7(unsigned));
+  const trimmedText = text.trim();
+  const leadingLen = text.length - text.trimStart().length;
+  const adjustedAnnotations = annotations.map((a) => ({
+    ...a,
+    starts: a.starts.map((p) => Math.max(0, p - leadingLen)),
+    ends: a.ends.map((p) => Math.max(0, p - leadingLen))
+  })).filter((a) => (a.ends[0] ?? 0) > (a.starts[0] ?? 0));
+  adjustedAnnotations.sort((a, b) => {
+    const aStart = a.starts[0] ?? 0;
+    const bStart = b.starts[0] ?? 0;
+    if (aStart !== bStart) return aStart - bStart;
+    const aEnd = a.ends[0] ?? 0;
+    const bEnd = b.ends[0] ?? 0;
+    if (aEnd !== bEnd) return aEnd - bEnd;
+    return a.type < b.type ? -1 : a.type > b.type ? 1 : 0;
+  });
+  return { text: trimmedText, annotations: adjustedAnnotations };
+}
+function extractTitle($) {
+  const titleEl = $('teiHeader fileDesc titleStmt title[level="a"]');
+  if (titleEl.length) return titleEl.text().trim();
+  const anyTitle = $("teiHeader fileDesc titleStmt title");
+  if (anyTitle.length) return anyTitle.first().text().trim();
+  return "";
+}
+function extractAuthors($) {
+  const authors = [];
+  $("teiHeader fileDesc sourceDesc biblStruct analytic author persName").each((_i, el) => {
+    const forenames = [];
+    $(el).find("forename").each((_j, fn) => {
+      forenames.push($(fn).text().trim());
+    });
+    const surname = $(el).find("surname").text().trim();
+    const name = [...forenames, surname].filter(Boolean).join(" ");
+    if (name) authors.push(name);
+  });
+  if (authors.length === 0) {
+    $("teiHeader sourceDesc biblStruct analytic author").each((_i, el) => {
+      const persName = $(el).find("persName");
+      if (persName.length) {
+        const forenames = [];
+        persName.find("forename").each((_j, fn) => {
+          forenames.push($(fn).text().trim());
+        });
+        const surname = persName.find("surname").text().trim();
+        const name = [...forenames, surname].filter(Boolean).join(" ");
+        if (name) authors.push(name);
+      }
+    });
+  }
+  return authors.join(", ");
+}
+function extractAbstract($) {
+  const abs = $("teiHeader profileDesc abstract");
+  if (!abs.length) return "";
+  const parts = [];
+  abs.find("p").each((_i, el) => {
+    const t = $(el).text().trim();
+    if (t) parts.push(t);
+  });
+  if (parts.length) return parts.join("\n\n");
+  return abs.text().trim();
+}
+function extractDate($) {
+  const dateEl = $('teiHeader fileDesc publicationStmt date[type="published"]');
+  const when = dateEl.attr("when");
+  if (when) return when;
+  return dateEl.text().trim();
+}
+function parseCoords(coordsStr) {
+  if (!coordsStr) return null;
+  const first = coordsStr.split(";")[0];
+  if (!first) return null;
+  const parts = first.split(",").map(Number);
+  if (parts.length < 5 || parts.some(isNaN)) return null;
+  return {
+    page: parts[0],
+    x: parts[1],
+    y: parts[2],
+    width: parts[3],
+    height: parts[4]
+  };
+}
+function formatTable($, tableEl) {
+  const rows = [];
+  tableEl.find("row").each((_i, row) => {
+    const cells = [];
+    $(row).find("cell").each((_j, cell) => {
+      cells.push($(cell).text().trim());
+    });
+    rows.push(cells);
+  });
+  if (rows.length === 0) return tableEl.text().trim();
+  const colWidths = [];
+  for (const row of rows) {
+    for (let i = 0; i < row.length; i++) {
+      colWidths[i] = Math.max(colWidths[i] || 0, (row[i] || "").length);
+    }
+  }
+  const lines = [];
+  for (let r = 0; r < rows.length; r++) {
+    const row = rows[r];
+    const line = row.map((cell, c) => cell.padEnd(colWidths[c] || 0)).join(" | ");
+    lines.push(line);
+    if (r === 0) {
+      lines.push(colWidths.map((w) => "-".repeat(w)).join("-+-"));
+    }
+  }
+  return lines.join("\n");
+}
+function formatBiblStruct($, bib) {
+  const authors = [];
+  bib.find("author persName").each((_i, el) => {
+    const forenames = [];
+    $(el).find("forename").each((_j, fn) => {
+      forenames.push($(fn).text().trim());
+    });
+    const surname = $(el).find("surname").text().trim();
+    const name = [...forenames, surname].filter(Boolean).join(" ");
+    if (name) authors.push(name);
+  });
+  const title = bib.find("analytic title").text().trim() || bib.find("monogr title").text().trim();
+  const journal = bib.find('monogr title[level="j"]').text().trim();
+  const volume = bib.find('biblScope[unit="volume"]').text().trim();
+  const pages = bib.find('biblScope[unit="page"]');
+  const from = pages.attr("from") || "";
+  const to = pages.attr("to") || "";
+  const pageStr = from && to ? `${from}-${to}` : pages.text().trim();
+  const year = bib.find('date[type="published"]').attr("when") || bib.find('date[type="published"]').text().trim();
+  const doi = bib.find('idno[type="DOI"]').text().trim();
+  const parts = [];
+  if (authors.length) parts.push(authors.join(", "));
+  if (title) parts.push(`"${title}"`);
+  if (journal) {
+    let jPart = journal;
+    if (volume) jPart += ` ${volume}`;
+    if (pageStr) jPart += `: ${pageStr}`;
+    parts.push(jPart);
+  }
+  if (year) parts.push(`(${year})`);
+  let result = parts.join(". ");
+  if (doi) result += `. DOI: ${doi}`;
+  return result || bib.text().trim().replace(/\s+/g, " ");
+}
+function inferHeadingLevel(_$, headEl) {
+  var _a, _b;
+  let depth = 0;
+  let parent = headEl.parent();
+  while (parent.length) {
+    const tag = (_b = (_a = parent[0]) == null ? void 0 : _a.name) == null ? void 0 : _b.toLowerCase();
+    if (tag === "body" || tag === "text") break;
+    if (tag === "div") depth++;
+    parent = parent.parent();
+  }
+  return Math.min(depth + 1, 6);
+}
+async function processBodyElements($, bodyEl, opts) {
+  const elements = [];
+  async function walkChildren(container) {
+    var _a;
+    for (const child of container.children().toArray()) {
+      const $child = $(child);
+      const tagName = ((_a = child.name) == null ? void 0 : _a.toLowerCase()) || "";
+      if (tagName === "div") {
+        await walkChildren($child);
+        continue;
+      }
+      if (tagName === "head") {
+        const text = $child.text().trim();
+        if (!text) continue;
+        const level = inferHeadingLevel($, $child);
+        const heading = makeHeading(text);
+        elements.push({ type: "heading", level, blockNode: heading });
+        continue;
+      }
+      if (tagName === "p") {
+        const { text, annotations } = parseInlineContent($, $child);
+        if (!text) continue;
+        elements.push({
+          type: "content",
+          blockNode: makeParagraph(text, annotations)
+        });
+        continue;
+      }
+      if (tagName === "formula") {
+        const label = $child.find("label").text().trim();
+        $child.find("label").remove();
+        let formulaText = $child.text().trim();
+        if (label) formulaText = `${formulaText} (${label})`;
+        if (formulaText) {
+          elements.push({
+            type: "content",
+            blockNode: makeMath(formulaText)
+          });
+        }
+        continue;
+      }
+      if (tagName === "figure") {
+        const figType = $child.attr("type");
+        if (figType === "table") {
+          const label2 = $child.find("head").text().trim();
+          const caption2 = $child.find("figDesc").text().trim();
+          const tableEl = $child.find("table");
+          let tableText = "";
+          if (tableEl.length) {
+            tableText = formatTable($, tableEl);
+          } else {
+            tableText = $child.text().trim();
+          }
+          const header = [label2, caption2].filter(Boolean).join(": ");
+          const fullText = header ? `${header}
+
+${tableText}` : tableText;
+          if (fullText) {
+            elements.push({
+              type: "content",
+              blockNode: makeCode(fullText)
+            });
+          }
+          continue;
+        }
+        const figId = $child.attr("xml:id") || "";
+        const label = $child.find("label").text().trim();
+        const caption = $child.find("figDesc").text().trim();
+        const coordsStr = $child.attr("coords");
+        const coords = parseCoords(coordsStr);
+        const figureInfo = { id: figId, label, caption, coords };
+        let imageLink = null;
+        if (opts.extractFigureImage && coords) {
+          imageLink = await opts.extractFigureImage(figureInfo);
+        }
+        if (imageLink) {
+          const captionText = [label ? `Figure ${label}` : "", caption].filter(Boolean).join(": ");
+          elements.push({
+            type: "content",
+            blockNode: makeImage(imageLink, captionText)
+          });
+        } else {
+          const captionText = [label ? `Figure ${label}` : "Figure", caption].filter(Boolean).join(": ");
+          if (captionText) {
+            elements.push({
+              type: "content",
+              blockNode: makeParagraph(captionText, [
+                {
+                  type: "Italic",
+                  starts: [0],
+                  ends: [codePointLength(captionText)]
+                }
+              ])
+            });
+          }
+        }
+        continue;
+      }
+      if (tagName === "list") {
+        const items = [];
+        $child.find("item").each((_i, item) => {
+          const { text, annotations } = parseInlineContent($, $(item));
+          if (text) items.push(makeParagraph(text, annotations));
+        });
+        if (items.length) {
+          elements.push({
+            type: "content",
+            blockNode: makeList(items, "Unordered")
+          });
+        }
+        continue;
+      }
+      if (tagName === "note") {
+        const { text, annotations } = parseInlineContent($, $child);
+        if (text) {
+          annotations.push({
+            type: "Italic",
+            starts: [0],
+            ends: [codePointLength(text)]
+          });
+          elements.push({
+            type: "content",
+            blockNode: makeParagraph(text, annotations)
+          });
+        }
+        continue;
+      }
+    }
+  }
+  await walkChildren(bodyEl);
+  return elements;
+}
+function processReferences($) {
+  const elements = [];
+  const biblStructs = $("back listBibl biblStruct");
+  if (!biblStructs.length) return elements;
+  elements.push({
+    type: "heading",
+    level: 2,
+    blockNode: makeHeading("References")
+  });
+  biblStructs.each((_i, bib) => {
+    const formatted = formatBiblStruct($, $(bib));
+    if (formatted) {
+      elements.push({
+        type: "content",
+        blockNode: makeParagraph(`[${_i + 1}] ${formatted}`)
+      });
+    }
+  });
+  return elements;
+}
+function buildHierarchy(elements) {
+  var _a;
+  const blocks = [];
+  const headingStack = [];
+  for (const element of elements) {
+    if (element.type === "heading" && element.level && element.blockNode) {
+      while (headingStack.length > 0 && (((_a = headingStack[headingStack.length - 1]) == null ? void 0 : _a.level) ?? 0) >= element.level) {
+        headingStack.pop();
+      }
+      if (headingStack.length === 0) {
+        blocks.push(element.blockNode);
+      } else {
+        const parent = headingStack[headingStack.length - 1].blockNode;
+        if (!parent.children) parent.children = [];
+        parent.children.push(element.blockNode);
+      }
+      headingStack.push({ level: element.level, blockNode: element.blockNode });
+    } else if (element.type === "content" && element.blockNode) {
+      if (headingStack.length === 0) {
+        blocks.push(element.blockNode);
+      } else {
+        const parent = headingStack[headingStack.length - 1].blockNode;
+        if (!parent.children) parent.children = [];
+        parent.children.push(element.blockNode);
+      }
+    }
+  }
+  return blocks;
+}
+async function teiToBlocks(teiXml, opts = {}) {
+  const { load } = await import("cheerio");
+  const $ = load(teiXml, { xml: true });
+  const title = extractTitle($);
+  const displayAuthor = extractAuthors($);
+  const summary = extractAbstract($);
+  const displayPublishTime = extractDate($);
+  const metadata = {
+    name: title,
+    ...displayAuthor ? { displayAuthor } : {},
+    ...summary ? { summary } : {},
+    ...displayPublishTime ? { displayPublishTime } : {}
+  };
+  const allElements = [];
+  const abstractEl = $("teiHeader profileDesc abstract");
+  if (abstractEl.length) {
+    allElements.push({
+      type: "heading",
+      level: 2,
+      blockNode: makeHeading("Abstract")
+    });
+    abstractEl.find("p").each((_i, p) => {
+      const { text, annotations } = parseInlineContent($, $(p));
+      if (text) {
+        allElements.push({
+          type: "content",
+          blockNode: makeParagraph(text, annotations)
+        });
+      }
+    });
+    if (!abstractEl.find("p").length) {
+      const absText = abstractEl.text().trim();
+      if (absText) {
+        allElements.push({
+          type: "content",
+          blockNode: makeParagraph(absText)
+        });
+      }
+    }
+  }
+  const body = $("text body");
+  if (body.length) {
+    const bodyElements = await processBodyElements($, body, opts);
+    allElements.push(...bodyElements);
+  }
+  const ack = $('back div[type="acknowledgement"], back div[type="acknowledgment"]');
+  if (ack.length) {
+    allElements.push({
+      type: "heading",
+      level: 2,
+      blockNode: makeHeading("Acknowledgements")
+    });
+    ack.find("p").each((_i, p) => {
+      const { text, annotations } = parseInlineContent($, $(p));
+      if (text) {
+        allElements.push({
+          type: "content",
+          blockNode: makeParagraph(text, annotations)
+        });
+      }
+    });
+  }
+  allElements.push(...processReferences($));
+  const blocks = buildHierarchy(allElements);
+  return { metadata, blocks };
+}
+
+// src/grobid.ts
+var DEFAULT_GROBID_URL = "http://localhost:8070";
+async function isGrobidAvailable(grobidUrl = DEFAULT_GROBID_URL, timeoutMs = 3e3) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const response = await fetch(`${grobidUrl}/api/isalive`, {
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function processFulltextDocument(pdfBuffer, options) {
+  const baseUrl = (options == null ? void 0 : options.grobidUrl) || DEFAULT_GROBID_URL;
+  const url = `${baseUrl}/api/processFulltextDocument`;
+  const formData = new FormData();
+  formData.append("input", new Blob([pdfBuffer]), "document.pdf");
+  const coords = (options == null ? void 0 : options.teiCoordinates) || ["figure"];
+  for (const coord of coords) {
+    formData.append("teiCoordinates", coord);
+  }
+  const response = await fetch(url, {
+    method: "POST",
+    body: formData
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`GROBID error (${response.status}): ${response.statusText}${body ? ` \u2014 ${body}` : ""}`);
+  }
+  return response.text();
+}
+
+// src/pdf-to-blocks-embedded.ts
+function generateBlockId3() {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-";
+  let id = "";
+  for (let i = 0; i < 8; i++) {
+    id += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return id;
+}
+function isTextItem(item) {
+  return "str" in item;
+}
+function isBoldFont(fontName) {
+  const lower = fontName.toLowerCase();
+  return lower.includes("bold") || lower.includes("heavy") || lower.includes("black");
+}
+function isItalicFont(fontName) {
+  const lower = fontName.toLowerCase();
+  return lower.includes("italic") || lower.includes("oblique") || lower.includes("slant");
+}
+function isMonospaceFont(fontName) {
+  const lower = fontName.toLowerCase();
+  return lower.includes("mono") || lower.includes("courier") || lower.includes("consolas") || lower.includes("menlo") || lower.includes("firacode") || lower.includes("inconsolata") || lower.includes("source code") || lower.includes("dejavu sans mono") || lower.includes("lucida console");
+}
+function makeBlock2(type, text, extra = {}) {
+  return {
+    block: {
+      id: generateBlockId3(),
+      type,
+      text,
+      revision: "",
+      link: "",
+      attributes: {},
+      annotations: [],
+      ...extra
+    },
+    children: []
+  };
+}
+function makeHeading2(text, annotations = []) {
+  return makeBlock2("Heading", text, {
+    attributes: { childrenType: "Group" },
+    annotations
+  });
+}
+function makeParagraph2(text, annotations = []) {
+  return makeBlock2("Paragraph", text, { annotations });
+}
+function makeCode2(text, language = "") {
+  return makeBlock2("Code", text, {
+    attributes: language ? { language } : {}
+  });
+}
+function makeList2(items, listType) {
+  const container = makeBlock2("Paragraph", "", {
+    attributes: { childrenType: listType }
+  });
+  container.children = items;
+  return container;
+}
+var MIN_HEADING_TEXT_LENGTH = 4;
+function clusterFontSizes(lines) {
+  const sizeCount = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    if (line.runs.length === 0) continue;
+    const size = Math.round(line.fontSize * 10) / 10;
+    sizeCount.set(size, (sizeCount.get(size) || 0) + 1);
+  }
+  if (sizeCount.size === 0) {
+    return { bodySize: 12, headingLevels: /* @__PURE__ */ new Map(), boldHeadingLevel: 1 };
+  }
+  const clusters = Array.from(sizeCount.entries()).map(([size, count]) => ({ size, count })).sort((a, b) => b.count - a.count);
+  const bodySize = clusters[0].size;
+  const headingSizeCount = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    if (line.runs.length === 0) continue;
+    const text = line.runs.map((r) => r.text).join("").trim();
+    if (text.length < MIN_HEADING_TEXT_LENGTH) continue;
+    const size = Math.round(line.fontSize * 10) / 10;
+    if (size > bodySize + 1) {
+      headingSizeCount.set(size, (headingSizeCount.get(size) || 0) + 1);
+    }
+  }
+  const headingSizes = Array.from(headingSizeCount.keys()).sort((a, b) => b - a);
+  const headingLevels = /* @__PURE__ */ new Map();
+  for (let i = 0; i < headingSizes.length && i < 6; i++) {
+    headingLevels.set(headingSizes[i], i + 1);
+  }
+  const boldHeadingLevel = Math.min(headingLevels.size + 1, 6);
+  return { bodySize, headingLevels, boldHeadingLevel };
+}
+var BULLET_PATTERNS = /^[\u2022\u2023\u25E6\u2043\u2219•·‣⁃○◦▪▸►–—-]\s+/;
+var NUMBERED_PATTERN = /^(\d+)[.)]\s+/;
+var LETTER_PATTERN = /^[a-zA-Z][.)]\s+/;
+function detectListType(text) {
+  const bulletMatch = text.match(BULLET_PATTERNS);
+  if (bulletMatch) {
+    return { type: "bullet", content: text.slice(bulletMatch[0].length) };
+  }
+  const numberedMatch = text.match(NUMBERED_PATTERN);
+  if (numberedMatch) {
+    return { type: "numbered", content: text.slice(numberedMatch[0].length) };
+  }
+  const letterMatch = text.match(LETTER_PATTERN);
+  if (letterMatch) {
+    return { type: "numbered", content: text.slice(letterMatch[0].length) };
+  }
+  return null;
+}
+async function extractTextRuns(doc) {
+  const allLines = [];
+  for (let pageNum = 1; pageNum <= doc.numPages; pageNum++) {
+    const page = await doc.getPage(pageNum);
+    await page.getOperatorList();
+    const textContent = await page.getTextContent({ includeMarkedContent: false });
+    const items = textContent.items.filter(isTextItem);
+    const styles = textContent.styles;
+    if (items.length === 0) continue;
+    const fontInfoCache = /* @__PURE__ */ new Map();
+    const getFontInfo = (fontName) => {
+      const cached = fontInfoCache.get(fontName);
+      if (cached) return cached;
+      let bold = false;
+      let italic = false;
+      let monospace = false;
+      try {
+        if (page.commonObjs.has(fontName)) {
+          const fontObj = page.commonObjs.get(fontName);
+          if (fontObj) {
+            bold = fontObj.bold === true || fontObj.black === true;
+            italic = fontObj.italic === true;
+            monospace = fontObj.isMonospace === true;
+            if (fontObj.name) {
+              if (!monospace) monospace = isMonospaceFont(fontObj.name);
+              if (!bold) bold = isBoldFont(fontObj.name);
+              if (!italic) italic = isItalicFont(fontObj.name);
+            }
+          }
+        }
+      } catch {
+      }
+      if (!bold && !italic && !monospace) {
+        const style = styles[fontName];
+        if (style == null ? void 0 : style.fontFamily) {
+          monospace = style.fontFamily === "monospace" || isMonospaceFont(style.fontFamily);
+        }
+      }
+      if (!bold) bold = isBoldFont(fontName);
+      if (!italic) italic = isItalicFont(fontName);
+      if (!monospace) monospace = isMonospaceFont(fontName);
+      const info = { bold, italic, monospace };
+      fontInfoCache.set(fontName, info);
+      return info;
+    };
+    const lineGroups = [];
+    let currentLineItems = [];
+    let currentY = null;
+    const Y_TOLERANCE = 2;
+    const sorted = [...items].sort((a, b) => {
+      const yDiff = b.transform[5] - a.transform[5];
+      if (Math.abs(yDiff) > Y_TOLERANCE) return yDiff;
+      return a.transform[4] - b.transform[4];
+    });
+    for (const item of sorted) {
+      const y = item.transform[5];
+      if (currentY === null || Math.abs(y - currentY) > Y_TOLERANCE) {
+        if (currentLineItems.length > 0) lineGroups.push(currentLineItems);
+        currentLineItems = [item];
+        currentY = y;
+      } else {
+        currentLineItems.push(item);
+      }
+    }
+    if (currentLineItems.length > 0) lineGroups.push(currentLineItems);
+    for (const group of lineGroups) {
+      group.sort((a, b) => a.transform[4] - b.transform[4]);
+      const runs = group.filter((item) => item.str.length > 0).map((item) => {
+        const fontInfo = getFontInfo(item.fontName);
+        return {
+          text: item.str,
+          fontSize: Math.abs(item.transform[3]),
+          fontName: item.fontName,
+          x: item.transform[4],
+          y: item.transform[5],
+          width: item.width,
+          bold: fontInfo.bold,
+          italic: fontInfo.italic,
+          monospace: fontInfo.monospace
+        };
+      });
+      if (runs.length === 0) continue;
+      const firstRun = runs[0];
+      allLines.push({
+        runs,
+        y: firstRun.y,
+        x: firstRun.x,
+        fontSize: firstRun.fontSize,
+        fontName: firstRun.fontName,
+        bold: runs.every((r) => r.bold),
+        italic: runs.every((r) => r.italic),
+        monospace: runs.every((r) => r.monospace),
+        pageIndex: pageNum - 1
+      });
+    }
+  }
+  return allLines;
+}
+var BOLD_HEADING_MAX_LENGTH = 100;
+function normalizeForComparison(text) {
+  return text.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function groupLinesIntoParagraphs(lines, bodySize, headingLevels, boldHeadingLevel) {
+  const groups = [];
+  let currentGroup = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const roundedSize = Math.round(line.fontSize * 10) / 10;
+    let headingLevel = headingLevels.get(roundedSize);
+    const lineText = line.runs.map((r) => r.text).join("");
+    const listInfo = detectListType(lineText);
+    const isCode = line.monospace && !headingLevel;
+    if (!headingLevel && !isCode && line.bold && lineText.length > 0 && lineText.length <= BOLD_HEADING_MAX_LENGTH && Math.abs(roundedSize - bodySize) <= 1.5) {
+      headingLevel = boldHeadingLevel;
+    }
+    let lineType;
+    if (headingLevel) {
+      lineType = "heading";
+    } else if (isCode) {
+      lineType = "code";
+    } else if (listInfo) {
+      lineType = listInfo.type === "bullet" ? "list-bullet" : "list-numbered";
+    } else {
+      lineType = "paragraph";
+    }
+    const isPageBreak = i > 0 && lines[i - 1].pageIndex !== line.pageIndex;
+    const shouldStartNew = !currentGroup || isPageBreak || lineType === "heading" || currentGroup.type === "heading" || lineType === "list-bullet" || lineType === "list-numbered" || currentGroup.type === "list-bullet" || currentGroup.type === "list-numbered" || lineType === "code" !== (currentGroup.type === "code") || i > 0 && !isPageBreak && Math.abs(lines[i - 1].y - line.y) > line.fontSize * 1.8 && lineType !== "code";
+    if (shouldStartNew) {
+      if (currentGroup && currentGroup.lines.length > 0) groups.push(currentGroup);
+      currentGroup = { lines: [line], type: lineType, headingLevel };
+    } else {
+      currentGroup.lines.push(line);
+    }
+  }
+  if (currentGroup && currentGroup.lines.length > 0) groups.push(currentGroup);
+  return groups;
+}
+function runsToTextAndAnnotations(runs, allBold, allItalic) {
+  const annotations = [];
+  let text = "";
+  for (const run of runs) {
+    if (run.text.length === 0) continue;
+    const start = text.length;
+    text += run.text;
+    const end = text.length;
+    if (run.bold && !allBold) {
+      annotations.push({ type: "Bold", starts: [start], ends: [end] });
+    }
+    if (run.italic && !allItalic) {
+      annotations.push({ type: "Italic", starts: [start], ends: [end] });
+    }
+    if (run.monospace) {
+      annotations.push({ type: "Code", starts: [start], ends: [end] });
+    }
+  }
+  const merged = mergeAdjacentAnnotations(annotations);
+  return { text, annotations: merged };
+}
+function mergeAdjacentAnnotations(annotations) {
+  if (annotations.length <= 1) return annotations;
+  const byType = /* @__PURE__ */ new Map();
+  for (const ann of annotations) {
+    const list = byType.get(ann.type) || [];
+    list.push(ann);
+    byType.set(ann.type, list);
+  }
+  const result = [];
+  for (const [, anns] of Array.from(byType)) {
+    anns.sort((a, b) => (a.starts[0] ?? 0) - (b.starts[0] ?? 0));
+    let current = { ...anns[0], starts: [...anns[0].starts], ends: [...anns[0].ends] };
+    for (let i = 1; i < anns.length; i++) {
+      const next = anns[i];
+      if ((current.ends[0] ?? 0) >= (next.starts[0] ?? 0)) {
+        current.ends[0] = Math.max(current.ends[0] ?? 0, next.ends[0] ?? 0);
+      } else {
+        result.push(current);
+        current = { ...next, starts: [...next.starts], ends: [...next.ends] };
+      }
+    }
+    result.push(current);
+  }
+  result.sort((a, b) => (a.starts[0] ?? 0) - (b.starts[0] ?? 0));
+  return result;
+}
+function buildHierarchy2(blocks) {
+  const result = [];
+  const stack = [];
+  for (const { block, headingLevel } of blocks) {
+    if (headingLevel && headingLevel > 0) {
+      while (stack.length && stack[stack.length - 1].level >= headingLevel) {
+        stack.pop();
+      }
+      const parent = stack[stack.length - 1];
+      if (parent) {
+        if (!parent.node.children) parent.node.children = [];
+        parent.node.children.push(block);
+      } else {
+        result.push(block);
+      }
+      stack.push({ level: headingLevel, node: block });
+    } else {
+      const parent = stack[stack.length - 1];
+      if (parent) {
+        if (!parent.node.children) parent.node.children = [];
+        parent.node.children.push(block);
+      } else {
+        result.push(block);
+      }
+    }
+  }
+  return result;
+}
+async function extractTitle2(doc) {
+  var _a;
+  if (doc.numPages === 0) return void 0;
+  const page = await doc.getPage(1);
+  await page.getOperatorList();
+  const textContent = await page.getTextContent({ includeMarkedContent: false });
+  const items = textContent.items.filter(isTextItem);
+  if (items.length === 0) return void 0;
+  let maxFontSize = 0;
+  let titleItems = [];
+  for (const item of items) {
+    const fontSize = Math.abs(item.transform[3]);
+    if (fontSize > maxFontSize + 0.5) {
+      maxFontSize = fontSize;
+      titleItems = [item];
+    } else if (Math.abs(fontSize - maxFontSize) <= 0.5) {
+      titleItems.push(item);
+    }
+  }
+  const sizeCount = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const size = Math.round(Math.abs(item.transform[3]) * 10) / 10;
+    sizeCount.set(size, (sizeCount.get(size) || 0) + 1);
+  }
+  const bodySize = ((_a = Array.from(sizeCount.entries()).sort((a, b) => b[1] - a[1])[0]) == null ? void 0 : _a[0]) || 12;
+  if (maxFontSize <= bodySize + 0.5) {
+    return items.slice(0, 10).map((item) => item.str).join("").trim().slice(0, 100) || void 0;
+  }
+  titleItems.sort((a, b) => a.transform[4] - b.transform[4]);
+  return titleItems.map((item) => item.str).join("").trim() || void 0;
+}
+async function embeddedPdfToBlocks(pdfData) {
+  let pdfjsLib;
+  try {
+    pdfjsLib = await import("pdfjs-dist");
+  } catch {
+    throw new Error(
+      "pdfjs-dist is not installed. Install it for embedded PDF extraction:\n  pnpm add pdfjs-dist\nOr provide a GROBID server URL for higher-fidelity extraction."
+    );
+  }
+  const loadingTask = pdfjsLib.getDocument({ data: new Uint8Array(pdfData) });
+  const doc = await loadingTask.promise;
+  if (doc.numPages === 0) {
+    return { metadata: { name: void 0 }, blocks: [] };
+  }
+  const title = await extractTitle2(doc);
+  const lines = await extractTextRuns(doc);
+  if (lines.length === 0) {
+    return { metadata: { name: title }, blocks: [] };
+  }
+  const { bodySize, headingLevels, boldHeadingLevel } = clusterFontSizes(lines);
+  const paragraphGroups = groupLinesIntoParagraphs(lines, bodySize, headingLevels, boldHeadingLevel);
+  const flatBlocks = [];
+  for (const group of paragraphGroups) {
+    switch (group.type) {
+      case "heading": {
+        const allRuns = group.lines.flatMap((l) => l.runs);
+        const { text, annotations } = runsToTextAndAnnotations(allRuns, true, false);
+        if (text) {
+          flatBlocks.push({
+            block: makeHeading2(text, annotations),
+            headingLevel: group.headingLevel
+          });
+        }
+        break;
+      }
+      case "code": {
+        const codeText = group.lines.map((l) => l.runs.map((r) => r.text).join("")).join("\n");
+        if (codeText) {
+          flatBlocks.push({ block: makeCode2(codeText) });
+        }
+        break;
+      }
+      case "list-bullet":
+      case "list-numbered": {
+        const listType = group.type === "list-bullet" ? "Unordered" : "Ordered";
+        const items = [];
+        for (const line of group.lines) {
+          const lineText = line.runs.map((r) => r.text).join("");
+          const listInfo = detectListType(lineText);
+          const contentText = listInfo ? listInfo.content : lineText;
+          items.push(makeParagraph2(contentText));
+        }
+        if (items.length) {
+          flatBlocks.push({ block: makeList2(items, listType) });
+        }
+        break;
+      }
+      case "paragraph":
+      default: {
+        const allRuns = [];
+        const allBold = group.lines.every((l) => l.bold);
+        const allItalic = group.lines.every((l) => l.italic);
+        for (let i = 0; i < group.lines.length; i++) {
+          const line = group.lines[i];
+          if (i > 0 && allRuns.length > 0) {
+            const lastRun = allRuns[allRuns.length - 1];
+            if (lastRun.text.endsWith("-")) {
+              lastRun.text = lastRun.text.slice(0, -1);
+            } else if (!lastRun.text.endsWith(" ")) {
+              allRuns.push({ ...line.runs[0], text: " ", width: 0 });
+            }
+          }
+          allRuns.push(...line.runs);
+        }
+        const { text, annotations } = runsToTextAndAnnotations(allRuns, allBold, allItalic);
+        if (text) {
+          flatBlocks.push({ block: makeParagraph2(text, annotations) });
+        }
+        break;
+      }
+    }
+  }
+  const PAGE_NUMBER_RE = /^\d{1,3}$/;
+  for (let i = flatBlocks.length - 1; i >= 0; i--) {
+    const entry = flatBlocks[i];
+    if (entry.headingLevel) continue;
+    const blockText = (entry.block.block.text || "").trim();
+    if (PAGE_NUMBER_RE.test(blockText)) {
+      flatBlocks.splice(i, 1);
+    }
+  }
+  if (title && flatBlocks.length > 0) {
+    const first = flatBlocks[0];
+    if (first.headingLevel) {
+      const blockText = first.block.block.text || "";
+      if (normalizeForComparison(blockText) === normalizeForComparison(title)) {
+        flatBlocks.shift();
+      }
+    }
+  }
+  const blocks = buildHierarchy2(flatBlocks);
+  return { metadata: { name: title }, blocks };
+}
+
+// src/pdf-to-blocks.ts
+async function pdfToBlocks(pdfData, options = {}) {
+  const { grobidUrl, grobidTimeoutMs = 3e3, teiOptions = {}, grobidOptions = {} } = options;
+  if (grobidUrl) {
+    const available = await isGrobidAvailable(grobidUrl, grobidTimeoutMs);
+    if (!available) {
+      throw new Error(
+        `GROBID server is not reachable at ${grobidUrl}.
+Start a GROBID instance with:
+  docker run --rm -p 8070:8070 grobid/grobid:0.8.2-full`
+      );
+    }
+    return useGrobidExtraction(pdfData, grobidUrl, grobidOptions, teiOptions);
+  }
+  return useEmbeddedExtraction(pdfData);
+}
+async function useGrobidExtraction(pdfData, grobidUrl, grobidOpts, teiOpts) {
+  const teiXml = await processFulltextDocument(pdfData, {
+    grobidUrl,
+    teiCoordinates: grobidOpts.teiCoordinates || ["figure"]
+  });
+  const { metadata, blocks } = await teiToBlocks(teiXml, teiOpts);
+  return { metadata, blocks, source: "grobid" };
+}
+async function useEmbeddedExtraction(pdfData) {
+  const { metadata, blocks } = await embeddedPdfToBlocks(pdfData);
+  return {
+    metadata: {
+      name: metadata.name
+    },
+    blocks,
+    source: "embedded"
+  };
+}
+
+// src/file-to-ipfs.ts
+import { MemoryBlockstore } from "blockstore-core/memory";
+import { importer as unixFSImporter } from "ipfs-unixfs-importer";
+async function fileToIpfsBlobs(data) {
+  const blockstore = new MemoryBlockstore();
+  const results = unixFSImporter([{ content: data }], blockstore);
+  const result = await results.next();
+  if (!result.value) {
+    throw new Error("Failed to chunk file into IPFS blocks");
+  }
+  const rootCid = result.value.cid.toString();
+  const blobs = [];
+  for await (const pair of blockstore.getAll()) {
+    blobs.push({
+      cid: pair.cid.toString(),
+      data: pair.block
+    });
+  }
+  return { cid: rootCid, blobs };
+}
+async function filesToIpfsBlobs(binaries) {
+  const blockstore = new MemoryBlockstore();
+  const resultCIDs = [];
+  for (const binary of binaries) {
+    const results = unixFSImporter([{ content: binary }], blockstore);
+    const result = await results.next();
+    if (!result.value) {
+      throw new Error("Failed to chunk file into IPFS blocks");
+    }
+    resultCIDs.push(result.value.cid.toString());
+  }
+  const blobs = [];
+  for await (const pair of blockstore.getAll()) {
+    blobs.push({
+      cid: pair.cid.toString(),
+      data: pair.block
+    });
+  }
+  return { resultCIDs, blobs };
+}
+var FILE_PROTOCOL = "file://";
+function getBlockLink(block) {
+  const b = block;
+  return typeof b.link === "string" ? b.link : void 0;
+}
+function setBlockLink(block, link) {
+  return { ...block, link };
+}
+async function resolveFileLinksInBlocks(nodes, readFile) {
+  const blockstore = new MemoryBlockstore();
+  const cidMap = /* @__PURE__ */ new Map();
+  const resolved = await resolveNodes(nodes, blockstore, cidMap, readFile);
+  const blobs = [];
+  for await (const pair of blockstore.getAll()) {
+    blobs.push({
+      cid: pair.cid.toString(),
+      data: pair.block
+    });
+  }
+  return { nodes: resolved, blobs };
+}
+async function resolveNodes(nodes, blockstore, cidMap, readFile) {
+  const result = [];
+  for (const node of nodes) {
+    let resolvedBlock = node.block;
+    const link = getBlockLink(resolvedBlock);
+    if (link && link.startsWith(FILE_PROTOCOL)) {
+      const filePath = link.slice(FILE_PROTOCOL.length);
+      const ipfsUrl = await resolveFileToCid(filePath, blockstore, cidMap, readFile);
+      resolvedBlock = setBlockLink(resolvedBlock, ipfsUrl);
+    }
+    const resolvedChildren = node.children ? await resolveNodes(node.children, blockstore, cidMap, readFile) : void 0;
+    result.push({ block: resolvedBlock, children: resolvedChildren });
+  }
+  return result;
+}
+async function resolveFileToCid(filePath, blockstore, cidMap, readFile) {
+  const cached = cidMap.get(filePath);
+  if (cached) return cached;
+  const data = await readFile(filePath);
+  const results = unixFSImporter([{ content: data }], blockstore);
+  const result = await results.next();
+  if (!result.value) {
+    throw new Error(`Failed to process file for IPFS: ${filePath}`);
+  }
+  const ipfsUrl = `ipfs://${result.value.cid.toString()}`;
+  cidMap.set(filePath, ipfsUrl);
+  return ipfsUrl;
+}
+function hasFileLinks(nodes) {
+  for (const node of nodes) {
+    const link = getBlockLink(node.block);
+    if (link && link.startsWith(FILE_PROTOCOL)) {
+      return true;
+    }
+    if (node.children && hasFileLinks(node.children)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/markdown-to-blocks.ts
+import { parse as parseYaml } from "yaml";
+var ID_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-";
+function generateBlockId4() {
+  let id = "";
+  for (let i = 0; i < 8; i++) {
+    id += ID_CHARS[Math.floor(Math.random() * ID_CHARS.length)];
+  }
+  return id;
+}
+function parseInlineFormatting(raw) {
+  const annotations = [];
+  let text = "";
+  let i = 0;
+  while (i < raw.length) {
+    if (raw[i] === "\\" && i + 1 < raw.length) {
+      text += raw[i + 1];
+      i += 2;
+      continue;
+    }
+    if (raw[i] === "!" && i + 1 < raw.length && raw[i + 1] === "[") {
+      const closeBracket = findClosingBracket(raw, i + 1);
+      if (closeBracket !== -1 && closeBracket + 1 < raw.length && raw[closeBracket + 1] === "(") {
+        const closeParen = raw.indexOf(")", closeBracket + 2);
+        if (closeParen !== -1) {
+          const altText = raw.slice(i + 2, closeBracket);
+          if (altText) {
+            text += altText;
+          }
+          i = closeParen + 1;
+          continue;
+        }
+      }
+    }
+    if (raw[i] === "[") {
+      const closeBracket = findClosingBracket(raw, i);
+      if (closeBracket !== -1 && closeBracket + 1 < raw.length && raw[closeBracket + 1] === "(") {
+        const closeParen = raw.indexOf(")", closeBracket + 2);
+        if (closeParen !== -1) {
+          const linkText = raw.slice(i + 1, closeBracket);
+          const url = raw.slice(closeBracket + 2, closeParen);
+          const parsed = parseInlineFormatting(linkText);
+          const start = text.length;
+          text += parsed.text;
+          const end = text.length;
+          for (const ann of parsed.annotations) {
+            annotations.push({
+              ...ann,
+              starts: ann.starts.map((s) => s + start),
+              ends: ann.ends.map((e) => e + start)
+            });
+          }
+          annotations.push({
+            type: "Link",
+            starts: [start],
+            ends: [end],
+            link: url
+          });
+          i = closeParen + 1;
+          continue;
+        }
+      }
+    }
+    if (raw[i] === "*" && raw[i + 1] === "*") {
+      const end = raw.indexOf("**", i + 2);
+      if (end !== -1) {
+        const inner = raw.slice(i + 2, end);
+        const parsed = parseInlineFormatting(inner);
+        const start = text.length;
+        text += parsed.text;
+        for (const ann of parsed.annotations) {
+          annotations.push({
+            ...ann,
+            starts: ann.starts.map((s) => s + start),
+            ends: ann.ends.map((e) => e + start)
+          });
+        }
+        annotations.push({
+          type: "Bold",
+          starts: [start],
+          ends: [text.length]
+        });
+        i = end + 2;
+        continue;
+      }
+    }
+    if (raw[i] === "*" && raw[i + 1] !== "*") {
+      const end = findSingleDelimiter(raw, "*", i + 1);
+      if (end !== -1) {
+        const inner = raw.slice(i + 1, end);
+        const parsed = parseInlineFormatting(inner);
+        const start = text.length;
+        text += parsed.text;
+        for (const ann of parsed.annotations) {
+          annotations.push({
+            ...ann,
+            starts: ann.starts.map((s) => s + start),
+            ends: ann.ends.map((e) => e + start)
+          });
+        }
+        annotations.push({
+          type: "Italic",
+          starts: [start],
+          ends: [text.length]
+        });
+        i = end + 1;
+        continue;
+      }
+    }
+    if (raw[i] === "`") {
+      const end = raw.indexOf("`", i + 1);
+      if (end !== -1) {
+        const start = text.length;
+        text += raw.slice(i + 1, end);
+        annotations.push({
+          type: "Code",
+          starts: [start],
+          ends: [text.length]
+        });
+        i = end + 1;
+        continue;
+      }
+    }
+    text += raw[i];
+    i++;
+  }
+  return { text, annotations };
+}
+function findClosingBracket(s, openPos) {
+  let depth = 0;
+  for (let i = openPos; i < s.length; i++) {
+    if (s[i] === "[") depth++;
+    if (s[i] === "]") {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function findSingleDelimiter(s, delim, start) {
+  for (let i = start; i < s.length; i++) {
+    if (s[i] === delim && s[i + 1] !== delim && (i === 0 || s[i - 1] !== delim)) {
+      return i;
+    }
+  }
+  return -1;
+}
+var BLOCK_ID_RE = /\s*<!--\s*id:([A-Za-z0-9_-]+)\s*-->\s*$/;
+function stripBlockId(s) {
+  const m = s.match(BLOCK_ID_RE);
+  if (m) {
+    return { text: s.slice(0, m.index).trimEnd(), id: m[1] };
+  }
+  return { text: s };
+}
+var STANDALONE_ID_RE = /^\s*<!--\s*id:([A-Za-z0-9_-]+)\s*-->\s*$/;
+function tokenize(markdown) {
+  const lines = markdown.split("\n");
+  const blocks = [];
+  let i = 0;
+  let pendingContainerId;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === "") {
+      i++;
+      continue;
+    }
+    const standaloneMatch = line.match(STANDALONE_ID_RE);
+    if (standaloneMatch) {
+      pendingContainerId = standaloneMatch[1];
+      i++;
+      continue;
+    }
+    if (line.trim().startsWith("```")) {
+      const fenceContent = line.trim().slice(3).trim();
+      const { text: language, id } = stripBlockId(fenceContent);
+      const codeLines = [];
+      i++;
+      while (i < lines.length && !lines[i].trim().startsWith("```")) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      i++;
+      blocks.push({ kind: "code", language, text: codeLines.join("\n"), id });
+      pendingContainerId = void 0;
+      continue;
+    }
+    if (line.trim().startsWith("$$")) {
+      const fenceContent = line.trim().slice(2).trim();
+      const { id } = stripBlockId(fenceContent);
+      const mathLines = [];
+      i++;
+      while (i < lines.length && !lines[i].trim().startsWith("$$")) {
+        mathLines.push(lines[i]);
+        i++;
+      }
+      i++;
+      blocks.push({ kind: "math", text: mathLines.join("\n"), id });
+      pendingContainerId = void 0;
+      continue;
+    }
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      const { text, id } = stripBlockId(headingMatch[2]);
+      blocks.push({ kind: "heading", level: headingMatch[1].length, text, id });
+      i++;
+      pendingContainerId = void 0;
+      continue;
+    }
+    const imageMatch = line.trim().match(/^!\[([^\]]*)\]\(([^)]+)\)(.*)$/);
+    if (imageMatch) {
+      let url = imageMatch[2];
+      const trailing = imageMatch[3] || "";
+      const { id } = stripBlockId(trailing);
+      if (url && !url.match(/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//)) {
+        url = `file://${url}`;
+      }
+      blocks.push({ kind: "image", alt: imageMatch[1], url, id });
+      i++;
+      pendingContainerId = void 0;
+      continue;
+    }
+    if (line.trim().startsWith("|")) {
+      const tableLines = [];
+      while (i < lines.length && lines[i].trim().startsWith("|")) {
+        tableLines.push(lines[i]);
+        i++;
+      }
+      blocks.push({ kind: "table", text: tableLines.join("\n") });
+      pendingContainerId = void 0;
+      continue;
+    }
+    if (/^[-*+]\s+/.test(line.trim())) {
+      const items = [];
+      while (i < lines.length && /^[-*+]\s+/.test(lines[i].trim())) {
+        const raw = lines[i].trim().replace(/^[-*+]\s+/, "");
+        const { text, id } = stripBlockId(raw);
+        items.push({ text, id });
+        i++;
+      }
+      blocks.push({ kind: "ul", items, containerId: pendingContainerId });
+      pendingContainerId = void 0;
+      continue;
+    }
+    if (/^\d+\.\s+/.test(line.trim())) {
+      const items = [];
+      while (i < lines.length && /^\d+\.\s+/.test(lines[i].trim())) {
+        const raw = lines[i].trim().replace(/^\d+\.\s+/, "");
+        const { text, id } = stripBlockId(raw);
+        items.push({ text, id });
+        i++;
+      }
+      blocks.push({ kind: "ol", items, containerId: pendingContainerId });
+      pendingContainerId = void 0;
+      continue;
+    }
+    const paraLines = [];
+    while (i < lines.length && lines[i].trim() !== "" && !lines[i].trim().startsWith("```") && !lines[i].trim().startsWith("$$") && !lines[i].trim().startsWith("#") && !lines[i].trim().startsWith("|") && !lines[i].match(STANDALONE_ID_RE) && !/^!\[([^\]]*)\]\(([^)]+)\)/.test(lines[i].trim()) && !/^[-*+]\s+/.test(lines[i].trim()) && !/^\d+\.\s+/.test(lines[i].trim())) {
+      paraLines.push(lines[i]);
+      i++;
+    }
+    if (paraLines.length > 0) {
+      const firstLine = paraLines[0];
+      const { text: cleanFirst, id } = stripBlockId(firstLine);
+      paraLines[0] = cleanFirst;
+      blocks.push({ kind: "paragraph", text: paraLines.join("\n"), id });
+      pendingContainerId = void 0;
+    }
+  }
+  return blocks;
+}
+function makeBlockNode(block, children = []) {
+  return { block, children };
+}
+function createParagraphNode(rawText, id) {
+  const { text, annotations } = parseInlineFormatting(rawText);
+  return makeBlockNode({
+    type: "Paragraph",
+    id: id || generateBlockId4(),
+    text,
+    annotations
+  });
+}
+function createHeadingNode(rawText, id) {
+  const { text, annotations } = parseInlineFormatting(rawText);
+  return makeBlockNode(
+    {
+      type: "Heading",
+      id: id || generateBlockId4(),
+      text,
+      annotations,
+      childrenType: "Group"
+    },
+    []
+  );
+}
+function createCodeNode(text, language, id) {
+  return makeBlockNode({
+    type: "Code",
+    id: id || generateBlockId4(),
+    text,
+    annotations: [],
+    language: language || void 0
+  });
+}
+function createMathNode(text, id) {
+  return makeBlockNode({
+    type: "Math",
+    id: id || generateBlockId4(),
+    text,
+    annotations: []
+  });
+}
+function createImageNode(alt, url, id) {
+  return makeBlockNode({
+    type: "Image",
+    id: id || generateBlockId4(),
+    text: alt,
+    annotations: [],
+    link: url
+  });
+}
+function createListNode(items, listType, containerId) {
+  const children = items.map((item) => createParagraphNode(item.text, item.id));
+  const container = makeBlockNode(
+    {
+      type: "Paragraph",
+      id: containerId || generateBlockId4(),
+      text: "",
+      annotations: [],
+      childrenType: listType
+    },
+    children
+  );
+  return [container];
+}
+function coerceString(value) {
+  if (value == null) return void 0;
+  if (value instanceof Date) {
+    return value.toISOString().split("T")[0];
+  }
+  if (typeof value === "string") return value;
+  return String(value);
+}
+var METADATA_STRING_KEYS = [
+  "name",
+  "summary",
+  "displayAuthor",
+  "displayPublishTime",
+  "icon",
+  "cover",
+  "siteUrl",
+  "layout",
+  "seedExperimentalLogo",
+  "importCategories",
+  "importTags"
+];
+var METADATA_BOOLEAN_KEYS = ["showOutline", "showActivity"];
+var METADATA_ENUM_KEYS = ["seedExperimentalHomeOrder", "contentWidth"];
+function parseFrontmatter(markdown) {
+  const trimmed = markdown.trimStart();
+  if (!trimmed.startsWith("---")) {
+    return { content: markdown, metadata: {} };
+  }
+  const endIndex = trimmed.indexOf("\n---", 3);
+  if (endIndex === -1) {
+    return { content: markdown, metadata: {} };
+  }
+  const yamlBlock = trimmed.slice(3, endIndex).trim();
+  const rest = trimmed.slice(endIndex + 4);
+  const metadata = {};
+  try {
+    const parsed = parseYaml(yamlBlock);
+    if (!parsed || typeof parsed !== "object") {
+      return { content: rest, metadata };
+    }
+    for (const key of METADATA_STRING_KEYS) {
+      const val = coerceString(parsed[key]);
+      if (val !== void 0) metadata[key] = val;
+    }
+    if (!metadata.name && parsed["title"]) {
+      const val = coerceString(parsed["title"]);
+      if (val !== void 0) metadata.name = val;
+    }
+    for (const key of METADATA_BOOLEAN_KEYS) {
+      if (parsed[key] != null) metadata[key] = Boolean(parsed[key]);
+    }
+    for (const key of METADATA_ENUM_KEYS) {
+      const val = coerceString(parsed[key]);
+      if (val !== void 0) metadata[key] = val;
+    }
+    if (parsed["theme"] && typeof parsed["theme"] === "object") {
+      const themeInput = parsed["theme"];
+      const theme = {};
+      const hl = themeInput["headerLayout"];
+      if (hl === "Center" || hl === "") theme.headerLayout = hl;
+      if (Object.keys(theme).length > 0) metadata.theme = theme;
+    }
+  } catch {
+    return { content: markdown, metadata: {} };
+  }
+  return { content: rest, metadata };
+}
+function parseMarkdown(markdown) {
+  const { content, metadata } = parseFrontmatter(markdown);
+  const tokens = tokenize(content);
+  const rootNodes = [];
+  const headingStack = [];
+  function addToCurrentParent(node) {
+    const nodes = Array.isArray(node) ? node : [node];
+    if (headingStack.length === 0) {
+      rootNodes.push(...nodes);
+    } else {
+      const parent = headingStack[headingStack.length - 1].node;
+      parent.children.push(...nodes);
+    }
+  }
+  for (const token of tokens) {
+    switch (token.kind) {
+      case "heading": {
+        const headingNode = createHeadingNode(token.text, token.id);
+        while (headingStack.length > 0 && headingStack[headingStack.length - 1].level >= token.level) {
+          headingStack.pop();
+        }
+        addToCurrentParent(headingNode);
+        headingStack.push({ level: token.level, node: headingNode });
+        break;
+      }
+      case "paragraph":
+        addToCurrentParent(createParagraphNode(token.text, token.id));
+        break;
+      case "code":
+        addToCurrentParent(createCodeNode(token.text, token.language, token.id));
+        break;
+      case "math":
+        addToCurrentParent(createMathNode(token.text, token.id));
+        break;
+      case "image":
+        addToCurrentParent(createImageNode(token.alt, token.url, token.id));
+        break;
+      case "table":
+        addToCurrentParent(createCodeNode(token.text, "", token.id));
+        break;
+      case "ul":
+        addToCurrentParent(createListNode(token.items, "Unordered", token.containerId));
+        break;
+      case "ol":
+        addToCurrentParent(createListNode(token.items, "Ordered", token.containerId));
+        break;
+    }
+  }
+  return { tree: rootNodes, metadata };
+}
+function flattenToOperations(tree, parentId = "") {
+  const ops = [];
+  const blockIds = [];
+  for (const node of tree) {
+    const block = {
+      type: node.block.type,
+      id: node.block.id,
+      text: node.block.text,
+      annotations: node.block.annotations
+    };
+    if (node.block.language !== void 0) {
+      block["language"] = node.block.language;
+    }
+    if (node.block.childrenType !== void 0) {
+      block["childrenType"] = node.block.childrenType;
+    }
+    if (node.block.link !== void 0) {
+      block["link"] = node.block.link;
+    }
+    ops.push({ type: "ReplaceBlock", block });
+    blockIds.push(node.block.id);
+    if (node.children.length > 0) {
+      ops.push(...flattenToOperations(node.children, node.block.id));
+    }
+  }
+  if (blockIds.length > 0) {
+    ops.push({ type: "MoveBlocks", blocks: blockIds, parent: parentId });
+  }
+  return ops;
+}
+
+// src/blocks-to-markdown.ts
+var FM_STRING_KEYS = [
+  "name",
+  "summary",
+  "displayAuthor",
+  "displayPublishTime",
+  "icon",
+  "cover",
+  "siteUrl",
+  "layout",
+  "seedExperimentalLogo",
+  "seedExperimentalHomeOrder",
+  "contentWidth",
+  "importCategories",
+  "importTags"
+];
+var FM_BOOLEAN_KEYS = ["showOutline", "showActivity"];
+function emitFrontmatter(metadata) {
+  const lines = [];
+  for (const key of FM_STRING_KEYS) {
+    const val = metadata[key];
+    if (val !== void 0 && val !== "") {
+      lines.push(`${key}: ${JSON.stringify(val)}`);
+    }
+  }
+  for (const key of FM_BOOLEAN_KEYS) {
+    const val = metadata[key];
+    if (val !== void 0) {
+      lines.push(`${key}: ${val}`);
+    }
+  }
+  if (metadata.theme && typeof metadata.theme === "object") {
+    const entries = [];
+    if (metadata.theme.headerLayout !== void 0) {
+      entries.push(`  headerLayout: ${JSON.stringify(metadata.theme.headerLayout)}`);
+    }
+    if (entries.length > 0) {
+      lines.push("theme:");
+      lines.push(...entries);
+    }
+  }
+  if (lines.length === 0) return "---\n---\n";
+  return "---\n" + lines.join("\n") + "\n---\n";
+}
+function idComment(id) {
+  return `<!-- id:${id} -->`;
+}
+function appendIdToFirstLine(md, id) {
+  const newline = md.indexOf("\n");
+  if (newline === -1) {
+    return md ? `${md} ${idComment(id)}` : idComment(id);
+  }
+  return `${md.slice(0, newline)} ${idComment(id)}${md.slice(newline)}`;
+}
+function blocksToMarkdown(doc, options) {
+  const opts = { ipfsGateway: true, ...options };
+  const lines = [];
+  lines.push(emitFrontmatter(doc.metadata || {}));
+  for (const node of doc.content) {
+    const blockMd = blockNodeToMarkdown(node, 0, opts);
+    if (blockMd) {
+      lines.push(blockMd);
+    }
+  }
+  return lines.join("\n");
+}
+function blockNodeToMarkdown(node, depth, opts) {
+  var _a;
+  const block = node.block;
+  const children = node.children || [];
+  const childrenType = (_a = block.attributes) == null ? void 0 : _a.childrenType;
+  const isListContainer = block.type === "Paragraph" && !block.text && (childrenType === "Ordered" || childrenType === "Unordered" || childrenType === "Blockquote");
+  let result;
+  if (isListContainer) {
+    result = idComment(block.id);
+  } else {
+    result = blockToMarkdown(block, depth, opts);
+  }
+  for (const child of children) {
+    const childMd = blockNodeToMarkdown(child, depth + 1, opts);
+    if (childMd) {
+      if (childrenType === "Ordered") {
+        result += "\n" + indent(depth + 1) + "1. " + childMd.trim();
+      } else if (childrenType === "Unordered") {
+        result += "\n" + indent(depth + 1) + "- " + childMd.trim();
+      } else if (childrenType === "Blockquote") {
+        result += "\n" + indent(depth + 1) + "> " + childMd.trim();
+      } else {
+        result += "\n" + childMd;
+      }
+    }
+  }
+  return result;
+}
+function blockToMarkdown(block, depth, opts) {
+  var _a, _b;
+  const ind = indent(depth);
+  const b = block;
+  const text = b.text || "";
+  const link = b.link || "";
+  const annotations = b.annotations;
+  const id = b.id;
+  switch (block.type) {
+    case "Paragraph": {
+      const rendered = ind + applyAnnotations(text, annotations);
+      return appendIdToFirstLine(rendered, id);
+    }
+    case "Heading": {
+      const level = Math.min(depth + 1, 6);
+      const hashes = "#".repeat(level);
+      const rendered = `${hashes} ${applyAnnotations(text, annotations)}`;
+      return appendIdToFirstLine(rendered, id);
+    }
+    case "Code": {
+      const lang = ((_a = b.attributes) == null ? void 0 : _a.language) || "";
+      return ind + "```" + lang + " " + idComment(id) + "\n" + ind + text + "\n" + ind + "```";
+    }
+    case "Math": {
+      return ind + "$$ " + idComment(id) + "\n" + ind + text + "\n" + ind + "$$";
+    }
+    case "Image": {
+      const altText = text || "image";
+      const imgUrl = formatMediaUrl(link, opts.ipfsGateway);
+      return ind + `![${altText}](${imgUrl}) ${idComment(id)}`;
+    }
+    case "Video": {
+      const videoUrl = formatMediaUrl(link, opts.ipfsGateway);
+      return ind + `[Video](${videoUrl}) ${idComment(id)}`;
+    }
+    case "File": {
+      const fileName = ((_b = b.attributes) == null ? void 0 : _b.name) || "file";
+      const fileUrl = formatMediaUrl(link, opts.ipfsGateway);
+      return ind + `[${fileName}](${fileUrl}) ${idComment(id)}`;
+    }
+    case "Embed": {
+      return ind + `> [Embed: ${link}](${link}) ${idComment(id)}`;
+    }
+    case "WebEmbed": {
+      return ind + `[Web Embed](${link}) ${idComment(id)}`;
+    }
+    case "Button": {
+      const buttonText = text || "Button";
+      return ind + `[${buttonText}](${link}) ${idComment(id)}`;
+    }
+    case "Query": {
+      return ind + `<!-- Query block --> ${idComment(id)}`;
+    }
+    case "Nostr": {
+      return ind + `[Nostr: ${link}](${link}) ${idComment(id)}`;
+    }
+    default: {
+      if (text) {
+        return appendIdToFirstLine(ind + text, id);
+      }
+      return "";
+    }
+  }
+}
+function applyAnnotations(text, annotations) {
+  if (!annotations || annotations.length === 0) {
+    return text;
+  }
+  const markers = [];
+  for (const ann of annotations) {
+    const starts = ann.starts || [];
+    const ends = ann.ends || [];
+    for (let i = 0; i < starts.length; i++) {
+      markers.push({ pos: starts[i], type: "open", annotation: ann });
+      if (ends[i] !== void 0) {
+        markers.push({ pos: ends[i], type: "close", annotation: ann });
+      }
+    }
+  }
+  markers.sort((a, b) => {
+    if (a.pos !== b.pos) return a.pos - b.pos;
+    return a.type === "open" ? -1 : 1;
+  });
+  let result = "";
+  let lastPos = 0;
+  for (const marker of markers) {
+    result += text.slice(lastPos, marker.pos);
+    lastPos = marker.pos;
+    result += getAnnotationMarker(marker.annotation, marker.type);
+  }
+  result += text.slice(lastPos);
+  result = result.replace(/\uFFFC/g, "");
+  return result;
+}
+function getAnnotationMarker(ann, type) {
+  switch (ann.type) {
+    case "Bold":
+      return "**";
+    case "Italic":
+      return "_";
+    case "Strike":
+      return "~~";
+    case "Code":
+      return "`";
+    case "Underline":
+      return type === "open" ? "<u>" : "</u>";
+    case "Link":
+      if (type === "open") {
+        return "[";
+      } else {
+        return `](${ann.link || ""})`;
+      }
+    case "Embed": {
+      const link = "link" in ann ? ann.link || "" : "";
+      if (type === "open") {
+        const pathPart = link.includes("/") ? link.split("/").pop() || "embed" : link.replace("hm://", "").slice(0, 12);
+        return `[\u2197 ${pathPart}`;
+      } else {
+        return `](${link})`;
+      }
+    }
+    default:
+      return "";
+  }
+}
+function formatMediaUrl(url, useGateway) {
+  if (useGateway && url.startsWith("ipfs://")) {
+    const cid = url.slice(7);
+    return `https://ipfs.io/ipfs/${cid}`;
+  }
+  return url;
+}
+function indent(depth) {
+  return "  ".repeat(depth);
+}
+
+// src/block-diff.ts
+function createBlocksMap(nodes, parentId = "") {
+  const result = {};
+  nodes.forEach((node, idx) => {
+    var _a, _b, _c;
+    if (!((_a = node.block) == null ? void 0 : _a.id)) return;
+    const prev = idx > 0 ? nodes[idx - 1] : void 0;
+    const prevId = ((_b = prev == null ? void 0 : prev.block) == null ? void 0 : _b.id) || "";
+    result[node.block.id] = {
+      parent: parentId,
+      left: prevId,
+      block: node.block
+    };
+    if ((_c = node.children) == null ? void 0 : _c.length) {
+      Object.assign(result, createBlocksMap(node.children, node.block.id));
+    }
+  });
+  return result;
+}
+function matchBlockIds(oldNodes, newNodes) {
+  return newNodes.map((newNode, idx) => {
+    const oldNode = idx < oldNodes.length ? oldNodes[idx] : void 0;
+    let matchedId = newNode.block.id;
+    if (oldNode && oldNode.block.type === newNode.block.type) {
+      matchedId = oldNode.block.id;
+    }
+    const matchedChildren = matchBlockIds((oldNode == null ? void 0 : oldNode.children) ?? [], newNode.children);
+    return {
+      block: { ...newNode.block, id: matchedId },
+      children: matchedChildren
+    };
+  });
+}
+function computeReplaceOps(oldMap, matchedTree, parentId = "") {
+  const ops = [];
+  const touchedIds = /* @__PURE__ */ new Set();
+  const blockIdsAtLevel = [];
+  matchedTree.forEach((node, idx) => {
+    const blockId = node.block.id;
+    touchedIds.add(blockId);
+    blockIdsAtLevel.push(blockId);
+    const oldEntry = oldMap[blockId];
+    const isNew = !oldEntry;
+    const block = {
+      type: node.block.type,
+      id: blockId,
+      text: node.block.text,
+      annotations: node.block.annotations
+    };
+    if (node.block.language !== void 0) {
+      block.language = node.block.language;
+    }
+    if (node.block.childrenType !== void 0) {
+      block.childrenType = node.block.childrenType;
+    }
+    if (isNew) {
+      ops.push({ type: "ReplaceBlock", block });
+    } else {
+      if (!isBlockContentEqual(oldEntry.block, node.block)) {
+        ops.push({ type: "ReplaceBlock", block });
+      }
+      const prevNode = idx > 0 ? matchedTree[idx - 1] : void 0;
+      const expectedLeft = (prevNode == null ? void 0 : prevNode.block.id) ?? "";
+      if (oldEntry.parent !== parentId || oldEntry.left !== expectedLeft) {
+      }
+    }
+    if (node.children.length > 0) {
+      const childOps = computeReplaceOps(oldMap, node.children, blockId);
+      ops.push(...childOps);
+      collectIds(node.children, touchedIds);
+    }
+  });
+  if (blockIdsAtLevel.length > 0) {
+    ops.push({
+      type: "MoveBlocks",
+      blocks: blockIdsAtLevel,
+      parent: parentId
+    });
+  }
+  const deletedIds = [];
+  for (const [id, entry] of Object.entries(oldMap)) {
+    if (entry.parent === parentId && !touchedIds.has(id)) {
+      deletedIds.push(id);
+    }
+  }
+  if (deletedIds.length > 0) {
+    ops.push({ type: "DeleteBlocks", blocks: deletedIds });
+  }
+  return ops;
+}
+function collectIds(nodes, set) {
+  for (const node of nodes) {
+    set.add(node.block.id);
+    collectIds(node.children, set);
+  }
+}
+function isBlockContentEqual(old, newBlock) {
+  if (old.type !== newBlock.type) return false;
+  if ((old.text || "") !== (newBlock.text || "")) return false;
+  const oldAnn = old.annotations || [];
+  const newAnn = newBlock.annotations || [];
+  if (oldAnn.length !== newAnn.length) return false;
+  if (oldAnn.length > 0 && JSON.stringify(oldAnn) !== JSON.stringify(newAnn)) {
+    return false;
+  }
+  const oldAttrs = old.attributes || {};
+  if ((oldAttrs.childrenType || "") !== (newBlock.childrenType || "")) {
+    return false;
+  }
+  if ((oldAttrs.language || "") !== (newBlock.language || "")) return false;
+  return true;
+}
+function hmBlockNodeToBlockNode(node) {
+  const b = node.block;
+  const attrs = b.attributes || {};
+  const block = {
+    type: b.type || "",
+    id: b.id || "",
+    text: b.text || "",
+    annotations: b.annotations || [],
+    ...attrs.childrenType ? { childrenType: attrs.childrenType } : {},
+    ...attrs.language ? { language: attrs.language } : {},
+    ...b.link ? { link: b.link } : {}
+  };
+  return {
+    block,
+    children: (node.children || []).map(hmBlockNodeToBlockNode)
+  };
+}
+
+// src/document-state.ts
+async function resolveDocumentState(client, targetId) {
+  const unpacked = unpackHmId(targetId);
+  if (!unpacked) throw new Error(`Invalid ID: ${targetId}`);
+  const changesResp = await client.request("ListChanges", { targetId: unpacked });
+  if (!changesResp.changes || changesResp.changes.length === 0) {
+    throw new Error(`No changes found for ${targetId}. Document may not exist.`);
+  }
+  const depthMap = computeDepths(changesResp);
+  let genesis = "";
+  for (const change of changesResp.changes) {
+    if (!change.deps || change.deps.length === 0) {
+      genesis = change.id;
+      break;
+    }
+  }
+  if (!genesis) {
+    throw new Error("Could not find genesis change (change with no deps).");
+  }
+  const allDeps = /* @__PURE__ */ new Set();
+  for (const change of changesResp.changes) {
+    if (change.deps) {
+      for (const dep of change.deps) {
+        allDeps.add(dep);
+      }
+    }
+  }
+  const heads = [];
+  for (const change of changesResp.changes) {
+    if (change.id && !allDeps.has(change.id)) {
+      heads.push(change.id);
+    }
+  }
+  if (heads.length === 0) {
+    throw new Error("Could not determine document heads.");
+  }
+  let maxHeadDepth = 0;
+  for (const head of heads) {
+    const d = depthMap.get(head) ?? 0;
+    if (d > maxHeadDepth) maxHeadDepth = d;
+  }
+  const version = heads.join(".");
+  return {
+    genesis,
+    heads,
+    headDepth: maxHeadDepth,
+    version
+  };
+}
+function computeDepths(changesResp) {
+  const depthMap = /* @__PURE__ */ new Map();
+  const depsMap = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  for (const change of changesResp.changes) {
+    const id = change.id;
+    const deps = change.deps ?? [];
+    depsMap.set(id, deps);
+    for (const dep of deps) {
+      const existing = dependents.get(dep) ?? [];
+      existing.push(id);
+      dependents.set(dep, existing);
+    }
+  }
+  const queue = [];
+  for (const change of changesResp.changes) {
+    const deps = change.deps ?? [];
+    if (deps.length === 0) {
+      depthMap.set(change.id, 0);
+      queue.push(change.id);
+    }
+  }
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const children = dependents.get(current) ?? [];
+    for (const child of children) {
+      const childDeps = depsMap.get(child) ?? [];
+      let allResolved = true;
+      let maxDepDepth = 0;
+      for (const dep of childDeps) {
+        const d = depthMap.get(dep);
+        if (d === void 0) {
+          allResolved = false;
+          break;
+        }
+        if (d > maxDepDepth) maxDepDepth = d;
+      }
+      if (allResolved && !depthMap.has(child)) {
+        depthMap.set(child, maxDepDepth + 1);
+        queue.push(child);
+      }
+    }
+  }
+  return depthMap;
+}
+
+// src/auto-link.ts
+import { CID as CID4 } from "multiformats/cid";
+function documentContainsLinkToChild(document, childId) {
+  const childUrlNormalized = packHmId({ ...childId, version: null, latest: null });
+  function searchBlocks(nodes) {
+    for (const node of nodes) {
+      if (node.block.type === "Embed") {
+        const linkId = unpackHmId(node.block.link);
+        if (linkId) {
+          const linkUrl = packHmId({ ...linkId, version: null, latest: null });
+          if (linkUrl === childUrlNormalized) return true;
+        }
+      }
+      const annotations = "annotations" in node.block ? node.block.annotations : void 0;
+      if (annotations) {
+        for (const ann of annotations) {
+          if (ann.type === "Link" || ann.type === "Embed") {
+            const linkId = unpackHmId(ann.link);
+            if (linkId) {
+              const linkUrl = packHmId({ ...linkId, version: null, latest: null });
+              if (linkUrl === childUrlNormalized) return true;
+            }
+          }
+        }
+      }
+      if (node.children && searchBlocks(node.children)) return true;
+    }
+    return false;
+  }
+  return searchBlocks(document.content || []);
+}
+function documentHasSelfQuery(document, documentId) {
+  var _a;
+  const documentPathWithSlash = hmIdPathToEntityQueryPath(documentId.path);
+  const documentPathWithoutSlash = ((_a = documentId.path) == null ? void 0 : _a.join("/")) || "";
+  function searchBlocks(nodes) {
+    var _a2;
+    for (const node of nodes) {
+      if (node.block.type === "Query") {
+        const query = (_a2 = node.block.attributes) == null ? void 0 : _a2.query;
+        if (query == null ? void 0 : query.includes) {
+          for (const inc of query.includes) {
+            const isSpaceMatch = !inc.space || inc.space === documentId.uid;
+            const isPathMatch = !inc.path || inc.path === documentPathWithSlash || inc.path === documentPathWithoutSlash;
+            if (isSpaceMatch && isPathMatch) return true;
+          }
+        }
+      }
+      if (node.children && searchBlocks(node.children)) return true;
+    }
+    return false;
+  }
+  return searchBlocks(document.content || []);
+}
+function shouldAutoLinkParent(isPrivate, parentDocument, editableLocation, parentId) {
+  if (isPrivate) return false;
+  if (parentDocument) {
+    if (documentContainsLinkToChild(parentDocument, editableLocation)) {
+      return false;
+    }
+    if (documentHasSelfQuery(parentDocument, parentId)) {
+      return false;
+    }
+  }
+  return true;
+}
+function createAutoLinkOps(parentDocument, childHmUrl, newBlockId) {
+  const existingRootBlockIds = (parentDocument.content || []).map((node) => node.block.id).filter(Boolean);
+  const embedBlock = {
+    id: newBlockId,
+    type: "Embed",
+    link: childHmUrl,
+    attributes: { view: "Card" }
+  };
+  return [
+    { type: "ReplaceBlock", block: embedBlock },
+    { type: "MoveBlocks", blocks: [...existingRootBlockIds, newBlockId], parent: "" }
+  ];
+}
+async function autoLinkChildToParent(opts) {
+  const { client, account, path, childHmUrl, signer } = opts;
+  const segments = path.replace(/^\//, "").split("/");
+  if (segments.length <= 1) return false;
+  const parentSegments = segments.slice(0, -1);
+  const parentPath = "/" + parentSegments.join("/");
+  const parentId = unpackHmId(`hm://${account}${parentPath}`);
+  if (!parentId) return false;
+  const childId = unpackHmId(childHmUrl);
+  if (!childId) return false;
+  let parentDocument = null;
+  try {
+    const resource = await client.request("Resource", { ...parentId, latest: true });
+    if (resource.type === "document") {
+      parentDocument = resource.document;
+    }
+  } catch {
+    return false;
+  }
+  if (!parentDocument) return false;
+  if (!shouldAutoLinkParent(false, parentDocument, childId, parentId)) {
+    return false;
+  }
+  const newBlockId = generateBlockId5();
+  const ops = createAutoLinkOps(parentDocument, childHmUrl, newBlockId);
+  const hmUrl = `hm://${account}${parentPath}`;
+  const state = await resolveDocumentState(client, hmUrl);
+  const genesisCid = CID4.parse(state.genesis);
+  const depCids = state.heads.map((h) => CID4.parse(h));
+  const newDepth = state.headDepth + 1;
+  const { unsignedBytes, ts } = createChangeOps({ ops, genesisCid, deps: depCids, depth: newDepth });
+  const changeBlock = await createChange(unsignedBytes, signer);
+  const generation = Number(ts);
+  const refInput = await createVersionRef(
+    {
+      space: account,
+      path: parentPath,
+      genesis: state.genesis,
+      version: changeBlock.cid.toString(),
+      generation
+    },
+    signer
+  );
+  await client.publish({
+    blobs: [{ data: new Uint8Array(changeBlock.bytes), cid: changeBlock.cid.toString() }, ...refInput.blobs]
+  });
+  return true;
+}
+function generateBlockId5() {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let id = "";
+  const bytes = new Uint8Array(10);
+  crypto.getRandomValues(bytes);
+  for (let i = 0; i < 10; i++) {
+    id += chars[bytes[i] % chars.length];
+  }
+  return id;
 }
 export {
+  DEFAULT_GROBID_URL,
   HYPERMEDIA_SCHEME,
   SeedClientError,
   SeedNetworkError,
   SeedValidationError,
+  autoLinkChildToParent,
+  blocksToMarkdown,
+  codePointLength,
+  commentRecordIdFromBlob,
+  computeReplaceOps,
   contactRecordIdFromBlob,
+  createAutoLinkOps,
+  createBlocksMap,
   createCapability,
   createChange,
   createChangeOps,
@@ -878,14 +3168,38 @@ export {
   createVersionRef,
   deleteComment,
   deleteContact,
+  documentContainsLinkToChild,
+  documentHasSelfQuery,
+  embeddedPdfToBlocks,
+  emitFrontmatter,
   entityQueryPathToHmIdPath,
+  fileToIpfsBlobs,
+  filesToIpfsBlobs,
+  flattenToOperations,
   getHMQueryString,
+  hasFileLinks,
+  hmBlockNodeToBlockNode,
   hmIdPathToEntityQueryPath,
+  isGrobidAvailable,
+  isSurrogate,
+  matchBlockIds,
   packBaseId,
   packHmId,
+  parseCustomURL,
+  parseFragment,
+  parseFrontmatter,
+  parseInlineFormatting,
+  parseMarkdown,
+  pdfToBlocks,
+  processFulltextDocument,
+  resolveDocumentState,
+  resolveFileLinksInBlocks,
   serializeBlockRange,
+  shouldAutoLinkParent,
   signDocumentChange,
   signPreparedChange,
+  teiToBlocks,
   trimTrailingEmptyBlocks,
+  unpackHmId,
   updateContact
 };