@particle-academy/last-word 0.1.0

package/dist/index.js

@@ -0,0 +1,2419 @@
+// src/exceptions.ts
+var SchemaException = class _SchemaException extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.name = "SchemaException";
+    this.errors = errors;
+    Object.setPrototypeOf(this, _SchemaException.prototype);
+  }
+};
+
+// src/helpers/image-size.ts
+function base64Decode(b64) {
+  if (typeof Buffer !== "undefined") {
+    const buf = Buffer.from(b64, "base64");
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  const bin = atob(b64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+function base64Encode(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
+  }
+  let bin = "";
+  for (let i = 0; i < bytes.length; i++) bin += String.fromCharCode(bytes[i]);
+  return btoa(bin);
+}
+function parseDataUrl(src) {
+  const m = /^data:([^;,]+);base64,([\s\S]*)$/.exec(src);
+  if (!m) return null;
+  try {
+    return { mime: m[1].toLowerCase(), bytes: base64Decode(m[2].replace(/\s+/g, "")) };
+  } catch {
+    return null;
+  }
+}
+function pngSize(bytes) {
+  if (bytes.length < 24) return null;
+  const sig = [137, 80, 78, 71, 13, 10, 26, 10];
+  for (let i = 0; i < 8; i++) {
+    if (bytes[i] !== sig[i]) return null;
+  }
+  if (bytes[12] !== 73 || bytes[13] !== 72 || bytes[14] !== 68 || bytes[15] !== 82) return null;
+  const width = bytes[16] << 24 | bytes[17] << 16 | bytes[18] << 8 | bytes[19];
+  const height = bytes[20] << 24 | bytes[21] << 16 | bytes[22] << 8 | bytes[23];
+  if (width <= 0 || height <= 0) return null;
+  return { width, height };
+}
+function jpegSize(bytes) {
+  if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216) return null;
+  let i = 2;
+  while (i + 9 < bytes.length) {
+    if (bytes[i] !== 255) {
+      i++;
+      continue;
+    }
+    const marker = bytes[i + 1];
+    if (marker === 216 || marker >= 208 && marker <= 215 || marker === 1 || marker === 255) {
+      i += 2;
+      continue;
+    }
+    const length = bytes[i + 2] << 8 | bytes[i + 3];
+    const isSof = marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204;
+    if (isSof) {
+      const height = bytes[i + 5] << 8 | bytes[i + 6];
+      const width = bytes[i + 7] << 8 | bytes[i + 8];
+      if (width <= 0 || height <= 0) return null;
+      return { width, height };
+    }
+    if (marker === 217 || marker === 218) break;
+    i += 2 + length;
+  }
+  return null;
+}
+function sniffImageSize(bytes) {
+  return pngSize(bytes) ?? jpegSize(bytes);
+}
+
+// src/zip/crc32.ts
+var TABLE = /* @__PURE__ */ (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+function crc32(bytes) {
+  let crc = 4294967295;
+  for (let i = 0; i < bytes.length; i++) {
+    crc = TABLE[(crc ^ bytes[i]) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+
+// src/zip/zip-writer.ts
+var encoder = new TextEncoder();
+var DOS_TIME = 0;
+var DOS_DATE = 33;
+function zipSync(files) {
+  const localParts = [];
+  const centralParts = [];
+  let offset = 0;
+  for (const f of files) {
+    const nameBytes = encoder.encode(f.name);
+    const crc = crc32(f.data);
+    const size = f.data.length;
+    const lh = new Uint8Array(30 + nameBytes.length);
+    const ldv = new DataView(lh.buffer);
+    ldv.setUint32(0, 67324752, true);
+    ldv.setUint16(4, 20, true);
+    ldv.setUint16(6, 2048, true);
+    ldv.setUint16(8, 0, true);
+    ldv.setUint16(10, DOS_TIME, true);
+    ldv.setUint16(12, DOS_DATE, true);
+    ldv.setUint32(14, crc, true);
+    ldv.setUint32(18, size, true);
+    ldv.setUint32(22, size, true);
+    ldv.setUint16(26, nameBytes.length, true);
+    ldv.setUint16(28, 0, true);
+    lh.set(nameBytes, 30);
+    localParts.push(lh, f.data);
+    const cd = new Uint8Array(46 + nameBytes.length);
+    const cdv = new DataView(cd.buffer);
+    cdv.setUint32(0, 33639248, true);
+    cdv.setUint16(4, 20, true);
+    cdv.setUint16(6, 20, true);
+    cdv.setUint16(8, 2048, true);
+    cdv.setUint16(10, 0, true);
+    cdv.setUint16(12, DOS_TIME, true);
+    cdv.setUint16(14, DOS_DATE, true);
+    cdv.setUint32(16, crc, true);
+    cdv.setUint32(20, size, true);
+    cdv.setUint32(24, size, true);
+    cdv.setUint16(28, nameBytes.length, true);
+    cdv.setUint16(30, 0, true);
+    cdv.setUint16(32, 0, true);
+    cdv.setUint16(34, 0, true);
+    cdv.setUint16(36, 0, true);
+    cdv.setUint32(38, 0, true);
+    cdv.setUint32(42, offset, true);
+    cd.set(nameBytes, 46);
+    centralParts.push(cd);
+    offset += lh.length + f.data.length;
+  }
+  const localSize = offset;
+  const centralSize = centralParts.reduce((s, c) => s + c.length, 0);
+  const eocd = new Uint8Array(22);
+  const edv = new DataView(eocd.buffer);
+  edv.setUint32(0, 101010256, true);
+  edv.setUint16(4, 0, true);
+  edv.setUint16(6, 0, true);
+  edv.setUint16(8, files.length, true);
+  edv.setUint16(10, files.length, true);
+  edv.setUint32(12, centralSize, true);
+  edv.setUint32(16, localSize, true);
+  edv.setUint16(20, 0, true);
+  const out = new Uint8Array(localSize + centralSize + 22);
+  let p = 0;
+  for (const part of localParts) {
+    out.set(part, p);
+    p += part.length;
+  }
+  for (const part of centralParts) {
+    out.set(part, p);
+    p += part.length;
+  }
+  out.set(eocd, p);
+  return out;
+}
+
+// src/zip/inflate.ts
+var Tree = class {
+  constructor() {
+    // number of codes with a given bit length
+    this.table = new Uint16Array(16);
+    // symbols sorted by code
+    this.trans = new Uint16Array(288);
+  }
+};
+var LENGTH_BITS = new Uint8Array([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0
+]);
+var LENGTH_BASE = new Uint16Array([
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  13,
+  15,
+  17,
+  19,
+  23,
+  27,
+  31,
+  35,
+  43,
+  51,
+  59,
+  67,
+  83,
+  99,
+  115,
+  131,
+  163,
+  195,
+  227,
+  258
+]);
+var DIST_BITS = new Uint8Array([
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13
+]);
+var DIST_BASE = new Uint16Array([
+  1,
+  2,
+  3,
+  4,
+  5,
+  7,
+  9,
+  13,
+  17,
+  25,
+  33,
+  49,
+  65,
+  97,
+  129,
+  193,
+  257,
+  385,
+  513,
+  769,
+  1025,
+  1537,
+  2049,
+  3073,
+  4097,
+  6145,
+  8193,
+  12289,
+  16385,
+  24577
+]);
+var CLC_INDEX = new Uint8Array([
+  16,
+  17,
+  18,
+  0,
+  8,
+  7,
+  9,
+  6,
+  10,
+  5,
+  11,
+  4,
+  12,
+  3,
+  13,
+  2,
+  14,
+  1,
+  15
+]);
+function buildFixedTrees(lt, dt) {
+  let i;
+  for (i = 0; i < 7; i++) lt.table[i] = 0;
+  lt.table[7] = 24;
+  lt.table[8] = 152;
+  lt.table[9] = 112;
+  for (i = 0; i < 24; i++) lt.trans[i] = 256 + i;
+  for (i = 0; i < 144; i++) lt.trans[24 + i] = i;
+  for (i = 0; i < 8; i++) lt.trans[24 + 144 + i] = 280 + i;
+  for (i = 0; i < 112; i++) lt.trans[24 + 144 + 8 + i] = 144 + i;
+  for (i = 0; i < 5; i++) dt.table[i] = 0;
+  dt.table[5] = 32;
+  for (i = 0; i < 32; i++) dt.trans[i] = i;
+}
+var OFFS = new Uint16Array(16);
+function buildTree(t, lengths, off, num) {
+  let i;
+  let sum = 0;
+  for (i = 0; i < 16; i++) t.table[i] = 0;
+  for (i = 0; i < num; i++) t.table[lengths[off + i]]++;
+  t.table[0] = 0;
+  for (i = 0; i < 16; i++) {
+    OFFS[i] = sum;
+    sum += t.table[i];
+  }
+  for (i = 0; i < num; i++) {
+    const len = lengths[off + i];
+    if (len) t.trans[OFFS[len]++] = i;
+  }
+}
+var Reader = class {
+  constructor(source) {
+    this.index = 0;
+    this.tag = 0;
+    this.bitcount = 0;
+    this.source = source;
+  }
+};
+function getBit(d) {
+  if (d.bitcount-- === 0) {
+    d.tag = d.source[d.index++];
+    d.bitcount = 7;
+  }
+  const bit = d.tag & 1;
+  d.tag >>>= 1;
+  return bit;
+}
+function readBits(d, num, base) {
+  if (!num) return base;
+  let val = 0;
+  for (let i = 0; i < num; i++) val |= getBit(d) << i;
+  return val + base;
+}
+function decodeSymbol(d, t) {
+  let sum = 0;
+  let cur = 0;
+  let len = 0;
+  do {
+    cur = 2 * cur + getBit(d);
+    len++;
+    sum += t.table[len];
+    cur -= t.table[len];
+  } while (cur >= 0);
+  return t.trans[sum + cur];
+}
+function decodeTrees(d, lt, dt) {
+  const lengths = new Uint8Array(288 + 32);
+  const hlit = readBits(d, 5, 257);
+  const hdist = readBits(d, 5, 1);
+  const hclen = readBits(d, 4, 4);
+  let i;
+  for (i = 0; i < 19; i++) lengths[i] = 0;
+  for (i = 0; i < hclen; i++) {
+    const clen = readBits(d, 3, 0);
+    lengths[CLC_INDEX[i]] = clen;
+  }
+  const codeTree = new Tree();
+  buildTree(codeTree, lengths, 0, 19);
+  for (let num = 0; num < hlit + hdist; ) {
+    const sym = decodeSymbol(d, codeTree);
+    switch (sym) {
+      case 16: {
+        const prev = lengths[num - 1];
+        for (let length = readBits(d, 2, 3); length; length--) lengths[num++] = prev;
+        break;
+      }
+      case 17:
+        for (let length = readBits(d, 3, 3); length; length--) lengths[num++] = 0;
+        break;
+      case 18:
+        for (let length = readBits(d, 7, 11); length; length--) lengths[num++] = 0;
+        break;
+      default:
+        lengths[num++] = sym;
+        break;
+    }
+  }
+  buildTree(lt, lengths, 0, hlit);
+  buildTree(dt, lengths, hlit, hdist);
+}
+var Out = class {
+  constructor() {
+    this.buf = new Uint8Array(1024);
+    this.len = 0;
+  }
+  push(b) {
+    if (this.len >= this.buf.length) {
+      const next = new Uint8Array(this.buf.length * 2);
+      next.set(this.buf);
+      this.buf = next;
+    }
+    this.buf[this.len++] = b;
+  }
+};
+function inflateBlockData(d, out, lt, dt) {
+  for (; ; ) {
+    const sym = decodeSymbol(d, lt);
+    if (sym === 256) return;
+    if (sym < 256) {
+      out.push(sym);
+    } else {
+      const lengthSym = sym - 257;
+      const length = readBits(d, LENGTH_BITS[lengthSym], LENGTH_BASE[lengthSym]);
+      const distSym = decodeSymbol(d, dt);
+      const dist = readBits(d, DIST_BITS[distSym], DIST_BASE[distSym]);
+      const offs = out.len - dist;
+      for (let i = 0; i < length; i++) out.push(out.buf[offs + i]);
+    }
+  }
+}
+function inflateUncompressedBlock(d, out) {
+  d.bitcount = 0;
+  let length = d.source[d.index + 1] * 256 + d.source[d.index];
+  d.index += 4;
+  for (; length; length--) out.push(d.source[d.index++]);
+}
+function inflateRaw(source) {
+  const d = new Reader(source);
+  const out = new Out();
+  const lt = new Tree();
+  const dt = new Tree();
+  let bfinal;
+  do {
+    bfinal = getBit(d);
+    const btype = readBits(d, 2, 0);
+    if (btype === 0) {
+      inflateUncompressedBlock(d, out);
+    } else if (btype === 1) {
+      buildFixedTrees(lt, dt);
+      inflateBlockData(d, out, lt, dt);
+    } else if (btype === 2) {
+      decodeTrees(d, lt, dt);
+      inflateBlockData(d, out, lt, dt);
+    } else {
+      throw new Error("dark-slide: invalid DEFLATE block type");
+    }
+  } while (!bfinal);
+  return out.buf.subarray(0, out.len);
+}
+
+// src/zip/zip-reader.ts
+var decoder = new TextDecoder();
+function unzipSync(data) {
+  const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  let eocd = -1;
+  for (let i = data.length - 22; i >= 0; i--) {
+    if (dv.getUint32(i, true) === 101010256) {
+      eocd = i;
+      break;
+    }
+  }
+  if (eocd < 0) throw new Error("dark-slide: not a zip archive (no EOCD record)");
+  const count = dv.getUint16(eocd + 10, true);
+  let cd = dv.getUint32(eocd + 16, true);
+  const result = {};
+  for (let n = 0; n < count; n++) {
+    if (dv.getUint32(cd, true) !== 33639248) break;
+    const method = dv.getUint16(cd + 10, true);
+    const compSize = dv.getUint32(cd + 20, true);
+    const nameLen = dv.getUint16(cd + 28, true);
+    const extraLen = dv.getUint16(cd + 30, true);
+    const commentLen = dv.getUint16(cd + 32, true);
+    const localOffset = dv.getUint32(cd + 42, true);
+    const name = decoder.decode(data.subarray(cd + 46, cd + 46 + nameLen));
+    const lhNameLen = dv.getUint16(localOffset + 26, true);
+    const lhExtraLen = dv.getUint16(localOffset + 28, true);
+    const dataStart = localOffset + 30 + lhNameLen + lhExtraLen;
+    const raw = data.subarray(dataStart, dataStart + compSize);
+    let content;
+    if (method === 0) content = raw.slice();
+    else if (method === 8) content = inflateRaw(raw);
+    else throw new Error(`dark-slide: unsupported zip method ${method} for "${name}"`);
+    result[name] = content;
+    cd += 46 + nameLen + extraLen + commentLen;
+  }
+  return result;
+}
+
+// src/reader/xml.ts
+function localName(name) {
+  const idx = name.indexOf(":");
+  return idx >= 0 ? name.slice(idx + 1) : name;
+}
+function unescapeXml(s) {
+  if (s.indexOf("&") < 0) return s;
+  return s.replace(/&(#x?[0-9a-fA-F]+|\w+);/g, (m, ent) => {
+    switch (ent) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return '"';
+      case "apos":
+        return "'";
+      default:
+        if (ent[0] === "#") {
+          const code = ent[1] === "x" || ent[1] === "X" ? parseInt(ent.slice(2), 16) : parseInt(ent.slice(1), 10);
+          return Number.isFinite(code) ? String.fromCodePoint(code) : m;
+        }
+        return m;
+    }
+  });
+}
+function findTagEnd(src, from) {
+  let quote = "";
+  for (let i = from; i < src.length; i++) {
+    const ch = src[i];
+    if (quote) {
+      if (ch === quote) quote = "";
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (ch === ">") {
+      return i;
+    }
+  }
+  return src.length;
+}
+var ATTR_RE = /([^\s=/]+)\s*=\s*("([^"]*)"|'([^']*)')/g;
+function parseTag(inner) {
+  const trimmed = inner.trim();
+  let i = 0;
+  while (i < trimmed.length && !/\s/.test(trimmed[i])) i++;
+  const name = trimmed.slice(0, i);
+  const attrs = {};
+  const rest = trimmed.slice(i);
+  for (const m of rest.matchAll(ATTR_RE)) {
+    const key = localName(m[1]);
+    const value = unescapeXml(m[3] ?? m[4] ?? "");
+    attrs[key] = value;
+  }
+  return { name, attrs };
+}
+function parseXml(src) {
+  let i = 0;
+  const n = src.length;
+  const root = { name: "#root", attrs: {}, children: [], text: "" };
+  const stack = [root];
+  while (i < n) {
+    if (src[i] === "<") {
+      if (src.startsWith("<!--", i)) {
+        const end2 = src.indexOf("-->", i);
+        i = end2 < 0 ? n : end2 + 3;
+        continue;
+      }
+      if (src.startsWith("<![CDATA[", i)) {
+        const end2 = src.indexOf("]]>", i);
+        stack[stack.length - 1].text += src.slice(i + 9, end2 < 0 ? n : end2);
+        i = end2 < 0 ? n : end2 + 3;
+        continue;
+      }
+      if (src.startsWith("<?", i)) {
+        const end2 = src.indexOf("?>", i);
+        i = end2 < 0 ? n : end2 + 2;
+        continue;
+      }
+      if (src.startsWith("<!", i)) {
+        const end2 = src.indexOf(">", i);
+        i = end2 < 0 ? n : end2 + 1;
+        continue;
+      }
+      if (src[i + 1] === "/") {
+        const end2 = src.indexOf(">", i);
+        if (stack.length > 1) stack.pop();
+        i = end2 < 0 ? n : end2 + 1;
+        continue;
+      }
+      const end = findTagEnd(src, i + 1);
+      const tagContent = src.slice(i + 1, end);
+      const selfClosing = tagContent.endsWith("/");
+      const { name, attrs } = parseTag(selfClosing ? tagContent.slice(0, -1) : tagContent);
+      const node = { name: localName(name), attrs, children: [], text: "" };
+      stack[stack.length - 1].children.push(node);
+      if (!selfClosing) stack.push(node);
+      i = end + 1;
+    } else {
+      const next = src.indexOf("<", i);
+      const stop = next < 0 ? n : next;
+      stack[stack.length - 1].text += unescapeXml(src.slice(i, stop));
+      i = stop;
+    }
+  }
+  return root.children[0] ?? null;
+}
+function el(node, name) {
+  return node?.children.find((c) => c.name === name);
+}
+function els(node, name) {
+  return node ? node.children.filter((c) => c.name === name) : [];
+}
+function at(node, name) {
+  return node?.attrs[name];
+}
+
+// src/helpers/xml.ts
+var Xml = {
+  text(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  },
+  attr(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  },
+  declaration(standalone = true) {
+    const sa = standalone ? ' standalone="yes"' : "";
+    return `<?xml version="1.0" encoding="UTF-8"${sa}?>
+`;
+  }
+};
+
+// src/writer/docx-writer.ts
+var EMU_PER_PX = 9525;
+var MAX_WIDTH_PX = 624;
+var NS_W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+var NS_R = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+var NS_WP = "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
+var NS_A = "http://schemas.openxmlformats.org/drawingml/2006/main";
+var NS_PIC = "http://schemas.openxmlformats.org/drawingml/2006/picture";
+var REL_STYLES = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles";
+var REL_NUMBERING = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering";
+var REL_HYPERLINK = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
+var REL_IMAGE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+var REL_DOCUMENT = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+var REL_CORE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties";
+var NUM_ID_BULLET = 1;
+var NUM_ID_DECIMAL = 2;
+var MAX_ILVL = 5;
+var SDT_TAG_CODE = "lastword:code";
+var SDT_TAG_QUOTE = "lastword:quote";
+function normalizeHex(hex) {
+  return hex.replace(/^#/, "").toUpperCase();
+}
+var DocxWriter = class {
+  constructor() {
+    this.rels = [];
+    this.hyperlinkIds = /* @__PURE__ */ new Map();
+    this.media = [];
+    this.drawingId = 0;
+  }
+  toBytes(doc) {
+    this.rels = [
+      { id: "rId1", type: REL_STYLES, target: "styles.xml", external: false },
+      { id: "rId2", type: REL_NUMBERING, target: "numbering.xml", external: false }
+    ];
+    this.hyperlinkIds = /* @__PURE__ */ new Map();
+    this.media = [];
+    this.drawingId = 0;
+    const body = this.renderBlocks(doc.blocks ?? [], {});
+    const documentXml = Xml.declaration() + `<w:document xmlns:w="${NS_W}" xmlns:r="${NS_R}" xmlns:wp="${NS_WP}" xmlns:a="${NS_A}" xmlns:pic="${NS_PIC}"><w:body>${body}${this.sectPr()}</w:body></w:document>`;
+    const files = [
+      { name: "[Content_Types].xml", data: encode(this.contentTypesXml(doc)) },
+      { name: "_rels/.rels", data: encode(this.packageRelsXml(doc)) }
+    ];
+    if (doc.title !== void 0) {
+      files.push({ name: "docProps/core.xml", data: encode(this.coreXml(String(doc.title))) });
+    }
+    files.push(
+      { name: "word/document.xml", data: encode(documentXml) },
+      { name: "word/styles.xml", data: encode(this.stylesXml()) },
+      { name: "word/numbering.xml", data: encode(this.numberingXml()) },
+      { name: "word/_rels/document.xml.rels", data: encode(this.documentRelsXml()) }
+    );
+    for (const m of this.media) {
+      files.push({ name: `word/media/${m.name}`, data: m.bytes });
+    }
+    return zipSync(files);
+  }
+  // ── Blocks ────────────────────────────────────────────────────────────────
+  renderBlocks(blocks, ctx) {
+    let out = "";
+    for (const block of blocks) {
+      out += this.renderBlock(block, ctx);
+    }
+    return out;
+  }
+  renderBlock(block, ctx) {
+    switch (block.type) {
+      case "heading":
+        return this.paragraph(this.pPr(`Heading${clampLevel(block.level)}`), this.renderRuns(block.runs ?? []));
+      case "paragraph": {
+        const jc = block.align && block.align !== "left" ? block.align === "justify" ? "both" : block.align : null;
+        return this.paragraph(this.pPr(ctx.paragraphStyle ?? null, null, jc), this.renderRuns(block.runs ?? []));
+      }
+      case "list":
+        return this.renderList(block.items ?? [], block.ordered === true, 0);
+      case "table":
+        return this.renderTable(block);
+      case "code":
+        return this.renderCode(block);
+      case "quote":
+        return this.renderQuote(block);
+      case "image":
+        return this.renderImage(block);
+      case "pageBreak":
+        return `<w:p><w:r><w:br w:type="page"/></w:r></w:p>`;
+      case "hr":
+        return `<w:p><w:pPr><w:pBdr><w:bottom w:val="single" w:sz="6" w:space="1" w:color="auto"/></w:pBdr></w:pPr></w:p>`;
+      default:
+        return "";
+    }
+  }
+  paragraph(pPr, runs) {
+    return `<w:p>${pPr}${runs}</w:p>`;
+  }
+  pPr(style, numPr = null, jc = null) {
+    let inner = "";
+    if (style) inner += `<w:pStyle w:val="${Xml.attr(style)}"/>`;
+    if (numPr) inner += numPr;
+    if (jc) inner += `<w:jc w:val="${jc}"/>`;
+    return inner === "" ? "" : `<w:pPr>${inner}</w:pPr>`;
+  }
+  // ── Runs ──────────────────────────────────────────────────────────────────
+  renderRuns(runs) {
+    let out = "";
+    for (const run of runs) {
+      if (typeof run?.text !== "string") continue;
+      if (run.link) {
+        const rid = this.hyperlinkRel(run.link);
+        out += `<w:hyperlink r:id="${rid}" w:history="1">${this.renderRun(run, true)}</w:hyperlink>`;
+      } else {
+        out += this.renderRun(run, false);
+      }
+    }
+    return out;
+  }
+  renderRun(run, linked) {
+    let rPr = "";
+    if (run.code) rPr += `<w:rStyle w:val="InlineCode"/>`;
+    else if (linked) rPr += `<w:rStyle w:val="Hyperlink"/>`;
+    if (run.code) rPr += `<w:rFonts w:ascii="Consolas" w:hAnsi="Consolas" w:cs="Consolas"/>`;
+    if (run.bold) rPr += `<w:b/>`;
+    if (run.italic) rPr += `<w:i/>`;
+    if (run.strike) rPr += `<w:strike/>`;
+    if (run.color) rPr += `<w:color w:val="${normalizeHex(run.color)}"/>`;
+    if (run.underline) rPr += `<w:u w:val="single"/>`;
+    if (run.highlight) {
+      rPr += `<w:shd w:val="clear" w:color="auto" w:fill="${normalizeHex(run.highlight)}"/>`;
+    }
+    const pr = rPr === "" ? "" : `<w:rPr>${rPr}</w:rPr>`;
+    const parts = run.text.split("\n");
+    let content = "";
+    parts.forEach((part, i) => {
+      if (i > 0) content += `<w:br/>`;
+      if (part !== "") content += `<w:t xml:space="preserve">${Xml.text(part)}</w:t>`;
+    });
+    if (content === "") content = `<w:t xml:space="preserve"></w:t>`;
+    return `<w:r>${pr}${content}</w:r>`;
+  }
+  hyperlinkRel(url) {
+    const existing = this.hyperlinkIds.get(url);
+    if (existing) return existing;
+    const id = `rId${this.rels.length + 1}`;
+    this.rels.push({ id, type: REL_HYPERLINK, target: url, external: true });
+    this.hyperlinkIds.set(url, id);
+    return id;
+  }
+  // ── Lists ─────────────────────────────────────────────────────────────────
+  renderList(items, ordered, depth) {
+    const numId = ordered ? NUM_ID_DECIMAL : NUM_ID_BULLET;
+    const ilvl = Math.min(depth, MAX_ILVL);
+    let out = "";
+    for (const item of items) {
+      const numPr = `<w:numPr><w:ilvl w:val="${ilvl}"/><w:numId w:val="${numId}"/></w:numPr>`;
+      out += this.paragraph(this.pPr(null, numPr), this.renderRuns(item.runs ?? []));
+      if (item.children && item.children.length > 0) {
+        out += this.renderList(item.children, ordered, depth + 1);
+      }
+    }
+    return out;
+  }
+  // ── Tables ────────────────────────────────────────────────────────────────
+  renderTable(block) {
+    const rows = block.rows ?? [];
+    const cols = Math.max(1, ...rows.map((r) => Array.isArray(r?.cells) ? r.cells.length : 0));
+    const colWidth = Math.floor(9360 / cols);
+    let out = `<w:tbl><w:tblPr><w:tblStyle w:val="LastWordTable"/><w:tblW w:w="0" w:type="auto"/>`;
+    out += `<w:tblLook w:val="04A0" w:firstRow="1" w:lastRow="0" w:firstColumn="0" w:lastColumn="0" w:noHBand="0" w:noVBand="1"/>`;
+    out += `</w:tblPr><w:tblGrid>`;
+    for (let c = 0; c < cols; c++) out += `<w:gridCol w:w="${colWidth}"/>`;
+    out += `</w:tblGrid>`;
+    for (const row of rows) {
+      const header = row?.header === true;
+      out += `<w:tr>`;
+      if (header) out += `<w:trPr><w:tblHeader/></w:trPr>`;
+      const cells = Array.isArray(row?.cells) ? row.cells : [];
+      for (const cell of cells) {
+        out += `<w:tc><w:tcPr><w:tcW w:w="${colWidth}" w:type="dxa"/>`;
+        if (header) out += `<w:shd w:val="clear" w:color="auto" w:fill="F2F2F2"/>`;
+        out += `</w:tcPr>`;
+        let inner = this.renderBlocks(cell?.blocks ?? [], {});
+        if (inner === "" || !inner.endsWith("</w:p>")) inner += `<w:p/>`;
+        out += inner + `</w:tc>`;
+      }
+      out += `</w:tr>`;
+    }
+    out += `</w:tbl>`;
+    return out;
+  }
+  // ── Code / quote (SDT-wrapped for lossless round-trip) ──────────────────
+  renderCode(block) {
+    const language = typeof block.language === "string" && block.language !== "" ? block.language : null;
+    const tag = language ? `${SDT_TAG_CODE}:${language}` : SDT_TAG_CODE;
+    const lines = String(block.text ?? "").split("\n");
+    let body = "";
+    for (const line of lines) {
+      const runs = line === "" ? "" : `<w:r><w:t xml:space="preserve">${Xml.text(line)}</w:t></w:r>`;
+      body += this.paragraph(this.pPr("CodeBlock"), runs);
+    }
+    return `<w:sdt><w:sdtPr><w:alias w:val="Code"/><w:tag w:val="${Xml.attr(tag)}"/></w:sdtPr><w:sdtContent>${body}</w:sdtContent></w:sdt>`;
+  }
+  renderQuote(block) {
+    const body = this.renderBlocks(block.blocks ?? [], { paragraphStyle: "Quote" });
+    return `<w:sdt><w:sdtPr><w:alias w:val="Quote"/><w:tag w:val="${SDT_TAG_QUOTE}"/></w:sdtPr><w:sdtContent>${body === "" ? "<w:p/>" : body}</w:sdtContent></w:sdt>`;
+  }
+  // ── Images ────────────────────────────────────────────────────────────────
+  renderImage(block) {
+    const decoded = parseDataUrl(String(block.src ?? ""));
+    if (!decoded) {
+      throw new Error("last-word: image `src` must be a base64 data URL (data:image/png;base64,\u2026 or data:image/jpeg;base64,\u2026)");
+    }
+    const ext = extForMime(decoded.mime);
+    const name = `image${this.media.length + 1}.${ext}`;
+    this.media.push({ name, bytes: decoded.bytes, ext });
+    const rid = `rId${this.rels.length + 1}`;
+    this.rels.push({ id: rid, type: REL_IMAGE, target: `media/${name}`, external: false });
+    const { width, height } = resolveImageSize(block, decoded.bytes);
+    const cx = Math.max(1, Math.round(width * EMU_PER_PX));
+    const cy = Math.max(1, Math.round(height * EMU_PER_PX));
+    const id = ++this.drawingId;
+    const alt = typeof block.alt === "string" ? block.alt : "";
+    const descr = alt === "" ? "" : ` descr="${Xml.attr(alt)}"`;
+    return `<w:p><w:r><w:drawing><wp:inline distT="0" distB="0" distL="0" distR="0"><wp:extent cx="${cx}" cy="${cy}"/><wp:effectExtent l="0" t="0" r="0" b="0"/><wp:docPr id="${id}" name="Picture ${id}"${descr}/><wp:cNvGraphicFramePr><a:graphicFrameLocks noChangeAspect="1"/></wp:cNvGraphicFramePr><a:graphic><a:graphicData uri="${NS_PIC}"><pic:pic><pic:nvPicPr><pic:cNvPr id="${id}" name="Picture ${id}"${descr}/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip r:embed="${rid}"/><a:stretch><a:fillRect/></a:stretch></pic:blipFill><pic:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="${cx}" cy="${cy}"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></pic:spPr></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing></w:r></w:p>`;
+  }
+  // ── Parts ─────────────────────────────────────────────────────────────────
+  sectPr() {
+    return `<w:sectPr><w:pgSz w:w="12240" w:h="15840"/><w:pgMar w:top="1440" w:right="1440" w:bottom="1440" w:left="1440" w:header="720" w:footer="720" w:gutter="0"/></w:sectPr>`;
+  }
+  contentTypesXml(doc) {
+    const exts = [...new Set(this.media.map((m) => m.ext))].sort();
+    let defaults = `<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/>`;
+    for (const ext of exts) {
+      defaults += `<Default Extension="${ext}" ContentType="${mimeForExt(ext)}"/>`;
+    }
+    let overrides = `<Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/><Override PartName="/word/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/><Override PartName="/word/numbering.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"/>`;
+    if (doc.title !== void 0) {
+      overrides += `<Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/>`;
+    }
+    return Xml.declaration() + `<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">${defaults}${overrides}</Types>`;
+  }
+  packageRelsXml(doc) {
+    let rels = `<Relationship Id="rId1" Type="${REL_DOCUMENT}" Target="word/document.xml"/>`;
+    if (doc.title !== void 0) {
+      rels += `<Relationship Id="rId2" Type="${REL_CORE}" Target="docProps/core.xml"/>`;
+    }
+    return Xml.declaration() + `<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${rels}</Relationships>`;
+  }
+  coreXml(title) {
+    return Xml.declaration() + `<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><dc:title>${Xml.text(title)}</dc:title></cp:coreProperties>`;
+  }
+  documentRelsXml() {
+    let out = Xml.declaration() + `<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">`;
+    for (const rel of this.rels) {
+      const mode = rel.external ? ` TargetMode="External"` : "";
+      out += `<Relationship Id="${rel.id}" Type="${rel.type}" Target="${Xml.attr(rel.target)}"${mode}/>`;
+    }
+    return out + `</Relationships>`;
+  }
+  stylesXml() {
+    const headingSizes = [40, 32, 28, 26, 24, 22];
+    let styles = `<w:docDefaults><w:rPrDefault><w:rPr><w:rFonts w:ascii="Calibri" w:hAnsi="Calibri" w:eastAsia="Calibri" w:cs="Calibri"/><w:sz w:val="22"/><w:szCs w:val="22"/></w:rPr></w:rPrDefault><w:pPrDefault><w:pPr><w:spacing w:after="160" w:line="259" w:lineRule="auto"/></w:pPr></w:pPrDefault></w:docDefaults><w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/><w:qFormat/></w:style>`;
+    for (let level = 1; level <= 6; level++) {
+      const sz = headingSizes[level - 1];
+      styles += `<w:style w:type="paragraph" w:styleId="Heading${level}"><w:name w:val="heading ${level}"/><w:basedOn w:val="Normal"/><w:next w:val="Normal"/><w:qFormat/><w:pPr><w:keepNext/><w:spacing w:before="240" w:after="120"/><w:outlineLvl w:val="${level - 1}"/></w:pPr><w:rPr><w:b/><w:sz w:val="${sz}"/><w:szCs w:val="${sz}"/></w:rPr></w:style>`;
+    }
+    styles += `<w:style w:type="paragraph" w:styleId="Quote"><w:name w:val="Quote"/><w:basedOn w:val="Normal"/><w:qFormat/><w:pPr><w:ind w:left="720"/></w:pPr><w:rPr><w:i/><w:color w:val="595959"/></w:rPr></w:style><w:style w:type="paragraph" w:styleId="CodeBlock"><w:name w:val="Code Block"/><w:basedOn w:val="Normal"/><w:pPr><w:spacing w:after="0" w:line="240" w:lineRule="auto"/><w:shd w:val="clear" w:color="auto" w:fill="F2F2F2"/></w:pPr><w:rPr><w:rFonts w:ascii="Consolas" w:hAnsi="Consolas" w:cs="Consolas"/><w:sz w:val="20"/><w:szCs w:val="20"/></w:rPr></w:style><w:style w:type="character" w:styleId="InlineCode"><w:name w:val="Inline Code"/><w:rPr><w:rFonts w:ascii="Consolas" w:hAnsi="Consolas" w:cs="Consolas"/><w:shd w:val="clear" w:color="auto" w:fill="F2F2F2"/></w:rPr></w:style><w:style w:type="character" w:styleId="Hyperlink"><w:name w:val="Hyperlink"/><w:rPr><w:color w:val="0563C1"/><w:u w:val="single"/></w:rPr></w:style><w:style w:type="table" w:styleId="LastWordTable"><w:name w:val="LastWord Table"/><w:tblPr><w:tblBorders><w:top w:val="single" w:sz="4" w:space="0" w:color="auto"/><w:left w:val="single" w:sz="4" w:space="0" w:color="auto"/><w:bottom w:val="single" w:sz="4" w:space="0" w:color="auto"/><w:right w:val="single" w:sz="4" w:space="0" w:color="auto"/><w:insideH w:val="single" w:sz="4" w:space="0" w:color="auto"/><w:insideV w:val="single" w:sz="4" w:space="0" w:color="auto"/></w:tblBorders><w:tblCellMar><w:top w:w="60" w:type="dxa"/><w:left w:w="108" w:type="dxa"/><w:bottom w:w="60" w:type="dxa"/><w:right w:w="108" w:type="dxa"/></w:tblCellMar></w:tblPr><w:tblStylePr w:type="firstRow"><w:rPr><w:b/></w:rPr><w:tcPr><w:shd w:val="clear" w:color="auto" w:fill="F2F2F2"/></w:tcPr></w:tblStylePr></w:style>`;
+    return Xml.declaration() + `<w:styles xmlns:w="${NS_W}">${styles}</w:styles>`;
+  }
+  numberingXml() {
+    let out = Xml.declaration() + `<w:numbering xmlns:w="${NS_W}">`;
+    out += `<w:abstractNum w:abstractNumId="0"><w:multiLevelType w:val="hybridMultilevel"/>`;
+    for (let i = 0; i <= MAX_ILVL; i++) {
+      out += `<w:lvl w:ilvl="${i}"><w:start w:val="1"/><w:numFmt w:val="bullet"/><w:lvlText w:val="\u2022"/><w:lvlJc w:val="left"/><w:pPr><w:ind w:left="${720 * (i + 1)}" w:hanging="360"/></w:pPr></w:lvl>`;
+    }
+    out += `</w:abstractNum>`;
+    out += `<w:abstractNum w:abstractNumId="1"><w:multiLevelType w:val="hybridMultilevel"/>`;
+    for (let i = 0; i <= MAX_ILVL; i++) {
+      out += `<w:lvl w:ilvl="${i}"><w:start w:val="1"/><w:numFmt w:val="decimal"/><w:lvlText w:val="%${i + 1}."/><w:lvlJc w:val="left"/><w:pPr><w:ind w:left="${720 * (i + 1)}" w:hanging="360"/></w:pPr></w:lvl>`;
+    }
+    out += `</w:abstractNum>`;
+    out += `<w:num w:numId="${NUM_ID_BULLET}"><w:abstractNumId w:val="0"/></w:num>`;
+    out += `<w:num w:numId="${NUM_ID_DECIMAL}"><w:abstractNumId w:val="1"/></w:num>`;
+    return out + `</w:numbering>`;
+  }
+};
+var encoder2 = new TextEncoder();
+function encode(xml) {
+  return encoder2.encode(xml);
+}
+function clampLevel(level) {
+  const n = Number.isFinite(Number(level)) ? Math.trunc(Number(level)) : 1;
+  return Math.min(6, Math.max(1, n));
+}
+function extForMime(mime) {
+  switch (mime) {
+    case "image/png":
+      return "png";
+    case "image/jpeg":
+    case "image/jpg":
+      return "jpeg";
+    case "image/gif":
+      return "gif";
+    default:
+      return mime.split("/")[1] ?? "bin";
+  }
+}
+function mimeForExt(ext) {
+  switch (ext) {
+    case "png":
+      return "image/png";
+    case "jpeg":
+      return "image/jpeg";
+    case "gif":
+      return "image/gif";
+    default:
+      return "application/octet-stream";
+  }
+}
+function resolveImageSize(block, bytes) {
+  const intrinsic = sniffImageSize(bytes);
+  let width = typeof block.widthPx === "number" && block.widthPx > 0 ? block.widthPx : void 0;
+  let height = typeof block.heightPx === "number" && block.heightPx > 0 ? block.heightPx : void 0;
+  if (width === void 0 && height === void 0) {
+    width = intrinsic?.width ?? 300;
+    height = intrinsic?.height ?? 200;
+  } else if (width === void 0) {
+    const aspect = intrinsic ? intrinsic.width / intrinsic.height : 1.5;
+    width = height * aspect;
+  } else if (height === void 0) {
+    const aspect = intrinsic ? intrinsic.width / intrinsic.height : 1.5;
+    height = width / aspect;
+  }
+  if (width > MAX_WIDTH_PX) {
+    height = height * MAX_WIDTH_PX / width;
+    width = MAX_WIDTH_PX;
+  }
+  return { width: Math.max(1, Math.round(width)), height: Math.max(1, Math.round(height)) };
+}
+
+// src/reader/docx-reader.ts
+var DECODER = new TextDecoder();
+var HIGHLIGHT_NAMES = {
+  yellow: "#FFFF00",
+  green: "#00FF00",
+  cyan: "#00FFFF",
+  magenta: "#FF00FF",
+  blue: "#0000FF",
+  red: "#FF0000",
+  darkBlue: "#00008B",
+  darkCyan: "#008B8B",
+  darkGreen: "#006400",
+  darkMagenta: "#8B008B",
+  darkRed: "#8B0000",
+  darkYellow: "#808000",
+  darkGray: "#A9A9A9",
+  lightGray: "#D3D3D3",
+  black: "#000000",
+  white: "#FFFFFF"
+};
+var MONO_FONTS = ["consolas", "courier new", "courier", "menlo", "monaco", "source code pro"];
+var ORDERED_NUM_FMTS = [
+  "decimal",
+  "decimalZero",
+  "upperRoman",
+  "lowerRoman",
+  "upperLetter",
+  "lowerLetter"
+];
+var DocxReader = class {
+  constructor() {
+    this.parts = {};
+    this.rels = {};
+    this.numOrdered = {};
+  }
+  read(bytes) {
+    this.parts = unzipSync(bytes);
+    this.rels = this.loadRels("word/_rels/document.xml.rels");
+    this.numOrdered = this.loadNumbering();
+    const docXml = this.partText("word/document.xml");
+    const root = docXml ? parseXml(docXml) : null;
+    const body = el(root, "body");
+    const doc = { blocks: body ? this.walkBody(body.children, {}) : [] };
+    const title = this.readTitle();
+    if (title !== null) doc.title = title;
+    return doc;
+  }
+  // ── Parts / metadata ─────────────────────────────────────────────────────
+  partText(name) {
+    const part = this.parts[name];
+    return part ? DECODER.decode(part) : null;
+  }
+  readTitle() {
+    const xml = this.partText("docProps/core.xml");
+    if (!xml) return null;
+    const root = parseXml(xml);
+    const title = el(root, "title");
+    return title ? title.text : null;
+  }
+  loadRels(name) {
+    const xml = this.partText(name);
+    if (!xml) return {};
+    const root = parseXml(xml);
+    const out = {};
+    for (const rel of els(root, "Relationship")) {
+      const id = at(rel, "Id");
+      const target = at(rel, "Target");
+      if (!id || !target) continue;
+      out[id] = { target, external: at(rel, "TargetMode") === "External" };
+    }
+    return out;
+  }
+  loadNumbering() {
+    const xml = this.partText("word/numbering.xml");
+    if (!xml) return {};
+    const root = parseXml(xml);
+    const abstractOrdered = {};
+    for (const abs of els(root, "abstractNum")) {
+      const id = at(abs, "abstractNumId") ?? "";
+      const lvl0 = els(abs, "lvl").find((l) => at(l, "ilvl") === "0") ?? el(abs, "lvl");
+      const fmt = at(el(lvl0, "numFmt"), "val") ?? "bullet";
+      abstractOrdered[id] = ORDERED_NUM_FMTS.includes(fmt);
+    }
+    const out = {};
+    for (const num of els(root, "num")) {
+      const numId = at(num, "numId") ?? "";
+      const absId = at(el(num, "abstractNumId"), "val") ?? "";
+      out[numId] = abstractOrdered[absId] ?? false;
+    }
+    return out;
+  }
+  // ── Body walking ─────────────────────────────────────────────────────────
+  walkBody(nodes, ctx) {
+    const blocks = [];
+    let listBuf = [];
+    let codeBuf = null;
+    let quoteBuf = null;
+    const flushList = () => {
+      if (listBuf.length > 0) {
+        blocks.push(...this.buildLists(listBuf));
+        listBuf = [];
+      }
+    };
+    const flushCode = () => {
+      if (codeBuf !== null) {
+        blocks.push({ type: "code", text: codeBuf.join("\n") });
+        codeBuf = null;
+      }
+    };
+    const flushQuote = () => {
+      if (quoteBuf !== null) {
+        blocks.push({ type: "quote", blocks: quoteBuf });
+        quoteBuf = null;
+      }
+    };
+    const flushAll = () => {
+      flushList();
+      flushCode();
+      flushQuote();
+    };
+    for (const node of nodes) {
+      switch (node.name) {
+        case "p": {
+          const kind = this.classifyParagraph(node);
+          if (kind.kind === "listItem") {
+            flushCode();
+            flushQuote();
+            listBuf.push(kind.item);
+          } else if (kind.kind === "codeLine") {
+            flushList();
+            flushQuote();
+            if (codeBuf === null) codeBuf = [];
+            codeBuf.push(kind.text);
+          } else if (kind.kind === "quoteParagraph" && !ctx.insideQuote) {
+            flushList();
+            flushCode();
+            if (quoteBuf === null) quoteBuf = [];
+            quoteBuf.push(...kind.blocks);
+          } else {
+            flushAll();
+            blocks.push(...kind.blocks);
+          }
+          break;
+        }
+        case "tbl":
+          flushAll();
+          blocks.push(this.parseTable(node, ctx));
+          break;
+        case "sdt": {
+          flushAll();
+          blocks.push(...this.parseSdt(node, ctx));
+          break;
+        }
+        case "sectPr":
+        case "bookmarkStart":
+        case "bookmarkEnd":
+        case "proofErr":
+          break;
+        default:
+          if (node.children.length > 0) {
+            const inner = this.walkBody(node.children, ctx);
+            if (inner.length > 0) {
+              flushAll();
+              blocks.push(...inner);
+            }
+          }
+          break;
+      }
+    }
+    flushAll();
+    return blocks;
+  }
+  parseSdt(sdt, ctx) {
+    const tag = at(el(el(sdt, "sdtPr"), "tag"), "val") ?? "";
+    const content = el(sdt, "sdtContent");
+    if (!content) return [];
+    if (tag === SDT_TAG_CODE || tag.startsWith(SDT_TAG_CODE + ":")) {
+      const lines = els(content, "p").map((p) => this.plainText(p));
+      const block = { type: "code", text: lines.join("\n") };
+      if (tag.length > SDT_TAG_CODE.length + 1) {
+        block.language = tag.slice(SDT_TAG_CODE.length + 1);
+      }
+      return [orderCodeKeys(block)];
+    }
+    if (tag === SDT_TAG_QUOTE) {
+      return [{ type: "quote", blocks: this.walkBody(content.children, { ...ctx, insideQuote: true }) }];
+    }
+    return this.walkBody(content.children, ctx);
+  }
+  // ── Paragraph classification ─────────────────────────────────────────────
+  classifyParagraph(p) {
+    const pPr = el(p, "pPr");
+    const styleId = at(el(pPr, "pStyle"), "val") ?? "";
+    const numPr = el(pPr, "numPr");
+    if (numPr) {
+      const numId = at(el(numPr, "numId"), "val") ?? "";
+      const ilvl = parseInt(at(el(numPr, "ilvl"), "val") ?? "0", 10) || 0;
+      return { kind: "listItem", item: { numId, ilvl, runs: this.parseRuns(p, void 0) } };
+    }
+    if (/^(CodeBlock|SourceCode|HTMLPreformatted|Code)$/i.test(styleId)) {
+      return { kind: "codeLine", text: this.plainText(p) };
+    }
+    const blocks = [];
+    const drawings = findAll(p, "drawing");
+    const runs = this.parseRuns(p, void 0);
+    const headingMatch = /^Heading([1-9])$/i.exec(styleId);
+    const outlineLvl = at(el(pPr, "outlineLvl"), "val");
+    if (headingMatch || outlineLvl !== void 0) {
+      const raw = headingMatch ? parseInt(headingMatch[1], 10) : parseInt(outlineLvl ?? "0", 10) + 1;
+      const level = Math.min(6, Math.max(1, raw));
+      blocks.push({ type: "heading", level, runs });
+      for (const d of drawings) blocks.push(...this.parseDrawing(d));
+      return { kind: "blocks", blocks };
+    }
+    const hasPageBreak = findAll(p, "br").some((br) => at(br, "type") === "page");
+    const text = runs.map((r) => r.text).join("");
+    if (hasPageBreak && text === "" && drawings.length === 0) {
+      return { kind: "blocks", blocks: [{ type: "pageBreak" }] };
+    }
+    const pBdr = el(pPr, "pBdr");
+    if (pBdr && el(pBdr, "bottom") && text === "" && drawings.length === 0) {
+      return { kind: "blocks", blocks: [{ type: "hr" }] };
+    }
+    if (text !== "" || drawings.length === 0) {
+      const para = { type: "paragraph", runs };
+      const jc = at(el(pPr, "jc"), "val");
+      if (jc === "center" || jc === "right") para.align = jc;
+      else if (jc === "both" || jc === "distribute" || jc === "justify") para.align = "justify";
+      blocks.push(para);
+    }
+    for (const d of drawings) blocks.push(...this.parseDrawing(d));
+    if (/^(Quote|IntenseQuote|BlockQuote|Blockquote)$/i.test(styleId)) {
+      return { kind: "quoteParagraph", blocks };
+    }
+    return { kind: "blocks", blocks };
+  }
+  /** Concatenated visible text of a paragraph (tabs and soft breaks included). */
+  plainText(p) {
+    return this.parseRuns(p, void 0).map((r) => r.text).join("");
+  }
+  // ── Runs ─────────────────────────────────────────────────────────────────
+  parseRuns(container, link) {
+    const runs = [];
+    for (const child of container.children) {
+      switch (child.name) {
+        case "r":
+          runs.push(...this.runFrom(child, link));
+          break;
+        case "hyperlink": {
+          const rid = at(child, "id");
+          const rel = rid ? this.rels[rid] : void 0;
+          const anchor = at(child, "anchor");
+          const url = rel?.external ? rel.target : anchor ? `#${anchor}` : void 0;
+          runs.push(...this.parseRuns(child, url ?? link));
+          break;
+        }
+        case "sdt": {
+          const content = el(child, "sdtContent");
+          if (content) runs.push(...this.parseRuns(content, link));
+          break;
+        }
+        case "ins":
+        case "smartTag":
+          runs.push(...this.parseRuns(child, link));
+          break;
+      }
+    }
+    return mergeRuns(runs);
+  }
+  runFrom(r, link) {
+    const rPr = el(r, "rPr");
+    let text = "";
+    for (const child of r.children) {
+      if (child.name === "t") text += child.text;
+      else if (child.name === "br" && at(child, "type") !== "page") text += "\n";
+      else if (child.name === "cr") text += "\n";
+      else if (child.name === "tab") text += "	";
+    }
+    if (text === "") return [];
+    const run = { text };
+    if (onFlag(el(rPr, "b"))) run.bold = true;
+    if (onFlag(el(rPr, "i"))) run.italic = true;
+    if (onFlag(el(rPr, "strike"))) run.strike = true;
+    const u = el(rPr, "u");
+    if (u && (at(u, "val") ?? "single") !== "none") run.underline = true;
+    const rStyle = at(el(rPr, "rStyle"), "val") ?? "";
+    const asciiFont = (at(el(rPr, "rFonts"), "ascii") ?? "").toLowerCase();
+    if (/^InlineCode$/i.test(rStyle) || MONO_FONTS.includes(asciiFont)) run.code = true;
+    if (link) run.link = link;
+    const color = at(el(rPr, "color"), "val");
+    if (color && color !== "auto") run.color = `#${color.toUpperCase()}`;
+    const shdFill = at(el(rPr, "shd"), "fill");
+    if (shdFill && shdFill !== "auto") {
+      run.highlight = `#${shdFill.toUpperCase()}`;
+    } else {
+      const named = at(el(rPr, "highlight"), "val");
+      if (named && named !== "none" && HIGHLIGHT_NAMES[named]) run.highlight = HIGHLIGHT_NAMES[named];
+    }
+    return [run];
+  }
+  // ── Lists ────────────────────────────────────────────────────────────────
+  buildLists(flat) {
+    const blocks = [];
+    let i = 0;
+    while (i < flat.length) {
+      const numId = flat[i].numId;
+      const group = [];
+      while (i < flat.length && flat[i].numId === numId) {
+        group.push(flat[i]);
+        i++;
+      }
+      const ordered = this.numOrdered[numId] ?? false;
+      const items = buildTree2(group);
+      const block = ordered ? { type: "list", ordered: true, items } : { type: "list", items };
+      blocks.push(block);
+    }
+    return blocks;
+  }
+  // ── Tables ───────────────────────────────────────────────────────────────
+  parseTable(tbl, ctx) {
+    const rows = els(tbl, "tr").map((tr) => {
+      const header = el(el(tr, "trPr"), "tblHeader") !== void 0;
+      const cells = els(tr, "tc").map((tc) => ({ blocks: this.walkBody(tc.children, ctx) }));
+      return header ? { header: true, cells } : { cells };
+    });
+    return { type: "table", rows };
+  }
+  // ── Images ───────────────────────────────────────────────────────────────
+  parseDrawing(drawing) {
+    const frame = el(drawing, "inline") ?? el(drawing, "anchor");
+    if (!frame) return [];
+    const blip = findFirst(frame, "blip");
+    const rid = at(blip, "embed") ?? at(blip, "link");
+    const rel = rid ? this.rels[rid] : void 0;
+    if (!rel) return [];
+    const target = rel.target.replace(/^\.\//, "");
+    const partName = target.startsWith("/") ? target.slice(1) : `word/${target}`;
+    const media = this.parts[partName];
+    if (!media) return [];
+    const ext = (partName.split(".").pop() ?? "").toLowerCase();
+    const mime = ext === "png" ? "image/png" : ext === "jpg" || ext === "jpeg" ? "image/jpeg" : ext === "gif" ? "image/gif" : "image/png";
+    const block = { type: "image", src: `data:${mime};base64,${base64Encode(media)}` };
+    const extent = el(frame, "extent");
+    const cx = parseInt(at(extent, "cx") ?? "0", 10);
+    const cy = parseInt(at(extent, "cy") ?? "0", 10);
+    if (cx > 0) block.widthPx = Math.max(1, Math.round(cx / EMU_PER_PX));
+    if (cy > 0) block.heightPx = Math.max(1, Math.round(cy / EMU_PER_PX));
+    const descr = at(el(frame, "docPr"), "descr");
+    if (descr) block.alt = descr;
+    return [block];
+  }
+};
+function onFlag(node) {
+  if (!node) return false;
+  const val = node.attrs["val"];
+  return val === void 0 || !["0", "false", "none", "off"].includes(val);
+}
+function findAll(node, name) {
+  const out = [];
+  for (const child of node.children) {
+    if (child.name === name) out.push(child);
+    out.push(...findAll(child, name));
+  }
+  return out;
+}
+function findFirst(node, name) {
+  if (!node) return void 0;
+  for (const child of node.children) {
+    if (child.name === name) return child;
+    const nested = findFirst(child, name);
+    if (nested) return nested;
+  }
+  return void 0;
+}
+function mergeRuns(runs) {
+  const out = [];
+  for (const run of runs) {
+    if (run.text === "") continue;
+    const prev = out[out.length - 1];
+    if (prev && sameProps(prev, run)) {
+      prev.text += run.text;
+    } else {
+      out.push({ ...run });
+    }
+  }
+  return out;
+}
+function sameProps(a, b) {
+  const keys = ["bold", "italic", "underline", "strike", "code", "link", "color", "highlight"];
+  return keys.every((k) => (a[k] ?? void 0) === (b[k] ?? void 0));
+}
+function buildTree2(flat) {
+  const root = [];
+  const lastAtDepth = [];
+  for (const entry of flat) {
+    const item = { runs: entry.runs };
+    let depth = Math.max(0, entry.ilvl);
+    while (depth > 0 && lastAtDepth[depth - 1] === void 0) depth--;
+    if (depth === 0) {
+      root.push(item);
+    } else {
+      const parent = lastAtDepth[depth - 1];
+      if (!parent.children) parent.children = [];
+      parent.children.push(item);
+    }
+    lastAtDepth[depth] = item;
+    lastAtDepth.length = depth + 1;
+  }
+  return root;
+}
+function orderCodeKeys(block) {
+  const b = block;
+  if (b.language === void 0) return block;
+  return { type: "code", language: b.language, text: b.text };
+}
+
+// src/markdown/from-markdown.ts
+var HEADING_RE = /^(#{1,6})\s+(.*)$/;
+var HR_RE = /^(-{3,}|\*{3,}|_{3,})\s*$/;
+var FENCE_RE = /^```(.*)$/;
+var LIST_RE = /^(\s*)([-*+]|\d{1,9}\.)\s+(.*)$/;
+var IMAGE_LINE_RE = /^!\[((?:\\.|[^\]\\])*)\]\(([^)]*)\)\s*$/;
+var TABLE_SEP_RE = /^\s*\|?(\s*:?-{3,}:?\s*\|)*\s*:?-{3,}:?\s*\|?\s*$/;
+function fromMarkdown(markdown) {
+  const lines = String(markdown ?? "").replace(/\r\n?/g, "\n").split("\n");
+  return { blocks: parseBlocks(lines) };
+}
+function parseBlocks(lines) {
+  const blocks = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === "") {
+      i++;
+      continue;
+    }
+    const fence = FENCE_RE.exec(line);
+    if (fence) {
+      const language = fence[1].trim();
+      const body = [];
+      i++;
+      while (i < lines.length && !/^```\s*$/.test(lines[i])) {
+        body.push(lines[i]);
+        i++;
+      }
+      i++;
+      const block = { type: "code", text: body.join("\n") };
+      if (language !== "") block.language = language;
+      blocks.push(reorderCode(block));
+      continue;
+    }
+    const heading = HEADING_RE.exec(line);
+    if (heading) {
+      blocks.push({
+        type: "heading",
+        level: heading[1].length,
+        runs: parseInline(heading[2])
+      });
+      i++;
+      continue;
+    }
+    if (HR_RE.test(line)) {
+      blocks.push({ type: "hr" });
+      i++;
+      continue;
+    }
+    if (line.startsWith(">")) {
+      const inner = [];
+      while (i < lines.length && lines[i].startsWith(">")) {
+        inner.push(lines[i].replace(/^> ?/, ""));
+        i++;
+      }
+      blocks.push({ type: "quote", blocks: parseBlocks(inner) });
+      continue;
+    }
+    if (line.trimStart().startsWith("|") && i + 1 < lines.length && TABLE_SEP_RE.test(lines[i + 1])) {
+      const rows = [];
+      const headerCells = splitTableRow(line);
+      rows.push({ header: true, cells: headerCells });
+      i += 2;
+      while (i < lines.length && lines[i].trimStart().startsWith("|")) {
+        rows.push({ cells: splitTableRow(lines[i]) });
+        i++;
+      }
+      blocks.push({ type: "table", rows });
+      continue;
+    }
+    if (LIST_RE.test(line)) {
+      const entries = [];
+      while (i < lines.length) {
+        const m = LIST_RE.exec(lines[i]);
+        if (!m) break;
+        entries.push({
+          indent: m[1].length,
+          ordered: /\d/.test(m[2][0]),
+          content: m[3]
+        });
+        i++;
+      }
+      blocks.push(buildListBlock(entries));
+      continue;
+    }
+    const image = IMAGE_LINE_RE.exec(line);
+    if (image) {
+      const block = { type: "image", src: image[2] };
+      const alt = image[1].replace(/\\([[\]\\])/g, "$1");
+      if (alt !== "") block.alt = alt;
+      blocks.push(block);
+      i++;
+      continue;
+    }
+    const para = [line];
+    i++;
+    while (i < lines.length && lines[i].trim() !== "" && !isBlockStart(lines[i])) {
+      para.push(lines[i]);
+      i++;
+    }
+    blocks.push({ type: "paragraph", runs: parseInline(para.join(" ")) });
+  }
+  return blocks;
+}
+function isBlockStart(line) {
+  return HEADING_RE.test(line) || HR_RE.test(line) || FENCE_RE.test(line) || LIST_RE.test(line) || IMAGE_LINE_RE.test(line) || line.startsWith(">") || line.trimStart().startsWith("|");
+}
+function buildListBlock(entries) {
+  const root = [];
+  const stack = [
+    { indent: entries[0]?.indent ?? 0, items: root, last: null }
+  ];
+  for (const entry of entries) {
+    while (stack.length > 1 && entry.indent < stack[stack.length - 1].indent) {
+      stack.pop();
+    }
+    let top = stack[stack.length - 1];
+    if (entry.indent > top.indent && top.last) {
+      if (!top.last.children) top.last.children = [];
+      stack.push({ indent: entry.indent, items: top.last.children, last: null });
+      top = stack[stack.length - 1];
+    }
+    const item = { runs: parseInline(entry.content) };
+    top.items.push(item);
+    top.last = item;
+  }
+  const ordered = entries[0]?.ordered === true;
+  return ordered ? { type: "list", ordered: true, items: root } : { type: "list", items: root };
+}
+function splitTableRow(line) {
+  let s = line.trim();
+  if (s.startsWith("|")) s = s.slice(1);
+  if (s.endsWith("|") && !s.endsWith("\\|")) s = s.slice(0, -1);
+  const cells = [];
+  let buf = "";
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === "\\" && i + 1 < s.length) {
+      buf += ch + s[i + 1];
+      i++;
+      continue;
+    }
+    if (ch === "|") {
+      cells.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  cells.push(buf);
+  return cells.map((cell) => ({ blocks: [{ type: "paragraph", runs: parseInline(cell.trim()) }] }));
+}
+var PUNCT_RE = /[!-/:-@[-`{-~]/;
+var WORD_RE = /[A-Za-z0-9_]/;
+function parseInline(text) {
+  const runs = [];
+  let buf = "";
+  let bold = false;
+  let italic = false;
+  let strike = false;
+  let i = 0;
+  const len = text.length;
+  const flush = () => {
+    if (buf !== "") {
+      runs.push(makeRun(buf, bold, italic, strike, false));
+      buf = "";
+    }
+  };
+  while (i < len) {
+    const ch = text[i];
+    const two = text.slice(i, i + 2);
+    if (ch === "\\" && i + 1 < len && PUNCT_RE.test(text[i + 1])) {
+      buf += text[i + 1];
+      i += 2;
+      continue;
+    }
+    if (ch === "`") {
+      const fence = /^`+/.exec(text.slice(i))[0];
+      const end = text.indexOf(fence, i + fence.length);
+      if (end >= 0) {
+        flush();
+        let content = text.slice(i + fence.length, end);
+        if (fence.length > 1) content = content.replace(/^ /, "").replace(/ $/, "");
+        runs.push(makeRun(content, bold, italic, strike, true));
+        i = end + fence.length;
+        continue;
+      }
+      buf += ch;
+      i++;
+      continue;
+    }
+    if (two === "**" || two === "__") {
+      flush();
+      bold = !bold;
+      i += 2;
+      continue;
+    }
+    if (two === "~~") {
+      flush();
+      strike = !strike;
+      i += 2;
+      continue;
+    }
+    if (ch === "*") {
+      flush();
+      italic = !italic;
+      i++;
+      continue;
+    }
+    if (ch === "_") {
+      const prev = i > 0 ? text[i - 1] : " ";
+      const next = i + 1 < len ? text[i + 1] : " ";
+      if (!italic && !WORD_RE.test(prev) || italic && !WORD_RE.test(next)) {
+        flush();
+        italic = !italic;
+        i++;
+        continue;
+      }
+      buf += ch;
+      i++;
+      continue;
+    }
+    if (ch === "[") {
+      const match = matchLink(text, i);
+      if (match) {
+        flush();
+        const inner = parseInline(match.label);
+        for (const run of inner) {
+          run.link = match.url;
+          if (bold) run.bold = true;
+          if (italic) run.italic = true;
+          if (strike) run.strike = true;
+        }
+        runs.push(...inner);
+        i = match.end;
+        continue;
+      }
+      buf += ch;
+      i++;
+      continue;
+    }
+    if (ch === "!" && text[i + 1] === "[") {
+      const match = matchLink(text, i + 1);
+      if (match) {
+        buf += match.label.replace(/\\([[\]\\])/g, "$1");
+        i = match.end;
+        continue;
+      }
+    }
+    buf += ch;
+    i++;
+  }
+  flush();
+  return mergeRuns(runs);
+}
+function makeRun(text, bold, italic, strike, code, link) {
+  const run = { text };
+  if (bold) run.bold = true;
+  if (italic) run.italic = true;
+  if (strike) run.strike = true;
+  if (code) run.code = true;
+  return run;
+}
+function matchLink(text, start) {
+  let depth = 0;
+  let labelEnd = -1;
+  for (let j = start; j < text.length; j++) {
+    const ch = text[j];
+    if (ch === "\\") {
+      j++;
+      continue;
+    }
+    if (ch === "[") depth++;
+    else if (ch === "]") {
+      depth--;
+      if (depth === 0) {
+        labelEnd = j;
+        break;
+      }
+    }
+  }
+  if (labelEnd < 0 || text[labelEnd + 1] !== "(") return null;
+  for (let k = labelEnd + 2; k < text.length; k++) {
+    const ch = text[k];
+    if (ch === "\\") {
+      k++;
+      continue;
+    }
+    if (ch === ")") {
+      return { label: text.slice(start + 1, labelEnd), url: text.slice(labelEnd + 2, k), end: k + 1 };
+    }
+  }
+  return null;
+}
+function reorderCode(block) {
+  if (block.language === void 0) return block;
+  return { type: "code", language: block.language, text: block.text };
+}
+
+// src/markdown/to-markdown.ts
+function toMarkdown(doc) {
+  const chunks = [];
+  for (const block of doc.blocks ?? []) {
+    const md = blockToMarkdown(block);
+    if (md !== null) chunks.push(md);
+  }
+  return chunks.join("\n\n") + (chunks.length > 0 ? "\n" : "");
+}
+function blockToMarkdown(block) {
+  switch (block?.type) {
+    case "heading":
+      return "#".repeat(clamp(block.level)) + " " + inline(block.runs ?? []);
+    case "paragraph":
+      return guardLineStart(inline(block.runs ?? []).replace(/\n/g, " "));
+    case "list":
+      return listToMarkdown(block.items ?? [], block.ordered === true, 0).join("\n");
+    case "table":
+      return tableToMarkdown(block);
+    case "code": {
+      const lang = typeof block.language === "string" ? block.language : "";
+      return "```" + lang + "\n" + String(block.text ?? "") + "\n```";
+    }
+    case "quote": {
+      const inner = (block.blocks ?? []).map((b) => blockToMarkdown(b)).filter((s) => s !== null).join("\n\n");
+      return inner.split("\n").map((line) => line === "" ? ">" : "> " + line).join("\n");
+    }
+    case "image": {
+      const alt = typeof block.alt === "string" ? block.alt : "";
+      return `![${alt.replace(/([[\]\\])/g, "\\$1")}](${String(block.src ?? "")})`;
+    }
+    case "hr":
+      return "---";
+    case "pageBreak":
+      return null;
+    // no GFM equivalent
+    default:
+      return null;
+  }
+}
+function listToMarkdown(items, ordered, depth) {
+  const indent = (ordered ? "   " : "  ").repeat(depth);
+  const lines = [];
+  items.forEach((item, i) => {
+    const marker = ordered ? `${i + 1}. ` : "- ";
+    lines.push(indent + marker + inline(item.runs ?? []).replace(/\n/g, " "));
+    if (item.children && item.children.length > 0) {
+      lines.push(...listToMarkdown(item.children, ordered, depth + 1));
+    }
+  });
+  return lines;
+}
+function tableToMarkdown(block) {
+  const rows = block.rows ?? [];
+  if (rows.length === 0) return "";
+  const cols = Math.max(1, ...rows.map((r) => Array.isArray(r?.cells) ? r.cells.length : 0));
+  const lineOf = (row) => {
+    const cells = Array.isArray(row?.cells) ? row.cells : [];
+    const rendered = [];
+    for (let c = 0; c < cols; c++) {
+      rendered.push(cellInline(cells[c]));
+    }
+    return "| " + rendered.join(" | ") + " |";
+  };
+  const lines = [];
+  lines.push(lineOf(rows[0]));
+  lines.push("| " + Array.from({ length: cols }, () => "---").join(" | ") + " |");
+  for (let r = 1; r < rows.length; r++) lines.push(lineOf(rows[r]));
+  return lines.join("\n");
+}
+function cellInline(cell) {
+  const blocks = Array.isArray(cell?.blocks) ? cell.blocks : [];
+  const parts = [];
+  for (const b of blocks) {
+    if (b?.type === "paragraph" || b?.type === "heading") parts.push(inline(b.runs ?? []));
+    else if (b?.type === "code") parts.push("`" + String(b.text ?? "").replace(/\n/g, " ") + "`");
+    else {
+      const md = blockToMarkdown(b);
+      if (md !== null) parts.push(md.replace(/\n/g, " "));
+    }
+  }
+  return parts.join(" ").replace(/\|/g, "\\|").replace(/\n/g, " ");
+}
+function inline(runs) {
+  let out = "";
+  for (const run of runs) {
+    out += runToMarkdown(run);
+  }
+  return out;
+}
+function runToMarkdown(run) {
+  if (typeof run?.text !== "string") return "";
+  let s = run.code ? codeSpan(run.text) : escapeText(run.text);
+  if (run.bold) s = `**${s}**`;
+  if (run.italic) s = `*${s}*`;
+  if (run.strike) s = `~~${s}~~`;
+  if (run.link) s = `[${s}](${run.link})`;
+  return s;
+}
+function codeSpan(text) {
+  if (!text.includes("`")) return "`" + text + "`";
+  return "`` " + text + " ``";
+}
+function escapeText(text) {
+  return text.replace(/([\\`*_~[\]])/g, "\\$1");
+}
+function guardLineStart(text) {
+  if (/^(#{1,6} |[-*+] |\d+\. |>|(-{3,}|\*{3,}|_{3,})$|\|)/.test(text)) {
+    return "\\" + text;
+  }
+  return text;
+}
+function clamp(level) {
+  const n = Number.isFinite(Number(level)) ? Math.trunc(Number(level)) : 1;
+  return Math.min(6, Math.max(1, n));
+}
+
+// src/util.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNumeric(v) {
+  if (typeof v === "number") return Number.isFinite(v);
+  if (typeof v !== "string") return false;
+  return /^\s*[+-]?(\d+(\.\d+)?|\.\d+)([eE][+-]?\d+)?$/.test(v);
+}
+function clone(v) {
+  return typeof structuredClone === "function" ? structuredClone(v) : JSON.parse(JSON.stringify(v));
+}
+
+// src/schema/schema.ts
+var Schema = {
+  VERSION: "0.1.0",
+  BLOCK_TYPES: [
+    "heading",
+    "paragraph",
+    "list",
+    "table",
+    "code",
+    "quote",
+    "image",
+    "pageBreak",
+    "hr"
+  ],
+  ALIGNMENTS: ["left", "center", "right", "justify"],
+  MAX_HEADING_LEVEL: 6,
+  docRequiredKeys() {
+    return ["blocks"];
+  },
+  jsonSchema() {
+    const runSchema = {
+      type: "object",
+      required: ["text"],
+      properties: {
+        text: { type: "string" },
+        bold: { type: "boolean" },
+        italic: { type: "boolean" },
+        underline: { type: "boolean" },
+        strike: { type: "boolean" },
+        code: { type: "boolean" },
+        link: { type: "string" },
+        color: { type: "string", pattern: "^#[0-9a-fA-F]{6}$" },
+        highlight: { type: "string", pattern: "^#[0-9a-fA-F]{6}$" }
+      }
+    };
+    return {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      title: "LastWord Doc",
+      type: "object",
+      required: this.docRequiredKeys(),
+      properties: {
+        title: { type: "string" },
+        blocks: { type: "array", items: { $ref: "#/definitions/block" } }
+      },
+      definitions: {
+        run: runSchema,
+        listItem: {
+          type: "object",
+          required: ["runs"],
+          properties: {
+            runs: { type: "array", items: { $ref: "#/definitions/run" } },
+            children: { type: "array", items: { $ref: "#/definitions/listItem" } }
+          }
+        },
+        block: {
+          type: "object",
+          required: ["type"],
+          properties: {
+            type: { type: "string", enum: [...this.BLOCK_TYPES] },
+            // heading
+            level: { type: "integer", minimum: 1, maximum: this.MAX_HEADING_LEVEL },
+            // heading + paragraph
+            runs: { type: "array", items: { $ref: "#/definitions/run" } },
+            align: { type: "string", enum: [...this.ALIGNMENTS] },
+            // list
+            ordered: { type: "boolean" },
+            items: { type: "array", items: { $ref: "#/definitions/listItem" } },
+            // table
+            rows: {
+              type: "array",
+              items: {
+                type: "object",
+                required: ["cells"],
+                properties: {
+                  header: { type: "boolean" },
+                  cells: {
+                    type: "array",
+                    items: {
+                      type: "object",
+                      required: ["blocks"],
+                      properties: {
+                        blocks: { type: "array", items: { $ref: "#/definitions/block" } }
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            // code
+            language: { type: "string" },
+            text: { type: "string" },
+            // quote
+            blocks: { type: "array", items: { $ref: "#/definitions/block" } },
+            // image
+            src: { type: "string" },
+            widthPx: { type: "number", exclusiveMinimum: 0 },
+            heightPx: { type: "number", exclusiveMinimum: 0 },
+            alt: { type: "string" }
+          }
+        }
+      }
+    };
+  }
+};
+
+// src/schema/repairer.ts
+var Repairer = class {
+  constructor() {
+    /** Errors describing content the last `repair()` call had to drop. */
+    this.notes = [];
+  }
+  repair(docInput) {
+    this.notes = [];
+    const doc = isPlainObject(docInput) ? clone(docInput) : {};
+    if (doc.title !== void 0 && typeof doc.title !== "string") {
+      doc.title = String(doc.title);
+    }
+    doc.blocks = this.repairBlocks(doc.blocks ?? [], "/blocks");
+    return doc;
+  }
+  repairBlocks(blocks, path) {
+    if (!Array.isArray(blocks)) return [];
+    const out = [];
+    blocks.forEach((block, i) => {
+      const repaired = this.repairBlock(block, `${path}/${i}`);
+      if (repaired !== null) out.push(repaired);
+    });
+    return out;
+  }
+  repairBlock(block, path) {
+    if (typeof block === "string") {
+      return { type: "paragraph", runs: [{ text: block }] };
+    }
+    if (!isPlainObject(block)) {
+      this.notes.push({ path, message: "Dropped non-object block during repair." });
+      return null;
+    }
+    if (typeof block.type !== "string" || !Schema.BLOCK_TYPES.includes(block.type)) {
+      if (typeof block.text === "string") {
+        return { type: "paragraph", runs: [{ text: block.text }] };
+      }
+      this.notes.push({
+        path: `${path}/type`,
+        message: `Dropped block with unknown type \`${String(block.type)}\` during repair.`
+      });
+      return null;
+    }
+    switch (block.type) {
+      case "heading": {
+        let level = isNumeric(block.level) ? Math.trunc(Number(block.level)) : 1;
+        if (level < 1) level = 1;
+        if (level > Schema.MAX_HEADING_LEVEL) level = Schema.MAX_HEADING_LEVEL;
+        block.level = level;
+        block.runs = this.repairRuns(block.runs);
+        break;
+      }
+      case "paragraph":
+        block.runs = this.repairRuns(block.runs);
+        if (block.align !== void 0 && !Schema.ALIGNMENTS.includes(block.align)) {
+          delete block.align;
+        }
+        break;
+      case "list":
+        if (block.ordered !== void 0) block.ordered = Boolean(block.ordered);
+        block.items = this.repairListItems(block.items);
+        break;
+      case "table":
+        block.rows = this.repairRows(block.rows, path);
+        break;
+      case "code":
+        block.text = typeof block.text === "string" ? block.text : String(block.text ?? "");
+        if (block.language !== void 0 && typeof block.language !== "string") delete block.language;
+        break;
+      case "quote":
+        block.blocks = this.repairBlocks(block.blocks ?? [], `${path}/blocks`);
+        break;
+      case "image":
+        if (typeof block.src !== "string" || !block.src.startsWith("data:image/")) {
+          this.notes.push({ path: `${path}/src`, message: "Dropped image without a usable data URL during repair." });
+          return null;
+        }
+        for (const key of ["widthPx", "heightPx"]) {
+          if (block[key] !== void 0 && (!isNumeric(block[key]) || Number(block[key]) <= 0)) {
+            delete block[key];
+          } else if (block[key] !== void 0) {
+            block[key] = Number(block[key]);
+          }
+        }
+        if (block.alt !== void 0 && typeof block.alt !== "string") delete block.alt;
+        break;
+    }
+    return block;
+  }
+  repairRuns(runs) {
+    if (typeof runs === "string") return [{ text: runs }];
+    if (!Array.isArray(runs)) return [];
+    const out = [];
+    for (const run of runs) {
+      if (typeof run === "string") {
+        out.push({ text: run });
+        continue;
+      }
+      if (!isPlainObject(run)) continue;
+      if (typeof run.text !== "string") run.text = String(run.text ?? "");
+      for (const flag of ["bold", "italic", "underline", "strike", "code"]) {
+        if (run[flag] !== void 0 && typeof run[flag] !== "boolean") run[flag] = Boolean(run[flag]);
+      }
+      if (run.link !== void 0 && typeof run.link !== "string") delete run.link;
+      for (const key of ["color", "highlight"]) {
+        if (run[key] !== void 0 && (typeof run[key] !== "string" || !/^#[0-9a-fA-F]{6}$/.test(run[key]))) {
+          delete run[key];
+        }
+      }
+      out.push(run);
+    }
+    return out;
+  }
+  repairListItems(items) {
+    if (!Array.isArray(items)) return [];
+    const out = [];
+    for (const item of items) {
+      if (typeof item === "string") {
+        out.push({ runs: [{ text: item }] });
+        continue;
+      }
+      if (!isPlainObject(item)) continue;
+      item.runs = this.repairRuns(item.runs);
+      if (item.children !== void 0) {
+        const children = this.repairListItems(item.children);
+        if (children.length > 0) item.children = children;
+        else delete item.children;
+      }
+      out.push(item);
+    }
+    return out;
+  }
+  repairRows(rows, path) {
+    if (!Array.isArray(rows)) return [];
+    const out = [];
+    rows.forEach((row, r) => {
+      if (!isPlainObject(row)) return;
+      if (row.header !== void 0) row.header = Boolean(row.header);
+      const cells = Array.isArray(row.cells) ? row.cells : [];
+      row.cells = cells.filter((cell) => isPlainObject(cell) || typeof cell === "string").map((cell, c) => {
+        if (typeof cell === "string") {
+          return { blocks: [{ type: "paragraph", runs: [{ text: cell }] }] };
+        }
+        cell.blocks = this.repairBlocks(cell.blocks ?? [], `${path}/rows/${r}/cells/${c}/blocks`);
+        return cell;
+      });
+      out.push(row);
+    });
+    return out;
+  }
+};
+
+// src/schema/validator.ts
+function err(path, message) {
+  return { path, message };
+}
+var Validator = class {
+  validate(doc) {
+    const errors = [];
+    if (!isPlainObject(doc)) {
+      return [err("/", "Doc must be a JSON object with a `blocks` array.")];
+    }
+    if (doc.title !== void 0 && typeof doc.title !== "string") {
+      errors.push(err("/title", "Doc title must be a string."));
+    }
+    if (!("blocks" in doc)) {
+      errors.push(err("/blocks", "Doc must have a `blocks` array."));
+    } else if (!Array.isArray(doc.blocks)) {
+      errors.push(err("/blocks", "Doc blocks must be a JSON array."));
+    } else {
+      doc.blocks.forEach((block, i) => {
+        errors.push(...this.validateBlock(block, `/blocks/${i}`));
+      });
+    }
+    return errors;
+  }
+  validateBlock(block, path) {
+    const errors = [];
+    if (!isPlainObject(block)) {
+      return [err(path, "Each block must be a JSON object with a `type` field.")];
+    }
+    if (typeof block.type !== "string") {
+      return [err(`${path}/type`, "Block must have a string `type` field.")];
+    }
+    if (!Schema.BLOCK_TYPES.includes(block.type)) {
+      return [err(`${path}/type`, `Unknown block type \`${block.type}\`.`)];
+    }
+    switch (block.type) {
+      case "heading":
+        if (!Number.isInteger(block.level) || block.level < 1 || block.level > Schema.MAX_HEADING_LEVEL) {
+          errors.push(err(`${path}/level`, `Heading level must be an integer between 1 and ${Schema.MAX_HEADING_LEVEL}.`));
+        }
+        errors.push(...this.validateRuns(block.runs, `${path}/runs`));
+        break;
+      case "paragraph":
+        errors.push(...this.validateRuns(block.runs, `${path}/runs`));
+        if (block.align !== void 0 && !Schema.ALIGNMENTS.includes(block.align)) {
+          errors.push(err(`${path}/align`, "Paragraph align must be left, center, right, or justify."));
+        }
+        break;
+      case "list":
+        if (block.ordered !== void 0 && typeof block.ordered !== "boolean") {
+          errors.push(err(`${path}/ordered`, "List `ordered` must be a boolean."));
+        }
+        if (!Array.isArray(block.items)) {
+          errors.push(err(`${path}/items`, "List must have an `items` array."));
+        } else {
+          block.items.forEach((item, i) => {
+            errors.push(...this.validateListItem(item, `${path}/items/${i}`));
+          });
+        }
+        break;
+      case "table":
+        if (!Array.isArray(block.rows)) {
+          errors.push(err(`${path}/rows`, "Table must have a `rows` array."));
+        } else {
+          block.rows.forEach((row, r) => {
+            const rowPath = `${path}/rows/${r}`;
+            if (!isPlainObject(row)) {
+              errors.push(err(rowPath, "Each table row must be a JSON object with a `cells` array."));
+              return;
+            }
+            if (row.header !== void 0 && typeof row.header !== "boolean") {
+              errors.push(err(`${rowPath}/header`, "Row `header` must be a boolean."));
+            }
+            if (!Array.isArray(row.cells)) {
+              errors.push(err(`${rowPath}/cells`, "Table row must have a `cells` array."));
+              return;
+            }
+            row.cells.forEach((cell, c) => {
+              const cellPath = `${rowPath}/cells/${c}`;
+              if (!isPlainObject(cell)) {
+                errors.push(err(cellPath, "Each table cell must be a JSON object with a `blocks` array."));
+                return;
+              }
+              if (!Array.isArray(cell.blocks)) {
+                errors.push(err(`${cellPath}/blocks`, "Table cell must have a `blocks` array."));
+                return;
+              }
+              cell.blocks.forEach((b, i) => {
+                errors.push(...this.validateBlock(b, `${cellPath}/blocks/${i}`));
+              });
+            });
+          });
+        }
+        break;
+      case "code":
+        if (typeof block.text !== "string") {
+          errors.push(err(`${path}/text`, "Code block must have a string `text` field."));
+        }
+        if (block.language !== void 0 && typeof block.language !== "string") {
+          errors.push(err(`${path}/language`, "Code block `language` must be a string."));
+        }
+        break;
+      case "quote":
+        if (!Array.isArray(block.blocks)) {
+          errors.push(err(`${path}/blocks`, "Quote must have a `blocks` array."));
+        } else {
+          block.blocks.forEach((b, i) => {
+            errors.push(...this.validateBlock(b, `${path}/blocks/${i}`));
+          });
+        }
+        break;
+      case "image":
+        if (typeof block.src !== "string" || block.src === "") {
+          errors.push(err(`${path}/src`, "Image must have a `src` data URL string."));
+        } else if (!block.src.startsWith("data:image/")) {
+          errors.push(err(`${path}/src`, "Image `src` must be a data:image/png or data:image/jpeg data URL."));
+        }
+        for (const key of ["widthPx", "heightPx"]) {
+          if (block[key] !== void 0 && (typeof block[key] !== "number" || !(block[key] > 0))) {
+            errors.push(err(`${path}/${key}`, `Image \`${key}\` must be a positive number.`));
+          }
+        }
+        if (block.alt !== void 0 && typeof block.alt !== "string") {
+          errors.push(err(`${path}/alt`, "Image `alt` must be a string."));
+        }
+        break;
+    }
+    return errors;
+  }
+  validateRuns(runs, path) {
+    const errors = [];
+    if (!Array.isArray(runs)) {
+      return [err(path, "Must be an array of runs (`{ text, bold?, italic?, \u2026 }`).")];
+    }
+    runs.forEach((run, i) => {
+      errors.push(...this.validateRun(run, `${path}/${i}`));
+    });
+    return errors;
+  }
+  validateRun(run, path) {
+    const errors = [];
+    if (!isPlainObject(run)) {
+      return [err(path, "Each run must be a JSON object with a `text` field.")];
+    }
+    if (typeof run.text !== "string") {
+      errors.push(err(`${path}/text`, "Run must have a string `text` field."));
+    }
+    for (const flag of ["bold", "italic", "underline", "strike", "code"]) {
+      if (run[flag] !== void 0 && typeof run[flag] !== "boolean") {
+        errors.push(err(`${path}/${flag}`, `Run \`${flag}\` must be a boolean.`));
+      }
+    }
+    if (run.link !== void 0 && typeof run.link !== "string") {
+      errors.push(err(`${path}/link`, "Run `link` must be a URL string."));
+    }
+    for (const key of ["color", "highlight"]) {
+      if (run[key] !== void 0 && (typeof run[key] !== "string" || !/^#[0-9a-fA-F]{6}$/.test(run[key]))) {
+        errors.push(err(`${path}/${key}`, `Run \`${key}\` must be a #RRGGBB hex string.`));
+      }
+    }
+    return errors;
+  }
+  validateListItem(item, path) {
+    const errors = [];
+    if (!isPlainObject(item)) {
+      return [err(path, "Each list item must be a JSON object with a `runs` array.")];
+    }
+    errors.push(...this.validateRuns(item.runs, `${path}/runs`));
+    if (item.children !== void 0) {
+      if (!Array.isArray(item.children)) {
+        errors.push(err(`${path}/children`, "List item `children` must be an array of list items."));
+      } else {
+        item.children.forEach((child, i) => {
+          errors.push(...this.validateListItem(child, `${path}/children/${i}`));
+        });
+      }
+    }
+    return errors;
+  }
+};
+
+// src/agent.ts
+var VERSION = "0.1.0";
+function toU8(input) {
+  return input instanceof Uint8Array ? input : new Uint8Array(input);
+}
+function assertValid(doc) {
+  const errors = new Validator().validate(doc);
+  if (errors.length > 0) {
+    throw new SchemaException(
+      "Doc failed schema validation. Call Agent.validateAndRepair() for a recoverable form.",
+      errors
+    );
+  }
+}
+var Agent = {
+  /** Validate a doc without writing. Empty array = valid. */
+  validate(doc) {
+    return new Validator().validate(doc);
+  },
+  /**
+   * Validate + apply heuristic repairs (coerce strings to runs, clamp heading
+   * levels, drop unknown block types with the error retained, default missing
+   * blocks to []). Returns `{ ok, schema, errors }` where `ok` is true when
+   * the repaired doc validates clean; `errors` retains anything the repair
+   * dropped plus any remaining validation errors.
+   */
+  validateAndRepair(doc) {
+    const errors = this.validate(doc);
+    if (errors.length === 0) {
+      return { ok: true, schema: doc, errors: [] };
+    }
+    const repairer = new Repairer();
+    const repaired = repairer.repair(doc);
+    const remaining = this.validate(repaired);
+    return {
+      ok: remaining.length === 0,
+      schema: repaired,
+      errors: [...repairer.notes, ...remaining]
+    };
+  },
+  /** DOCX bytes for a doc (no temp file). Universal. Throws SchemaException if invalid. */
+  toBytes(doc) {
+    assertValid(doc);
+    return new DocxWriter().toBytes(doc);
+  },
+  /** Write a doc to disk as a .docx file (Node only). Throws SchemaException if invalid. */
+  async write(doc, path) {
+    assertValid(doc);
+    const bytes = new DocxWriter().toBytes(doc);
+    const fs = await import('fs');
+    fs.writeFileSync(path, bytes);
+    return { path, bytes: bytes.length, blocks: doc?.blocks?.length ?? 0 };
+  },
+  /** Read .docx bytes back into the Doc model. Universal. */
+  read(input) {
+    return new DocxReader().read(toU8(input));
+  },
+  /** Alias for {@see read}. */
+  fromBytes(input) {
+    return new DocxReader().read(toU8(input));
+  },
+  /** Doc → GFM markdown (the Editor bridge). */
+  toMarkdown(doc) {
+    return toMarkdown(doc);
+  },
+  /** GFM markdown → Doc (the Editor bridge). */
+  fromMarkdown(markdown) {
+    return fromMarkdown(markdown);
+  },
+  /** Plain-text summary of a doc: title, block counts by type, word count. */
+  describe(doc) {
+    const title = String(doc?.title ?? "Untitled");
+    const blocks = Array.isArray(doc?.blocks) ? doc.blocks : [];
+    const counts = {};
+    for (const block of blocks) {
+      const type = String(block?.type ?? "unknown");
+      counts[type] = (counts[type] ?? 0) + 1;
+    }
+    const lines = [`Doc: ${title}`, `Blocks: ${blocks.length}`];
+    const keys = Object.keys(counts);
+    if (keys.length > 0) {
+      lines.push("Kinds: " + keys.map((type) => `${counts[type]} ${type}`).join(", "));
+    }
+    lines.push(`Words: ${countWords(blocks)}`);
+    return lines.join("\n");
+  },
+  /** JSON Schema export for LLM tool-use registration. */
+  jsonSchema() {
+    return Schema.jsonSchema();
+  },
+  version() {
+    return VERSION;
+  }
+};
+function countWords(blocks) {
+  let text = "";
+  const visitRuns = (runs) => {
+    for (const run of runs ?? []) {
+      if (typeof run?.text === "string") text += run.text + " ";
+    }
+  };
+  const visitItems = (items) => {
+    for (const item of items ?? []) {
+      visitRuns(item.runs);
+      visitItems(item.children);
+    }
+  };
+  const visit = (list) => {
+    for (const block of list ?? []) {
+      switch (block?.type) {
+        case "heading":
+        case "paragraph":
+          visitRuns(block.runs);
+          break;
+        case "list":
+          visitItems(block.items);
+          break;
+        case "table":
+          for (const row of block.rows ?? []) {
+            for (const cell of row?.cells ?? []) visit(cell?.blocks ?? []);
+          }
+          break;
+        case "quote":
+          visit(block.blocks ?? []);
+          break;
+      }
+    }
+  };
+  visit(blocks);
+  return text.split(/\s+/).filter(Boolean).length;
+}
+
+export { Agent, DocxReader, DocxWriter, EMU_PER_PX, MAX_WIDTH_PX, Repairer, Schema, SchemaException, VERSION, Validator, fromMarkdown, jpegSize, mergeRuns, parseDataUrl, parseInline, pngSize, resolveImageSize, sniffImageSize, toMarkdown, unzipSync, zipSync };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map