@uurtech/jdf-cli 0.1.25 → 0.2.0

package/dist/index.js

@@ -1,13 +1,20 @@
 #!/usr/bin/env node
-import fs from 'fs';
-import path2 from 'path';
+import fs7 from 'fs';
+import path7 from 'path';
 import { fileURLToPath } from 'url';
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
 import JSZip from 'jszip';
 import crypto, { createHash } from 'crypto';
 import { readFile } from 'fs/promises';
-import { execFileSync } from 'child_process';
+import { execFileSync, spawnSync } from 'child_process';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // ../../packages/jdf-core/src/manifest.ts
 var JDFX_MANIFEST_VERSION = "1.0.0";
@@ -16,17 +23,17 @@ var JDFX_MANIFEST_PATH = "manifest.json";
 var JDFX_ASSET_DIR = "assets";
 
 // src/commands/validate.ts
-var __dirname$1 = path2.dirname(fileURLToPath(import.meta.url));
+var __dirname$1 = path7.dirname(fileURLToPath(import.meta.url));
 function resolveSchemaPath() {
-  const bundled = path2.resolve(__dirname$1, "jdf-schema.json");
-  if (fs.existsSync(bundled)) return bundled;
-  const dev = path2.resolve(__dirname$1, "../../../../spec/jdf-schema.json");
+  const bundled = path7.resolve(__dirname$1, "jdf-schema.json");
+  if (fs7.existsSync(bundled)) return bundled;
+  const dev = path7.resolve(__dirname$1, "../../../../spec/jdf-schema.json");
   return dev;
 }
 var SCHEMA_PATH = resolveSchemaPath();
 async function loadDocument(filePath) {
   if (filePath.toLowerCase().endsWith(".jdfx")) {
-    const zip = await JSZip.loadAsync(fs.readFileSync(filePath));
+    const zip = await JSZip.loadAsync(fs7.readFileSync(filePath));
     const docFile = zip.file(JDFX_DOCUMENT_PATH);
     if (!docFile) {
       console.error(`\u2717 Bundle missing ${JDFX_DOCUMENT_PATH}`);
@@ -51,11 +58,11 @@ async function loadDocument(filePath) {
     }
     return { doc, bundle: { manifest, assetCount } };
   }
-  return { doc: JSON.parse(fs.readFileSync(filePath, "utf-8")) };
+  return { doc: JSON.parse(fs7.readFileSync(filePath, "utf-8")) };
 }
 async function validate(file) {
-  const filePath = path2.resolve(file);
-  if (!fs.existsSync(filePath)) {
+  const filePath = path7.resolve(file);
+  if (!fs7.existsSync(filePath)) {
     console.error(`File not found: ${filePath}`);
     return false;
   }
@@ -68,11 +75,11 @@ async function validate(file) {
   }
   if (!loaded) return false;
   const { doc, bundle } = loaded;
-  if (!fs.existsSync(SCHEMA_PATH)) {
+  if (!fs7.existsSync(SCHEMA_PATH)) {
     console.error(`Schema not found at ${SCHEMA_PATH}`);
     return false;
   }
-  const schema = JSON.parse(fs.readFileSync(SCHEMA_PATH, "utf-8"));
+  const schema = JSON.parse(fs7.readFileSync(SCHEMA_PATH, "utf-8"));
   const ajv = new Ajv({ allErrors: true, strict: false });
   addFormats(ajv);
   const validateFn = ajv.compile(schema);
@@ -81,7 +88,7 @@ async function validate(file) {
     const d = doc;
     const pageCount = Array.isArray(d.pages) ? d.pages.length : 0;
     const elCount = Array.isArray(d.pages) ? d.pages.reduce((acc, p) => acc + (Array.isArray(p?.elements) ? p.elements.length : 0), 0) : 0;
-    console.log(`\u2713 Valid: ${path2.basename(filePath)}`);
+    console.log(`\u2713 Valid: ${path7.basename(filePath)}`);
     console.log(`  Format:    ${d.$jdf}${bundle ? " (jdfx bundle)" : ""}`);
     console.log(`  Title:     ${d.meta?.title}`);
     console.log(`  Pages:     ${pageCount}`);
@@ -94,7 +101,7 @@ async function validate(file) {
     }
     return true;
   }
-  console.error(`\u2717 Invalid: ${path2.basename(filePath)}`);
+  console.error(`\u2717 Invalid: ${path7.basename(filePath)}`);
   for (const err of validateFn.errors || []) {
     const loc = err.instancePath || "(root)";
     console.error(`  ${loc} \u2014 ${err.message}`);
@@ -109,15 +116,15 @@ function hashBytes(bytes) {
   return createHash("sha1").update(bytes).digest("hex").slice(0, 16);
 }
 function rewriteResourceRefs(doc, oldKey, newKey) {
-  function walk(els) {
+  function walk2(els) {
     if (!els) return;
     for (const el of els) {
       if (el?.resource === oldKey) el.resource = newKey;
-      if (el?.elements) walk(el.elements);
-      if (el?.children) walk(el.children);
+      if (el?.elements) walk2(el.elements);
+      if (el?.children) walk2(el.children);
     }
   }
-  for (const page of doc.pages || []) walk(page.elements);
+  for (const page of doc.pages || []) walk2(page.elements);
 }
 function extractAssets(doc) {
   const assets = [];
@@ -149,10 +156,10 @@ function extractAssets(doc) {
     assets.push({ id, bytes, mimeType, ext });
     return id;
   }
-  function walk(els) {
+  function walk2(els) {
     if (!els) return;
     for (const el of els) {
-      if (el?.type === "image" && typeof el.src === "string" && el.src.startsWith("data:")) {
+      if ((el?.type === "image" || el?.type === "video") && typeof el.src === "string" && el.src.startsWith("data:")) {
         const m = el.src.match(/^data:([^;]+);base64,(.*)$/);
         if (m) {
           const mimeType = m[1];
@@ -162,19 +169,21 @@ function extractAssets(doc) {
           el.resource = id;
         }
       }
-      if (el?.elements) walk(el.elements);
-      if (el?.children) walk(el.children);
+      if (el?.elements) walk2(el.elements);
+      if (el?.children) walk2(el.children);
     }
   }
-  for (const page of cloned.pages || []) walk(page.elements);
-  if (cloned.resources?.images) {
-    for (const [key, res] of Object.entries(cloned.resources.images)) {
+  for (const page of cloned.pages || []) walk2(page.elements);
+  for (const bucket of ["images", "videos"]) {
+    const store = cloned.resources?.[bucket];
+    if (!store) continue;
+    for (const [key, res] of Object.entries(store)) {
       if (!res || typeof res !== "object" || !("data" in res) || !res.data) continue;
       const data = String(res.data);
       const m = data.match(/^data:([^;]+);base64,(.*)$/);
       const b64 = m ? m[2] : data;
-      const mimeType = m ? m[1] : res.mimeType || "image/png";
-      const ext = mimeType.split("/")[1]?.replace("jpeg", "jpg") || "bin";
+      const mimeType = m ? m[1] : res.mimeType || (bucket === "videos" ? "video/mp4" : "image/png");
+      const ext = mimeType.split("/")[1]?.replace("jpeg", "jpg").replace("quicktime", "mov") || "bin";
       const bytes = decodeBase64(b64);
       const h = hashBytes(bytes);
       let canonicalId = hashToId.get(h);
@@ -188,10 +197,10 @@ function extractAssets(doc) {
       delete updated.data;
       updated.src = "embedded";
       if (canonicalId !== key) {
-        delete cloned.resources.images[key];
+        delete store[key];
         rewriteResourceRefs(cloned, key, canonicalId);
       } else {
-        cloned.resources.images[key] = updated;
+        store[key] = updated;
       }
     }
   }
@@ -221,21 +230,22 @@ async function packJdfx(doc) {
   return { bytes, manifest };
 }
 function shouldUseJdfx(doc) {
-  const images = doc.resources?.images ?? {};
-  for (const v of Object.values(images)) {
-    if (v && typeof v === "object" && "data" in v && v.data) return true;
+  for (const store of [doc.resources?.images ?? {}, doc.resources?.videos ?? {}]) {
+    for (const v of Object.values(store)) {
+      if (v && typeof v === "object" && "data" in v && v.data) return true;
+    }
   }
-  function walk(els) {
+  function walk2(els) {
     if (!els) return false;
     for (const el of els) {
-      if (el?.type === "image" && typeof el.src === "string" && el.src.startsWith("data:")) return true;
-      if (el?.elements && walk(el.elements)) return true;
-      if (el?.children && walk(el.children)) return true;
+      if ((el?.type === "image" || el?.type === "video") && typeof el.src === "string" && el.src.startsWith("data:")) return true;
+      if (el?.elements && walk2(el.elements)) return true;
+      if (el?.children && walk2(el.children)) return true;
     }
     return false;
   }
   for (const page of doc.pages || []) {
-    if (walk(page.elements)) return true;
+    if (walk2(page.elements)) return true;
   }
   return false;
 }
@@ -294,13 +304,13 @@ function stripInline(text) {
   return parseInline(text).map((r) => r.text).join("");
 }
 async function importMarkdown(inputPath, outputPath) {
-  const input = path2.resolve(inputPath);
+  const input = path7.resolve(inputPath);
   console.log(`Importing: ${input}`);
-  const content = fs.readFileSync(input, "utf-8");
-  const doc = convertMarkdownToJdf(content, path2.basename(input, path2.extname(input)), path2.dirname(input));
+  const content = fs7.readFileSync(input, "utf-8");
+  const doc = convertMarkdownToJdf(content, path7.basename(input, path7.extname(input)), path7.dirname(input));
   let output;
   if (outputPath) {
-    output = path2.resolve(outputPath);
+    output = path7.resolve(outputPath);
   } else {
     const stem = input.replace(/\.(md|markdown)$/i, "");
     output = stem + (shouldUseJdfx(doc) ? ".jdfx" : ".jdf");
@@ -308,11 +318,11 @@ async function importMarkdown(inputPath, outputPath) {
   console.log(`Output:    ${output}`);
   if (output.toLowerCase().endsWith(".jdfx")) {
     const { bytes, manifest } = await packJdfx(doc);
-    fs.writeFileSync(output, bytes);
+    fs7.writeFileSync(output, bytes);
     console.log(`
 Done! Created ${doc.pages.length} page(s), ${manifest.assets.length} asset(s) bundled`);
   } else {
-    fs.writeFileSync(output, JSON.stringify(doc, null, 2));
+    fs7.writeFileSync(output, JSON.stringify(doc, null, 2));
     console.log(`
 Done! Created ${doc.pages.length} page(s)`);
   }
@@ -329,10 +339,10 @@ var MIME_BY_EXT2 = {
 };
 function resolveImageSrc(src, baseDir) {
   if (/^(https?:|data:|file:)/i.test(src)) return src;
-  const abs = path2.isAbsolute(src) ? src : path2.resolve(baseDir, src);
+  const abs = path7.isAbsolute(src) ? src : path7.resolve(baseDir, src);
   try {
-    const bytes = fs.readFileSync(abs);
-    const ext = path2.extname(abs).slice(1).toLowerCase();
+    const bytes = fs7.readFileSync(abs);
+    const ext = path7.extname(abs).slice(1).toLowerCase();
     const mime = MIME_BY_EXT2[ext] || "application/octet-stream";
     return `data:${mime};base64,${bytes.toString("base64")}`;
   } catch {
@@ -613,8 +623,232 @@ function convertMarkdownToJdf(md, title, baseDir = process.cwd()) {
   };
 }
 
-// ../../packages/jdf-pdf-import/src/core.ts
+// ../../packages/jdf-pdf-import/src/tables.ts
 var PT_TO_MM = 0.352778;
+function calibrateGlyphWidth(runs) {
+  const ks = [];
+  for (const r of runs) {
+    const t = r.text;
+    if (/\s$/.test(t) || t.trim().length < 3 || r.width <= 0) continue;
+    ks.push(r.width / (t.length * r.fontSize * PT_TO_MM));
+  }
+  if (ks.length < 3) return 0.55;
+  ks.sort((a, b) => a - b);
+  return Math.min(0.7, Math.max(0.4, ks[Math.floor(ks.length / 2)]));
+}
+function hasStretchedSpaces(runs, k) {
+  let n = 0, wide = 0;
+  for (const r of runs) {
+    if (!/\s$/.test(r.text) || r.text.trim().length === 0) continue;
+    const em = r.fontSize * PT_TO_MM;
+    const est = r.text.trim().length * em * k + em * 0.25;
+    n++;
+    if (r.width > est * 1.4) wide++;
+  }
+  return n >= 4 && wide / n >= 0.3;
+}
+function textExtent(r, k, stretched) {
+  const em = r.fontSize * PT_TO_MM;
+  if (!/\s$/.test(r.text)) return Math.max(em * 0.5, r.width);
+  const chars = Math.max(1, r.text.trim().length);
+  const est = chars * em * k + em * 0.25;
+  if (stretched) return Math.max(em * 0.5, Math.min(r.width, est));
+  return Math.max(em * 0.5, r.width > est * 1.4 ? est : r.width);
+}
+function groupRows(runs, skip) {
+  const k = calibrateGlyphWidth(runs);
+  const stretched = hasStretchedSpaces(runs, k);
+  const idx = runs.map((_, i) => i).filter((i) => !skip(runs[i]) && runs[i].text.trim().length > 0);
+  idx.sort((a, b) => runs[a].y - runs[b].y || runs[a].x - runs[b].x);
+  const rows = [];
+  for (const i of idx) {
+    const r = runs[i];
+    const tol = Math.max(0.8, r.fontSize * PT_TO_MM * 0.35);
+    const last = rows[rows.length - 1];
+    const cell = { run: r, idx: i, x0: r.x, x1: r.x + textExtent(r, k, stretched) };
+    if (last && Math.abs(last.y - r.y) <= tol) {
+      last.cells.push(cell);
+      last.h = Math.max(last.h, r.height);
+    } else {
+      rows.push({ y: r.y, h: r.height, cells: [cell] });
+    }
+  }
+  for (const row of rows) {
+    row.cells.sort((a, b) => a.x0 - b.x0);
+    const merged = [];
+    for (const c of row.cells) {
+      const last = merged[merged.length - 1];
+      const em = c.run.fontSize * PT_TO_MM;
+      if (last && c.x0 - last.x1 <= em * 1) {
+        last.x1 = Math.max(last.x1, c.x1);
+        last.run = { ...last.run, text: `${last.run.text.replace(/\s+$/, "")} ${c.run.text.replace(/^\s+/, "")}`, width: last.x1 - last.x0 };
+        last.extra = [...last.extra ?? [], c.idx];
+      } else merged.push({ ...c });
+    }
+    row.cells = merged;
+  }
+  return rows;
+}
+function columnBands(rows) {
+  const cells = rows.flatMap((r) => r.cells);
+  const sorted = cells.slice().sort((a, b) => a.x0 - b.x0);
+  const bands = [];
+  for (const c of sorted) {
+    const last = bands[bands.length - 1];
+    if (last && c.x0 <= last.x1 - 0.2) {
+      last.x1 = Math.max(last.x1, c.x1);
+      last.members.push(c);
+    } else bands.push({ x0: c.x0, x1: c.x1, members: [c] });
+  }
+  for (const b of bands) {
+    const rowsSeen = /* @__PURE__ */ new Set();
+    for (const m of b.members) {
+      const row = rows.find((r) => r.cells.includes(m));
+      if (rowsSeen.has(row)) return null;
+      rowsSeen.add(row);
+    }
+  }
+  return bands.map(({ x0, x1 }) => ({ x0, x1 }));
+}
+var numeric = (s) => /^[\s$€£¥+\-−–]*[\d.,]+\s*(%|ms|s|k|m|b|M|K|B|x|×)?\s*(\/\w+)?$/i.test(s.trim()) || /^[+\-−]?\d/.test(s.trim()) && /\d$/.test(s.trim().replace(/[%)]$/, ""));
+function detectTables(runs, shapes, pageWidthMm) {
+  const out = [];
+  const used = /* @__PURE__ */ new Set();
+  const rows = groupRows(runs, () => false);
+  const pageW = pageWidthMm;
+  let i = 0;
+  while (i < rows.length) {
+    if (rows[i].cells.length < 2) {
+      i++;
+      continue;
+    }
+    let j = i;
+    let cur = columnBands([rows[i]]);
+    let best = null;
+    while (j + 1 < rows.length && cur) {
+      const next = rows[j + 1];
+      const gap = next.y - (rows[j].y + rows[j].h);
+      const rowH = Math.max(rows[j].h, next.h);
+      if (gap > rowH * 2.2) break;
+      if (next.cells.length === 1) {
+        const c = next.cells[0];
+        const inBand = cur.findIndex((b) => c.x0 < b.x1 - 0.2 && c.x1 > b.x0 + 0.2);
+        const spansSeveral = cur.filter((b) => c.x0 < b.x1 - 0.2 && c.x1 > b.x0 + 0.2).length > 1;
+        if (inBand <= 0 || spansSeveral) break;
+        j++;
+        continue;
+      }
+      const nb = columnBands(rows.slice(i, j + 2));
+      if (!nb || nb.length < 2) break;
+      if (nb.length > cur.length && j - i >= 2) break;
+      cur = nb;
+      j++;
+      if (cur.length >= 2) best = { j, bands: cur };
+    }
+    const multiRows = best ? rows.slice(i, best.j + 1).filter((r) => r.cells.length >= 2).length : 0;
+    const blockRows = best ? rows.slice(i, best.j + 1) : [];
+    const bbox = blockRows.length ? {
+      x0: Math.min(...best.bands.map((b) => b.x0)) - 5,
+      x1: Math.max(...best.bands.map((b) => b.x1)) + 5,
+      // Cell padding puts backgrounds/borders well above the first baseline and below the last.
+      y0: blockRows[0].y - blockRows[0].h * 2.5,
+      y1: blockRows[blockRows.length - 1].y + blockRows[blockRows.length - 1].h * 3
+    } : null;
+    const gridShapes = bbox ? shapes.map((s, k) => ({ s, k })).filter(({ s }) => s.x >= bbox.x0 - 1 && s.x + s.width <= bbox.x1 + 1 && s.y >= bbox.y0 - 1 && s.y + s.height <= bbox.y1 + 1 && (s.kind === "line" || s.kind === "rect")) : [];
+    const hasLattice = gridShapes.length >= 3;
+    if (!best || multiRows < (hasLattice ? 2 : 3) || best.bands.length < 2) {
+      i++;
+      continue;
+    }
+    const bands = best.bands;
+    const cellText = (row, b) => row.cells.filter((c) => c.x0 < bands[b].x1 - 0.2 && c.x1 > bands[b].x0 + 0.2).map((c) => c.run.text.trim()).join(" ").trim();
+    const grid = [];
+    const lineIdx = [];
+    for (const row of blockRows) {
+      if (row.cells.length === 1 && grid.length) {
+        const c = row.cells[0];
+        const b = bands.findIndex((bb) => c.x0 < bb.x1 - 0.2 && c.x1 > bb.x0 + 0.2);
+        if (b > 0) {
+          grid[grid.length - 1][b] = (grid[grid.length - 1][b] + " " + c.run.text.trim()).trim();
+          lineIdx.push(c.idx, ...c.extra ?? []);
+          continue;
+        }
+      }
+      grid.push(bands.map((_, b) => cellText(row, b)));
+      for (const c of row.cells) {
+        lineIdx.push(c.idx);
+        for (const k of c.extra ?? []) lineIdx.push(k);
+      }
+    }
+    if (lineIdx.some((k) => used.has(k))) {
+      i = best.j + 1;
+      continue;
+    }
+    const first = blockRows[0];
+    const tableW = bbox.x1 - bbox.x0;
+    const rowFill = (row) => {
+      const cy = row.y + row.h * 0.5;
+      const rects = gridShapes.filter(({ s }) => s.kind === "rect" && s.fill && s.fill.toLowerCase() !== "#ffffff" && s.height >= row.h * 0.6 && s.height < row.h * 4.5 && s.y <= cy && s.y + s.height >= cy);
+      const covered = rects.reduce((a, { s }) => a + s.width, 0);
+      if (!rects.length || covered < tableW * 0.5) return null;
+      const counts = /* @__PURE__ */ new Map();
+      for (const { s } of rects) counts.set(s.fill, (counts.get(s.fill) ?? 0) + s.width);
+      const fill = [...counts.entries()].sort((a, b) => b[1] - a[1])[0][0];
+      return { fill, rects };
+    };
+    const headerBg = rowFill(first);
+    const firstBold = first.cells.every((c) => c.run.bold);
+    const bodyFills = blockRows.slice(1).map(rowFill);
+    const headerDistinct = !!headerBg && !bodyFills.every((f) => f?.fill === headerBg.fill);
+    const isHeader = headerDistinct || firstBold && !blockRows.slice(1).every((r) => r.cells.every((c) => c.run.bold));
+    const columns = bands.map((b, k) => {
+      const vals = grid.slice(isHeader ? 1 : 0).map((r) => r[k]).filter(Boolean);
+      const numericShare = vals.length ? vals.filter(numeric).length / vals.length : 0;
+      const col = { width: Math.round((b.x1 - b.x0) * 10) / 10 };
+      if (numericShare >= 0.7) col.align = "right";
+      return col;
+    });
+    const x0 = Math.max(0, bands[0].x0 - 2.5);
+    const x1 = Math.min(pageW, bands[bands.length - 1].x1 + 2.5);
+    for (let k = 0; k < bands.length; k++) {
+      const left = k === 0 ? x0 : (bands[k - 1].x1 + bands[k].x0) / 2;
+      const right = k === bands.length - 1 ? x1 : (bands[k].x1 + bands[k + 1].x0) / 2;
+      columns[k].width = Math.round((right - left) * 10) / 10;
+    }
+    const rowFills = (isHeader ? bodyFills : [headerBg, ...bodyFills]).map((f) => f?.fill ?? null);
+    const odd = rowFills.filter((_, k) => k % 2 === 1), even = rowFills.filter((_, k) => k % 2 === 0);
+    const altColor = odd.length && odd[0] && odd.every((f) => f === odd[0]) && even.every((f) => f !== odd[0]) ? odd[0] : void 0;
+    const borderShape = gridShapes.find(({ s }) => s.kind === "line" || s.kind === "rect" && (s.height < 0.6 || s.width < 0.6) && (s.fill || s.stroke));
+    const borderColor = borderShape ? borderShape.s.stroke || borderShape.s.fill : void 0;
+    const fontSize = Math.round(first.cells[0].run.fontSize * 10) / 10;
+    const y0 = headerBg ? Math.min(...headerBg.rects.map(({ s }) => s.y)) : first.y - first.h * 0.5;
+    const element = {
+      type: "table",
+      position: { x: Math.round(x0 * 100) / 100, y: Math.round(Math.max(0, y0) * 100) / 100 },
+      width: Math.round((x1 - x0) * 100) / 100,
+      columns,
+      rows: isHeader ? grid.slice(1) : grid,
+      style: { fontSize }
+    };
+    if (isHeader) {
+      element.headers = grid[0];
+      const hs = { fontWeight: "bold" };
+      if (headerBg) hs.backgroundColor = headerBg.fill;
+      const hc = first.cells[0].run.color;
+      if (hc && hc !== "#000000") hs.color = hc;
+      element.headerStyle = hs;
+    }
+    if (altColor) element.alternatingRowColor = altColor;
+    element.borders = borderColor ? { outer: true, inner: true, color: borderColor, width: 1 } : false;
+    for (const k of lineIdx) used.add(k);
+    out.push({ element, lineIdx, shapeIdx: gridShapes.map(({ k }) => k) });
+    i = best.j + 1;
+  }
+  return out;
+}
+
+// ../../packages/jdf-pdf-import/src/core.ts
+var PT_TO_MM2 = 0.352778;
 function classifyFont(name) {
   const n = (name || "").toLowerCase();
   const bold = /bold|black|heavy|semibold|demibold|extrabold/.test(n);
@@ -640,6 +874,38 @@ function rgbToHex(r, g, b) {
   const h = (n) => clampByte(n).toString(16).padStart(2, "0");
   return `#${h(r)}${h(g)}${h(b)}`;
 }
+function averageStops(stops) {
+  if (!Array.isArray(stops) || stops.length === 0) return null;
+  let r = 0, g = 0, b = 0, n = 0;
+  for (const st of stops) {
+    const css = Array.isArray(st) ? st[1] : null;
+    const m = typeof css === "string" && css.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
+    if (!m) continue;
+    r += parseInt(m[1], 16);
+    g += parseInt(m[2], 16);
+    b += parseInt(m[3], 16);
+    n++;
+  }
+  return n ? rgbToHex(r / n, g / n, b / n) : null;
+}
+function patternToColor(page, arg) {
+  if (!Array.isArray(arg)) return null;
+  if (arg[0] === "TilingPattern") {
+    const c = arg[1];
+    return Array.isArray(c) && c.length >= 3 ? rgbToHex(c[0], c[1], c[2]) : null;
+  }
+  if (arg[0] === "Shading") {
+    const id = arg[1];
+    try {
+      const store = typeof id === "string" && id.startsWith("g_") ? page.commonObjs : page.objs;
+      if (typeof store?.has === "function" && !store.has(id)) return null;
+      const ir = store.get(id);
+      if (Array.isArray(ir) && ir[0] === "RadialAxial") return averageStops(ir[3]);
+    } catch {
+    }
+  }
+  return null;
+}
 function multiplyCtm(a, b) {
   return [
     a[0] * b[0] + a[1] * b[2],
@@ -658,7 +924,7 @@ async function walkOps(page, OPS, viewport) {
     const [vx, vy] = viewport.convertToViewportPoint(x, y);
     return { x: vx, y: vy };
   };
-  const opList = await page.getOperatorList();
+  const opList = await page.getOperatorList({ annotationMode: annotationModeDisable });
   const fnArr = opList.fnArray;
   const argsArr = opList.argsArray;
   const gs = {
@@ -668,20 +934,60 @@ async function walkOps(page, OPS, viewport) {
     lineWidth: 1,
     fillAlpha: 1,
     strokeAlpha: 1,
-    textRenderingMode: 0
+    textRenderingMode: 0,
+    // Text state (PDF 9.3) — needed to know where each showText lands.
+    fontSize: 0,
+    charSpacing: 0,
+    wordSpacing: 0,
+    hscale: 1,
+    leading: 0,
+    rise: 0
   };
+  const snapshot = () => ({ ...gs, ctm: [...gs.ctm] });
   const stack = [];
-  const textColors = [];
-  const textOpacities = [];
-  const textRenderingModes = [];
+  const textOps = [];
   const shapes = [];
   const imagePositions = [];
-  let textIdx = 0;
+  let tm = [1, 0, 0, 1, 0, 0];
+  let tlm = [1, 0, 0, 1, 0, 0];
+  function pushImage(name, ctm, inline, maskFill) {
+    const corners = [tx(ctm, 0, 0), tx(ctm, 1, 0), tx(ctm, 1, 1), tx(ctm, 0, 1)];
+    const vpCorners = corners.map((p) => toViewport(p.x, p.y));
+    const xs = vpCorners.map((p) => p.x), ys = vpCorners.map((p) => p.y);
+    const minX = Math.min(...xs), maxX = Math.max(...xs);
+    const minY = Math.min(...ys), maxY = Math.max(...ys);
+    imagePositions.push({
+      name,
+      x: minX * PT_TO_MM2,
+      y: minY * PT_TO_MM2,
+      w: (maxX - minX) * PT_TO_MM2,
+      h: (maxY - minY) * PT_TO_MM2,
+      inline,
+      maskFill
+    });
+  }
   let pathSegments = [];
   let pathRect = null;
+  let pathRects = [];
   let pathStart = null;
   let pathLast = null;
   function flushPath(isFill, isStroke) {
+    for (const r of pathRects) {
+      const tl = toViewport(r.x, r.y + r.h);
+      const br = toViewport(r.x + r.w, r.y);
+      shapes.push({
+        kind: "rect",
+        x: Math.min(tl.x, br.x) * PT_TO_MM2,
+        y: Math.min(tl.y, br.y) * PT_TO_MM2,
+        width: Math.abs(br.x - tl.x) * PT_TO_MM2,
+        height: Math.abs(br.y - tl.y) * PT_TO_MM2,
+        fill: isFill ? gs.fill : void 0,
+        stroke: isStroke ? gs.stroke : void 0,
+        strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM2 : void 0,
+        opacity: isFill ? gs.fillAlpha : gs.strokeAlpha
+      });
+    }
+    pathRects = [];
     if (pathRect) {
       const tl = toViewport(pathRect.x, pathRect.y + pathRect.h);
       const br = toViewport(pathRect.x + pathRect.w, pathRect.y);
@@ -691,13 +997,13 @@ async function walkOps(page, OPS, viewport) {
       const h = Math.abs(br.y - tl.y);
       shapes.push({
         kind: "rect",
-        x: x * PT_TO_MM,
-        y: y * PT_TO_MM,
-        width: w * PT_TO_MM,
-        height: h * PT_TO_MM,
+        x: x * PT_TO_MM2,
+        y: y * PT_TO_MM2,
+        width: w * PT_TO_MM2,
+        height: h * PT_TO_MM2,
         fill: isFill ? gs.fill : void 0,
         stroke: isStroke ? gs.stroke : void 0,
-        strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM : void 0,
+        strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM2 : void 0,
         opacity: isFill ? gs.fillAlpha : gs.strokeAlpha
       });
     } else if (pathSegments.length === 2 && pathSegments[0].type === "M" && pathSegments[1].type === "L") {
@@ -709,35 +1015,35 @@ async function walkOps(page, OPS, viewport) {
       const minY = Math.min(va.y, vb.y);
       const maxX = Math.max(va.x, vb.x);
       const maxY = Math.max(va.y, vb.y);
-      const x1Local = (va.x - minX) * PT_TO_MM;
-      const y1Local = (va.y - minY) * PT_TO_MM;
-      const x2Local = (vb.x - minX) * PT_TO_MM;
-      const y2Local = (vb.y - minY) * PT_TO_MM;
-      const wLocal = Math.max(0.05, (maxX - minX) * PT_TO_MM);
-      const hLocal = Math.max(0.05, (maxY - minY) * PT_TO_MM);
+      const x1Local = (va.x - minX) * PT_TO_MM2;
+      const y1Local = (va.y - minY) * PT_TO_MM2;
+      const x2Local = (vb.x - minX) * PT_TO_MM2;
+      const y2Local = (vb.y - minY) * PT_TO_MM2;
+      const wLocal = Math.max(0.05, (maxX - minX) * PT_TO_MM2);
+      const hLocal = Math.max(0.05, (maxY - minY) * PT_TO_MM2);
       const dx = Math.abs(va.x - vb.x);
       const dy = Math.abs(va.y - vb.y);
       const axisAligned = dx < 0.5 || dy < 0.5;
       if (axisAligned) {
         shapes.push({
           kind: "line",
-          x: minX * PT_TO_MM,
-          y: minY * PT_TO_MM,
+          x: minX * PT_TO_MM2,
+          y: minY * PT_TO_MM2,
           width: wLocal,
           height: hLocal,
           stroke: isStroke ? gs.stroke : void 0,
-          strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM : void 0,
+          strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM2 : void 0,
           opacity: gs.strokeAlpha
         });
       } else {
         shapes.push({
           kind: "path",
-          x: minX * PT_TO_MM,
-          y: minY * PT_TO_MM,
+          x: minX * PT_TO_MM2,
+          y: minY * PT_TO_MM2,
           width: wLocal,
           height: hLocal,
           stroke: isStroke ? gs.stroke : void 0,
-          strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM : void 0,
+          strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM2 : void 0,
           opacity: gs.strokeAlpha,
           path: `M ${x1Local.toFixed(2)} ${y1Local.toFixed(2)} L ${x2Local.toFixed(2)} ${y2Local.toFixed(2)}`
         });
@@ -770,20 +1076,20 @@ async function walkOps(page, OPS, viewport) {
           if (seg.type === "Z") return "Z";
           const p = [];
           for (let i = 0; i < seg.pts.length; i += 2) {
-            p.push(((seg.pts[i] - minX) * PT_TO_MM).toFixed(2));
-            p.push(((seg.pts[i + 1] - minY) * PT_TO_MM).toFixed(2));
+            p.push(((seg.pts[i] - minX) * PT_TO_MM2).toFixed(2));
+            p.push(((seg.pts[i + 1] - minY) * PT_TO_MM2).toFixed(2));
           }
           return `${seg.type} ${p.join(" ")}`;
         }).join(" ");
         shapes.push({
           kind: "path",
-          x: minX * PT_TO_MM,
-          y: minY * PT_TO_MM,
-          width: bw * PT_TO_MM,
-          height: bh * PT_TO_MM,
+          x: minX * PT_TO_MM2,
+          y: minY * PT_TO_MM2,
+          width: bw * PT_TO_MM2,
+          height: bh * PT_TO_MM2,
           fill: isFill ? gs.fill : void 0,
           stroke: isStroke ? gs.stroke : void 0,
-          strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM : void 0,
+          strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM2 : void 0,
           opacity: isFill ? gs.fillAlpha : gs.strokeAlpha,
           path: d
         });
@@ -798,10 +1104,51 @@ async function walkOps(page, OPS, viewport) {
     const fn = fnArr[i];
     const args = argsArr[i] || [];
     if (fn === OPS.save) {
-      stack.push({ ctm: [...gs.ctm], fill: gs.fill, stroke: gs.stroke, lineWidth: gs.lineWidth, fillAlpha: gs.fillAlpha, strokeAlpha: gs.strokeAlpha, textRenderingMode: gs.textRenderingMode });
+      stack.push(snapshot());
     } else if (fn === OPS.restore) {
       const s = stack.pop();
       if (s) Object.assign(gs, s);
+    } else if (fn === OPS.paintFormXObjectBegin) {
+      stack.push(snapshot());
+      const matrix = args[0];
+      if (Array.isArray(matrix) && matrix.length === 6) gs.ctm = multiplyCtm(matrix, gs.ctm);
+    } else if (fn === OPS.paintFormXObjectEnd) {
+      const s = stack.pop();
+      if (s) Object.assign(gs, s);
+    } else if (fn === OPS.beginText) {
+      tm = [1, 0, 0, 1, 0, 0];
+      tlm = [1, 0, 0, 1, 0, 0];
+    } else if (fn === OPS.setTextMatrix) {
+      tm = [...args];
+      tlm = [...tm];
+    } else if (fn === OPS.moveText) {
+      tlm = multiplyCtm([1, 0, 0, 1, args[0], args[1]], tlm);
+      tm = [...tlm];
+    } else if (fn === OPS.setLeadingMoveText) {
+      gs.leading = -args[1];
+      tlm = multiplyCtm([1, 0, 0, 1, args[0], args[1]], tlm);
+      tm = [...tlm];
+    } else if (fn === OPS.nextLine) {
+      tlm = multiplyCtm([1, 0, 0, 1, 0, -gs.leading], tlm);
+      tm = [...tlm];
+    } else if (fn === OPS.setLeading) {
+      gs.leading = args[0];
+    } else if (fn === OPS.setFont) {
+      gs.fontSize = typeof args[1] === "number" ? args[1] : gs.fontSize;
+    } else if (fn === OPS.setCharSpacing) {
+      gs.charSpacing = args[0];
+    } else if (fn === OPS.setWordSpacing) {
+      gs.wordSpacing = args[0];
+    } else if (fn === OPS.setHScale) {
+      gs.hscale = (args[0] ?? 100) / 100;
+    } else if (fn === OPS.setTextRise) {
+      gs.rise = args[0];
+    } else if (fn === OPS.setFillColorN) {
+      const c = patternToColor(page, args[0]);
+      if (c) gs.fill = c;
+    } else if (fn === OPS.setStrokeColorN) {
+      const c = patternToColor(page, args[0]);
+      if (c) gs.stroke = c;
     } else if (fn === OPS.transform) {
       gs.ctm = multiplyCtm(args, gs.ctm);
     } else if (fn === OPS.setFillRGBColor) {
@@ -835,11 +1182,23 @@ async function walkOps(page, OPS, viewport) {
           else if (key === "CA") gs.strokeAlpha = val;
         }
       }
-    } else if (fn === OPS.showText || fn === OPS.showSpacedText || fn === OPS.nextLineShowText || fn === OPS.nextLineSetSpacingShowText) {
-      textColors[textIdx] = gs.fill;
-      textOpacities[textIdx] = gs.fillAlpha;
-      textRenderingModes[textIdx] = gs.textRenderingMode;
-      textIdx++;
+    } else if (fn === OPS.showText) {
+      const trm = multiplyCtm(tm, gs.ctm);
+      const origin = tx(trm, 0, gs.rise);
+      const vp = toViewport(origin.x, origin.y);
+      const scale = Math.hypot(trm[2], trm[3]) || 1;
+      textOps.push({ x: vp.x, y: vp.y, fontSize: gs.fontSize * scale, fill: gs.fill, alpha: gs.fillAlpha, mode: gs.textRenderingMode });
+      let advance = 0;
+      const glyphs = Array.isArray(args[0]) ? args[0] : [];
+      for (const g of glyphs) {
+        if (typeof g === "number") {
+          advance += -g / 1e3 * gs.fontSize * gs.hscale;
+        } else if (g && typeof g === "object") {
+          const w = typeof g.width === "number" ? g.width : 0;
+          advance += (w / 1e3 * gs.fontSize + gs.charSpacing + (g.isSpace ? gs.wordSpacing : 0)) * gs.hscale;
+        }
+      }
+      tm = multiplyCtm([1, 0, 0, 1, advance, 0], tm);
     } else if (fn === OPS.rectangle) {
       const [x, y, w, h] = args;
       const p1 = tx(gs.ctm, x, y);
@@ -892,6 +1251,12 @@ async function walkOps(page, OPS, viewport) {
         } else if (op === OPS.closePath) {
           pathSegments.push({ type: "Z", pts: [] });
           if (pathStart) pathLast = { ...pathStart };
+        } else if (op === OPS.rectangle) {
+          const x = pathArgs[ai], y = pathArgs[ai + 1], w = pathArgs[ai + 2], h = pathArgs[ai + 3];
+          ai += 4;
+          const p1 = tx(gs.ctm, x, y);
+          const p3 = tx(gs.ctm, x + w, y + h);
+          pathRects.push({ x: Math.min(p1.x, p3.x), y: Math.min(p1.y, p3.y), w: Math.abs(p3.x - p1.x), h: Math.abs(p3.y - p1.y) });
         }
       }
     } else if (fn === OPS.fill || fn === OPS.stroke || fn === OPS.fillStroke || fn === OPS.eoFill || fn === OPS.eoFillStroke || fn === OPS.closeFillStroke || fn === OPS.closeStroke || fn === OPS.closeEOFillStroke) {
@@ -900,59 +1265,128 @@ async function walkOps(page, OPS, viewport) {
       flushPath(isFill, isStroke);
     } else if (fn === OPS.endPath || fn === OPS.clip || fn === OPS.eoClip) {
       pathSegments = [];
+      pathRects = [];
       pathRect = null;
       pathStart = null;
       pathLast = null;
-    } else if (fn === OPS.paintImageXObject || fn === OPS.paintImageMaskXObject || fn === OPS.paintInlineImageXObject) {
-      const name = args[0];
-      const c = gs.ctm;
-      const corners = [tx(c, 0, 0), tx(c, 1, 0), tx(c, 1, 1), tx(c, 0, 1)];
-      const vpCorners = corners.map((p) => toViewport(p.x, p.y));
-      const xs = vpCorners.map((p) => p.x), ys = vpCorners.map((p) => p.y);
-      const minX = Math.min(...xs), maxX = Math.max(...xs);
-      const minY = Math.min(...ys), maxY = Math.max(...ys);
-      imagePositions.push({
-        name,
-        x: minX * PT_TO_MM,
-        y: minY * PT_TO_MM,
-        w: (maxX - minX) * PT_TO_MM,
-        h: (maxY - minY) * PT_TO_MM
-      });
+    } else if (fn === OPS.paintImageXObject) {
+      pushImage(String(args[0]), gs.ctm);
+    } else if (fn === OPS.paintImageXObjectRepeat) {
+      const [name, scaleX, scaleY, positions] = args;
+      if (Array.isArray(positions)) {
+        for (let k = 0; k + 1 < positions.length; k += 2) {
+          pushImage(String(name), multiplyCtm([scaleX, 0, 0, scaleY, positions[k], positions[k + 1]], gs.ctm));
+        }
+      }
+    } else if (fn === OPS.paintInlineImageXObject) {
+      const img = args[0];
+      if (img && typeof img === "object") pushImage(`inline-${imagePositions.length}`, gs.ctm, img);
+    } else if (fn === OPS.paintImageMaskXObject) {
+      const img = args[0];
+      if (img && typeof img === "object") pushImage(`mask-${imagePositions.length}`, gs.ctm, img, gs.fill);
+    } else if (fn === OPS.paintImageMaskXObjectRepeat) {
+      const [img, scaleX, skewX, skewY, scaleY, positions] = args;
+      if (img && typeof img === "object" && Array.isArray(positions)) {
+        for (let k = 0; k + 1 < positions.length; k += 2) {
+          pushImage(`mask-${imagePositions.length}`, multiplyCtm([scaleX, skewX, skewY, scaleY, positions[k], positions[k + 1]], gs.ctm), img, gs.fill);
+        }
+      }
+    } else if (fn === OPS.paintImageMaskXObjectGroup) {
+      const group = args[0];
+      if (Array.isArray(group)) {
+        for (const img of group) {
+          if (img && typeof img === "object" && Array.isArray(img.transform)) {
+            pushImage(`mask-${imagePositions.length}`, multiplyCtm(img.transform, gs.ctm), img, gs.fill);
+          }
+        }
+      }
     }
   }
-  return { textColors, textOpacities, textRenderingModes, shapes, imagePositions };
+  return { textOps, shapes, imagePositions };
 }
 async function extractImages(page, positions, runtime, dataUrlCache) {
+  const resolveObj = (id) => new Promise((resolve) => {
+    let settled2 = false;
+    const timer = setTimeout(() => done(null), 250);
+    const done = (v) => {
+      if (settled2) return;
+      settled2 = true;
+      clearTimeout(timer);
+      resolve(v);
+    };
+    try {
+      const store = id.startsWith("g_") ? page.commonObjs : page.objs;
+      store.get(id, (img) => done(img));
+    } catch {
+      try {
+        page.objs.get(id, (img) => done(img));
+      } catch {
+        done(null);
+      }
+    }
+  });
+  const maskToRgba = (data, width, height, fill) => {
+    const m = fill.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
+    const r = m ? parseInt(m[1], 16) : 0, g = m ? parseInt(m[2], 16) : 0, b = m ? parseInt(m[3], 16) : 0;
+    const out = new Uint8ClampedArray(width * height * 4);
+    const rowBytes = width + 7 >> 3;
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const byte = data[y * rowBytes + (x >> 3)] ?? 255;
+        const bit = byte >> 7 - (x & 7) & 1;
+        const o = (y * width + x) * 4;
+        out[o] = r;
+        out[o + 1] = g;
+        out[o + 2] = b;
+        out[o + 3] = bit ? 0 : 255;
+      }
+    }
+    return out;
+  };
+  const encode = async (imgObj, maskFill) => {
+    if (!imgObj || !imgObj.width || !imgObj.height) return null;
+    let data = imgObj.data;
+    if (typeof data === "string") data = (await resolveObj(data))?.data ?? null;
+    if (maskFill) {
+      if (!data) return null;
+      return runtime.encodePng(imgObj.width, imgObj.height, 3, maskToRgba(data, imgObj.width, imgObj.height, maskFill));
+    }
+    if (data) {
+      let kind = imgObj.kind || 0;
+      if (!kind) {
+        const px = imgObj.width * imgObj.height;
+        if (data.length === px * 4) kind = 3;
+        else if (data.length === px * 3) kind = 2;
+        else if (data.length === (imgObj.width + 7 >> 3) * imgObj.height) kind = 1;
+      }
+      return runtime.encodePng(imgObj.width, imgObj.height, kind, data);
+    }
+    if (imgObj.bitmap) {
+      try {
+        const { canvas, context } = runtime.createCanvas(imgObj.width, imgObj.height);
+        context.drawImage(imgObj.bitmap, 0, 0);
+        if (typeof canvas.toDataURL === "function") return canvas.toDataURL("image/png");
+        if (typeof canvas.toBuffer === "function") return `data:image/png;base64,${canvas.toBuffer("image/png").toString("base64")}`;
+      } catch {
+      }
+    }
+    return null;
+  };
   const tasks = positions.map(async (pos) => {
+    if (pos.inline) {
+      const dataUrl2 = await encode(pos.inline, pos.maskFill);
+      return dataUrl2 ? { pos, dataUrl: dataUrl2 } : null;
+    }
     if (dataUrlCache.has(pos.name)) {
       return { pos, dataUrl: dataUrlCache.get(pos.name) };
     }
     let imgObj = null;
     try {
-      imgObj = await new Promise((resolve) => {
-        let settled2 = false;
-        const timer = setTimeout(() => done(null), 250);
-        const done = (v) => {
-          if (settled2) return;
-          settled2 = true;
-          clearTimeout(timer);
-          resolve(v);
-        };
-        try {
-          page.objs.get(pos.name, (img) => done(img));
-        } catch {
-          try {
-            page.commonObjs.get(pos.name, (img) => done(img));
-          } catch {
-            done(null);
-          }
-        }
-      });
+      imgObj = await resolveObj(pos.name);
     } catch {
       imgObj = null;
     }
-    if (!imgObj || !imgObj.data || !imgObj.width || !imgObj.height) return null;
-    const dataUrl = runtime.encodePng(imgObj.width, imgObj.height, imgObj.kind || 0, imgObj.data);
+    const dataUrl = await encode(imgObj);
     if (!dataUrl) return null;
     dataUrlCache.set(pos.name, dataUrl);
     return { pos, dataUrl };
@@ -960,7 +1394,20 @@ async function extractImages(page, positions, runtime, dataUrlCache) {
   const settled = await Promise.all(tasks);
   return settled.filter((x) => x !== null);
 }
-async function extractLinks(page, viewport) {
+async function resolveDestPage(doc, dest) {
+  try {
+    let d = dest;
+    if (typeof d === "string") d = await doc.getDestination(d);
+    if (Array.isArray(d) && d[0] != null) {
+      if (typeof d[0] === "number") return d[0];
+      const idx = await doc.getPageIndex(d[0]);
+      if (typeof idx === "number") return idx;
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function extractLinks(doc, page, viewport) {
   const out = [];
   let annots = [];
   try {
@@ -983,13 +1430,15 @@ async function extractLinks(page, viewport) {
     const xMax = Math.max(c1.x, c2.x);
     const yMax = Math.max(c1.y, c2.y);
     const rectMm = {
-      x: xMin * PT_TO_MM,
-      y: yMin * PT_TO_MM,
-      w: (xMax - xMin) * PT_TO_MM,
-      h: (yMax - yMin) * PT_TO_MM
+      x: xMin * PT_TO_MM2,
+      y: yMin * PT_TO_MM2,
+      w: (xMax - xMin) * PT_TO_MM2,
+      h: (yMax - yMin) * PT_TO_MM2
     };
     const url = a.url || a.unsafeUrl;
-    out.push({ rectMm, url });
+    const destPage = url ? void 0 : await resolveDestPage(doc, a.dest);
+    if (!url && destPage == null) continue;
+    out.push({ rectMm, url, destPage });
   }
   return out;
 }
@@ -1022,10 +1471,10 @@ async function extractFormWidgets(page, viewport) {
     })).filter((o) => o.value !== "") : [];
     out.push({
       rectMm: {
-        x: xMin * PT_TO_MM,
-        y: yMin * PT_TO_MM,
-        w: (xMax - xMin) * PT_TO_MM,
-        h: (yMax - yMin) * PT_TO_MM
+        x: xMin * PT_TO_MM2,
+        y: yMin * PT_TO_MM2,
+        w: (xMax - xMin) * PT_TO_MM2,
+        h: (yMax - yMin) * PT_TO_MM2
       },
       fieldType: a.fieldType || "",
       fieldName: a.fieldName || `field-${out.length + 1}`,
@@ -1045,26 +1494,62 @@ async function extractFormWidgets(page, viewport) {
 async function flattenOutline(doc, outline) {
   if (!outline) return [];
   const out = [];
-  async function walk(items) {
+  async function walk2(items, depth) {
     for (const item of items) {
-      try {
-        let dest = item.dest;
-        if (typeof dest === "string") {
-          dest = await doc.getDestination(dest);
-        }
-        if (Array.isArray(dest) && dest[0]) {
-          const ref = dest[0];
-          const idx = await doc.getPageIndex(ref);
-          if (typeof idx === "number") out.push({ title: item.title, pageIndex: idx });
-        }
-      } catch {
+      const idx = await resolveDestPage(doc, item.dest);
+      if (idx != null && typeof item.title === "string" && item.title.trim()) {
+        out.push({ title: item.title.trim(), pageIndex: idx, depth });
       }
-      if (item.items?.length) await walk(item.items);
+      if (item.items?.length) await walk2(item.items, depth + 1);
     }
   }
-  await walk(outline);
+  await walk2(outline, 1);
   return out;
 }
+var normTitle = (s) => s.toLowerCase().replace(/[\s\u00a0]+/g, " ").replace(/[^\p{L}\p{N} ]/gu, "").trim();
+function applyOutline(pages, outline) {
+  for (const entry of outline) {
+    const page = pages[entry.pageIndex];
+    if (!page) continue;
+    const want = normTitle(entry.title);
+    if (!want) continue;
+    let best = null;
+    let bestScore = 0;
+    for (const el of page.elements) {
+      if (el.type !== "text") continue;
+      const have = normTitle(el.content || "");
+      if (!have) continue;
+      let score = 0;
+      if (have === want) score = 3;
+      else if (have.startsWith(want) || want.startsWith(have)) score = 2;
+      else if (have.length >= 6 && want.includes(have)) score = 1;
+      if (score > bestScore || score === bestScore && best && score > 0 && (el.position?.y ?? 0) < (best.position?.y ?? 0)) {
+        best = el;
+        bestScore = score;
+      }
+    }
+    if (best && bestScore > 0) {
+      const level = Math.min(6, Math.max(1, entry.depth));
+      if (!best.heading) best.heading = level;
+      best.tocEntry = entry.title;
+      best.tocLevel = level;
+    }
+  }
+}
+function pdfDateToIso(v) {
+  if (typeof v !== "string") return void 0;
+  const m = v.match(/^D:(\d{4})(\d{2})?(\d{2})?(\d{2})?(\d{2})?(\d{2})?([Zz+-])?(\d{2})?'?(\d{2})?/);
+  if (!m) {
+    const t2 = Date.parse(v);
+    return Number.isFinite(t2) ? new Date(t2).toISOString() : void 0;
+  }
+  const [, Y, Mo = "01", D = "01", h = "00", mi = "00", s = "00", sign, oh = "00", om = "00"] = m;
+  const tz = !sign || sign === "Z" || sign === "z" ? "Z" : `${sign}${oh}:${om}`;
+  const iso = `${Y}-${Mo}-${D}T${h}:${mi}:${s}${tz}`;
+  const t = Date.parse(iso);
+  return Number.isFinite(t) ? new Date(t).toISOString() : void 0;
+}
+var annotationModeDisable = 0;
 async function importPdfToJdf(source, title, runtime, options = {}) {
   const pdfjs = options.pdfjs || runtime.pdfjs;
   if (!pdfjs) {
@@ -1085,7 +1570,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
   } else {
     data = source;
   }
-  const doc = await pdfjs.getDocument({
+  const loadingTask = pdfjs.getDocument({
     data,
     // The runtime adapter declares whether it supports a real Web Worker.
     // We don't sniff `typeof Worker` here because Node 22+ exposes a global
@@ -1094,15 +1579,55 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
     // newer Node. Browser entry leaves this unset (= false = real worker
     // via GlobalWorkerOptions.workerSrc); node entry sets `true`.
     disableWorker: runtime.disableWorker === true,
-    isEvalSupported: false
-  }).promise;
+    isEvalSupported: false,
+    // Keep going past malformed content streams instead of failing the page.
+    stopAtErrors: false,
+    // Force the classic pixel-array image path on every host so the reader
+    // (WKWebView has OffscreenCanvas) and the CLI produce identical PNGs.
+    isOffscreenCanvasSupported: false,
+    password: options.password,
+    // Standard-14 font metrics + CJK CMaps: without these PDF.js falls back
+    // to guesses for non-embedded fonts and logs a warning per page.
+    ...runtime.standardFontDataUrl ? { standardFontDataUrl: runtime.standardFontDataUrl } : {},
+    ...runtime.cMapUrl ? { cMapUrl: runtime.cMapUrl, cMapPacked: true } : {}
+  });
+  let passwordTried = typeof options.password === "string";
+  loadingTask.onPassword = (updatePassword, reason) => {
+    const retry = reason === 2 || passwordTried;
+    if (!options.onPassword) {
+      updatePassword(new Error(retry ? "[@jdf/pdf-import] Wrong password for encrypted PDF" : "[@jdf/pdf-import] PDF is password-protected \u2014 pass `password`"));
+      return;
+    }
+    passwordTried = true;
+    options.onPassword(retry).then((pw) => {
+      if (pw == null) updatePassword(new Error("[@jdf/pdf-import] Password entry cancelled"));
+      else updatePassword(pw);
+    }).catch((e) => updatePassword(e instanceof Error ? e : new Error(String(e))));
+  };
+  let doc;
+  try {
+    doc = await loadingTask.promise;
+  } catch (e) {
+    if (e?.name === "PasswordException") {
+      const msg = /no password/i.test(e.message || "") ? "PDF is password-protected \u2014 pass a password (CLI: --password)" : e.message || "PDF is password-protected";
+      throw new Error(`[@jdf/pdf-import] ${msg}`);
+    }
+    throw e;
+  }
   const pages = [];
   const imageResources = {};
   let imgCounter = 0;
   const dataUrlCache = /* @__PURE__ */ new Map();
   const resourceKeyByName = /* @__PURE__ */ new Map();
-  const outline = await doc.getOutline().catch(() => null);
-  await flattenOutline(doc, outline);
+  const outline = await flattenOutline(doc, await doc.getOutline().catch(() => null));
+  let pdfInfo = null;
+  let pdfMetadata = null;
+  try {
+    const md = await doc.getMetadata();
+    pdfInfo = md?.info ?? null;
+    pdfMetadata = md?.metadata ?? null;
+  } catch {
+  }
   for (let pi = 1; pi <= doc.numPages; pi++) {
     let findLinkForRun2 = function(r) {
       const cx = r.x + r.width / 2;
@@ -1124,7 +1649,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
     } catch {
     }
     const ops = await walkOps(page, OPS, viewport);
-    const links = await extractLinks(page, viewport);
+    const links = await extractLinks(doc, page, viewport);
     const formWidgets = await extractFormWidgets(page, viewport);
     const textContent = await page.getTextContent({ disableCombineTextItems: false });
     const items = textContent.items;
@@ -1167,9 +1692,53 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       const n = typeof v === "number" ? v : Number(v);
       return Number.isFinite(n) ? n : fallback;
     };
-    items.forEach((it, idx) => {
+    const opBins = /* @__PURE__ */ new Map();
+    for (const op of ops.textOps) {
+      const key = `${Math.round(op.x)},${Math.round(op.y)}`;
+      const arr = opBins.get(key);
+      if (arr) arr.push(op);
+      else opBins.set(key, [op]);
+    }
+    const findOp = (x, y, fontSize) => {
+      let best = null;
+      let bestD = Infinity;
+      const bx = Math.round(x), by = Math.round(y);
+      for (let dy = -1; dy <= 1; dy++) {
+        for (let dx = -1; dx <= 1; dx++) {
+          const arr = opBins.get(`${bx + dx},${by + dy}`);
+          if (!arr) continue;
+          for (const op of arr) {
+            const d = Math.hypot(op.x - x, op.y - y);
+            if (d < bestD) {
+              bestD = d;
+              best = op;
+            }
+          }
+        }
+      }
+      if (best) return best;
+      const tol = Math.max(2, fontSize * 0.6);
+      for (const op of ops.textOps) {
+        if (Math.abs(op.y - y) > tol) continue;
+        const d = Math.abs(op.x - x) + Math.abs(op.y - y) * 4;
+        if (d < bestD) {
+          bestD = d;
+          best = op;
+        }
+      }
+      if (best) return best;
+      for (const op of ops.textOps) {
+        const d = Math.hypot(op.x - x, op.y - y);
+        if (d < bestD) {
+          bestD = d;
+          best = op;
+        }
+      }
+      return bestD < 40 ? best : null;
+    };
+    const keepInvisible = options.invisibleText !== "drop";
+    items.forEach((it) => {
       if (!it.str || !it.str.length) return;
-      if ((ops.textRenderingModes[idx] ?? 0) === 3) return;
       const tr = it.transform;
       const fontSize = safeNum(Math.hypot(safeNum(tr?.[2], 0), safeNum(tr?.[3], 0)), 0) || safeNum(it.height, 0) || 10;
       const baseX = safeNum(tr?.[4], 0);
@@ -1177,24 +1746,35 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       const conv = viewport.convertToViewportPoint(baseX, baseY);
       const vx = safeNum(conv?.[0], 0);
       const vy = safeNum(conv?.[1], 0);
+      const op = findOp(vx, vy, fontSize);
+      const mode = op?.mode ?? 0;
+      if (mode === 7) return;
+      const invisible = mode === 3;
+      if (invisible && !keepInvisible) return;
       const ascent = it.height ? safeNum(it.height, fontSize) * 0.78 : fontSize * 0.78;
       const yTop = vy - ascent;
       const w = safeNum(it.width, 0);
       runs.push({
         text: it.str,
-        x: safeNum(vx * PT_TO_MM, 0),
-        y: safeNum(yTop * PT_TO_MM, 0),
+        x: safeNum(vx * PT_TO_MM2, 0),
+        y: safeNum(yTop * PT_TO_MM2, 0),
         fontSize: safeNum(fontSize, 10),
         fontName: it.fontName,
-        width: safeNum(w * PT_TO_MM, 0),
-        height: safeNum((it.height || fontSize) * PT_TO_MM, fontSize * PT_TO_MM),
-        color: ops.textColors[idx] || "#000000",
-        opacity: safeNum(ops.textOpacities[idx], 1)
+        width: safeNum(w * PT_TO_MM2, 0),
+        height: safeNum((it.height || fontSize) * PT_TO_MM2, fontSize * PT_TO_MM2),
+        color: op?.fill || "#000000",
+        opacity: invisible ? 0 : safeNum(op?.alpha, 1)
       });
     });
     runs.sort((a, b) => a.y - b.y || a.x - b.x);
     const lines = [];
     const Y_TOL = 0.6;
+    const kGlyph = calibrateGlyphWidth(runs);
+    const stretchedSpaces = hasStretchedSpaces(runs, kGlyph);
+    const fontKey = (name) => {
+      const c = fontMap.get(name) || classifyFont(name || "");
+      return `${c.family}|${c.weight || ""}|${c.style || ""}`;
+    };
     for (const r of runs) {
       if (!r.text.length) continue;
       const last = lines[lines.length - 1];
@@ -1203,24 +1783,48 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         continue;
       }
       const sameLine = Math.abs(last.y - r.y) <= Y_TOL;
-      const sameStyle = Math.abs(last.fontSize - r.fontSize) < 0.4 && last.fontName === r.fontName && last.color === r.color && Math.abs(last.opacity - r.opacity) < 0.05;
-      const gapMm = r.x - (last.x + last.width);
-      const emMm = r.fontSize * PT_TO_MM;
-      const mergeOk = sameLine && sameStyle && gapMm >= -0.2 && gapMm <= emMm * 0.45;
+      const sameStyle = Math.abs(last.fontSize - r.fontSize) < 0.4 && (last.fontName === r.fontName || fontKey(last.fontName) === fontKey(r.fontName)) && last.color === r.color && Math.abs(last.opacity - r.opacity) < 0.05;
+      const emMm = r.fontSize * PT_TO_MM2;
+      const extent = (t) => {
+        if (!/\s$/.test(t.text)) return t.width;
+        const em = t.fontSize * PT_TO_MM2;
+        const est = Math.max(1, t.text.trim().length) * em * kGlyph + em * 0.25;
+        if (stretchedSpaces) return Math.min(t.width, est);
+        return t.width > est * 1.4 ? est : t.width;
+      };
+      const gapMm = r.x - (last.x + extent(last));
+      const mergeOk = sameLine && sameStyle && gapMm >= -emMm * 0.5 && gapMm <= emMm * 0.45;
       if (mergeOk) {
         const lastEndsSpace = /\s$/.test(last.text);
         const currStartsSpace = /^\s/.test(r.text);
         const sep = gapMm > emMm * 0.08 && !lastEndsSpace && !currStartsSpace ? " " : "";
         last.text = last.text + sep + r.text;
         const newExtent = r.x - last.x + r.width;
-        last.width = Math.max(last.width, newExtent);
+        last.width = Math.max(extent(last), newExtent);
       } else {
         lines.push({ ...r });
       }
     }
     const elements = [];
-    for (const sh of ops.shapes) {
-      if (sh.width < 0.3 && sh.height < 0.3) continue;
+    const tRuns = lines.map((l) => {
+      const cls = fontMap.get(l.fontName) || classifyFont(l.fontName || "");
+      return { text: l.text, x: l.x, y: l.y, width: l.width, height: l.height, fontSize: l.fontSize, fontName: l.fontName, color: l.color, bold: cls.weight === "bold" };
+    });
+    const detected = options.detectTables === false ? [] : detectTables(tRuns, ops.shapes, pageW * PT_TO_MM2);
+    const consumedLines = /* @__PURE__ */ new Set();
+    const consumedShapes = /* @__PURE__ */ new Set();
+    const tableAtLine = /* @__PURE__ */ new Map();
+    for (const t of detected) {
+      for (const k of t.lineIdx) consumedLines.add(k);
+      for (const k of t.shapeIdx) consumedShapes.add(k);
+      tableAtLine.set(Math.min(...t.lineIdx), t.element);
+    }
+    const pageWmm = pageW * PT_TO_MM2, pageHmm = pageH * PT_TO_MM2;
+    ops.shapes.forEach((sh, shapeIdx) => {
+      if (consumedShapes.has(shapeIdx)) return;
+      if (sh.width < 0.3 && sh.height < 0.3) return;
+      if (sh.x + sh.width <= 0 || sh.y + sh.height <= 0 || sh.x >= pageWmm || sh.y >= pageHmm) return;
+      if (sh.kind === "rect" && sh.fill && !sh.stroke && sh.width * sh.height >= pageWmm * pageHmm * 0.9) return;
       const shapeType = sh.kind;
       const shape = {
         type: "shape",
@@ -1236,7 +1840,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         shape.style = { opacity: Math.round(sh.opacity * 100) / 100 };
       }
       elements.push(shape);
-    }
+    });
     const imgs = await extractImages(page, ops.imagePositions, runtime, dataUrlCache);
     for (const { pos, dataUrl } of imgs) {
       let resourceKey = resourceKeyByName.get(pos.name);
@@ -1259,7 +1863,16 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         fit: "fill"
       });
     }
+    const sizeChars = /* @__PURE__ */ new Map();
     for (const l of lines) {
+      const k = Math.round(l.fontSize * 2) / 2;
+      sizeChars.set(k, (sizeChars.get(k) ?? 0) + l.text.length);
+    }
+    const bodyFontSize = [...sizeChars.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? 0;
+    lines.forEach((l, lineIdx) => {
+      const tableEl = tableAtLine.get(lineIdx);
+      if (tableEl) elements.push(tableEl);
+      if (consumedLines.has(lineIdx)) return;
       const cls = fontMap.get(l.fontName) || classifyFont(l.fontName || "");
       const style = {
         fontSize: Math.round(l.fontSize * 10) / 10,
@@ -1270,8 +1883,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       if (l.color !== "#000000") style.color = l.color;
       if (l.opacity < 0.999) style.opacity = Math.round(l.opacity * 100) / 100;
       const link = findLinkForRun2(l);
-      const pageWmm = pageW * PT_TO_MM;
-      const measured = Math.max(l.width + l.fontSize * PT_TO_MM * 0.4, l.fontSize * PT_TO_MM);
+      const measured = Math.max(l.width + l.fontSize * PT_TO_MM2 * 0.4, l.fontSize * PT_TO_MM2);
       const remaining = Math.max(measured, pageWmm - l.x);
       const elWidth = Math.min(measured, remaining);
       const text = {
@@ -1281,18 +1893,26 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         width: Math.max(2, Math.round(elWidth * 100) / 100),
         style
       };
-      if (cls.weight === "bold") {
-        if (l.fontSize >= 22) text.heading = 1;
-        else if (l.fontSize >= 17) text.heading = 2;
-        else if (l.fontSize >= 16) text.heading = 3;
+      if (cls.weight === "bold" && l.text.trim().length <= 120 && !consumedLines.has(lineIdx)) {
+        const ratio = bodyFontSize > 0 ? l.fontSize / bodyFontSize : 1;
+        if (l.fontSize >= 22 || ratio >= 1.8) text.heading = 1;
+        else if (l.fontSize >= 17 || ratio >= 1.35) text.heading = 2;
+        else if (l.fontSize >= 16 || ratio >= 1.2) text.heading = 3;
       }
       if (text.heading) text.tocEntry = text.content;
       if (link) {
         if (link.url) text.link = link.url;
         else if (link.destPage != null) text.link = { type: "internal", target: `#page-${link.destPage + 1}` };
       }
+      const prev = elements[elements.length - 1];
+      if (text.heading && prev && prev.type === "text" && prev.heading === text.heading && !link && !prev.link && Math.abs(prev.style?.fontSize - style.fontSize) < 0.5 && Math.abs(prev.position.x - text.position.x) < 1 && text.position.y - prev.position.y < l.fontSize * PT_TO_MM2 * 2.2 && text.position.y > prev.position.y) {
+        prev.content = `${prev.content} ${text.content}`.replace(/\s+/g, " ");
+        prev.tocEntry = prev.content;
+        prev.width = Math.max(prev.width ?? 0, text.width ?? 0);
+        return;
+      }
       elements.push(text);
-    }
+    });
     for (const w of formWidgets) {
       if (w.pushButton) continue;
       const baseEl = {
@@ -1327,19 +1947,41 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
     }
     pages.push({
       id: `page-${pi}`,
-      pageSize: { width: Math.round(pageW * PT_TO_MM * 100) / 100, height: Math.round(pageH * PT_TO_MM * 100) / 100 },
+      pageSize: { width: Math.round(pageW * PT_TO_MM2 * 100) / 100, height: Math.round(pageH * PT_TO_MM2 * 100) / 100 },
       margins: { top: 0, right: 0, bottom: 0, left: 0 },
       elements
     });
   }
+  applyOutline(pages, outline);
+  const meta = {
+    title,
+    pageSize: pages[0]?.pageSize || "A4",
+    unit: "mm",
+    margins: { top: 0, right: 0, bottom: 0, left: 0 }
+  };
+  if (pdfInfo) {
+    if (typeof pdfInfo.Author === "string" && pdfInfo.Author.trim()) meta.author = pdfInfo.Author.trim();
+    const created = pdfDateToIso(pdfInfo.CreationDate);
+    const modified = pdfDateToIso(pdfInfo.ModDate);
+    if (created) meta.created = created;
+    if (modified) meta.modified = modified;
+    if (typeof pdfInfo.Keywords === "string") {
+      const kws = pdfInfo.Keywords.split(/[,;]+/).map((k) => k.trim()).filter(Boolean);
+      if (kws.length) meta.keywords = kws;
+    }
+    if (typeof pdfInfo.Language === "string" && pdfInfo.Language.trim()) meta.language = pdfInfo.Language.trim();
+  }
+  if (!meta.language && pdfMetadata && typeof pdfMetadata.get === "function") {
+    try {
+      const lang = pdfMetadata.get("dc:language");
+      const first = Array.isArray(lang) ? lang[0] : lang;
+      if (typeof first === "string" && first.trim()) meta.language = first.trim();
+    } catch {
+    }
+  }
   const result = {
     $jdf: "1.0.0",
-    meta: {
-      title,
-      pageSize: pages[0]?.pageSize || "A4",
-      unit: "mm",
-      margins: { top: 0, right: 0, bottom: 0, left: 0 }
-    },
+    meta,
     pages
   };
   if (Object.keys(imageResources).length > 0) {
@@ -1351,27 +1993,31 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
 // ../../packages/jdf-pdf-import/src/node.ts
 var pdfjsModule = null;
 var pdfjsLoadPromise = null;
+var pdfjsAssetDirs = null;
 async function loadNodePdfJs() {
   if (pdfjsModule) return pdfjsModule;
   if (pdfjsLoadPromise) return pdfjsLoadPromise;
   pdfjsLoadPromise = (async () => {
     const { createRequire } = await import('module');
     const require_ = createRequire(import.meta.url);
-    const origWarn = console.warn;
-    console.warn = (...args) => {
-      if (typeof args[0] === "string" && args[0].includes("legacy")) return;
-      origWarn.apply(console, args);
+    const origLog = console.log;
+    console.log = (...args) => {
+      if (typeof args[0] === "string" && args[0].includes("`legacy` build")) return;
+      origLog.apply(console, args);
     };
     let lib;
     try {
       lib = await import('pdfjs-dist/build/pdf.mjs');
     } finally {
-      console.warn = origWarn;
+      console.log = origLog;
     }
     const workerPath = require_.resolve("pdfjs-dist/build/pdf.worker.mjs");
     if (lib.GlobalWorkerOptions) {
       lib.GlobalWorkerOptions.workerSrc = workerPath;
     }
+    const { dirname, join } = await import('path');
+    const pkgDir = dirname(dirname(workerPath));
+    pdfjsAssetDirs = { standardFontDataUrl: join(pkgDir, "standard_fonts") + "/", cMapUrl: join(pkgDir, "cmaps") + "/" };
     pdfjsModule = lib;
     return lib;
   })();
@@ -1382,6 +2028,10 @@ async function loadCanvas() {
   if (canvasModule) return canvasModule;
   try {
     canvasModule = await import('@napi-rs/canvas');
+    const g = globalThis;
+    if (typeof g.DOMMatrix === "undefined" && canvasModule.DOMMatrix) g.DOMMatrix = canvasModule.DOMMatrix;
+    if (typeof g.Path2D === "undefined" && canvasModule.Path2D) g.Path2D = canvasModule.Path2D;
+    if (typeof g.ImageData === "undefined" && canvasModule.ImageData) g.ImageData = canvasModule.ImageData;
     return canvasModule;
   } catch (err) {
     throw new Error(
@@ -1433,6 +2083,7 @@ async function importPdfToJdf2(source, title, options = {}) {
   const runtime = {
     pdfjs,
     disableWorker: true,
+    ...pdfjsAssetDirs ?? {},
     createCanvas(width, height) {
       const canvas = canvasMod.createCanvas(width, height);
       const context = canvas.getContext("2d");
@@ -1449,19 +2100,22 @@ async function importPdfToJdf2(source, title, options = {}) {
 
 // src/commands/import-pdf.ts
 async function importPdf(inputPath, outputPath, options = {}) {
-  const input = path2.resolve(inputPath);
-  if (!fs.existsSync(input)) {
+  const input = path7.resolve(inputPath);
+  if (!fs7.existsSync(input)) {
     console.error(`File not found: ${input}`);
     process.exit(1);
   }
   console.log(`Importing: ${input}`);
-  const title = path2.basename(input, path2.extname(input));
+  const title = path7.basename(input, path7.extname(input));
   const t0 = Date.now();
-  const doc = await importPdfToJdf2(input, title);
+  const doc = await importPdfToJdf2(input, title, {
+    password: options.password,
+    invisibleText: options.dropInvisibleText ? "drop" : "keep"
+  });
   console.log(`Parsed in ${((Date.now() - t0) / 1e3).toFixed(1)}s \u2014 ${doc.pages.length} page(s)`);
   let output;
   if (outputPath) {
-    output = path2.resolve(outputPath);
+    output = path7.resolve(outputPath);
   } else {
     const stem = input.replace(/\.pdf$/i, "");
     const wantJdfx = !options.forceJson && shouldUseJdfx(doc);
@@ -1470,11 +2124,11 @@ async function importPdf(inputPath, outputPath, options = {}) {
   console.log(`Output:    ${output}`);
   if (output.toLowerCase().endsWith(".jdfx")) {
     const { bytes, manifest } = await packJdfx(doc);
-    fs.writeFileSync(output, bytes);
+    fs7.writeFileSync(output, bytes);
     console.log(`
 Done! Created ${doc.pages.length} page(s), ${manifest.assets.length} asset(s) bundled`);
   } else {
-    fs.writeFileSync(output, JSON.stringify(doc, null, 2));
+    fs7.writeFileSync(output, JSON.stringify(doc, null, 2));
     console.log(`
 Done! Created ${doc.pages.length} page(s)`);
   }
@@ -1487,23 +2141,23 @@ var ImportJsonError = class extends Error {
   }
 };
 async function importJson(inputPath, outputPath, options = {}) {
-  const input = path2.resolve(inputPath);
-  if (!fs.existsSync(input)) {
+  const input = path7.resolve(inputPath);
+  if (!fs7.existsSync(input)) {
     throw new ImportJsonError(`File not found: ${input}`);
   }
   console.log(`Importing: ${input}`);
-  const raw = fs.readFileSync(input, "utf-8");
+  const raw = fs7.readFileSync(input, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (e) {
     throw new ImportJsonError(`Not valid JSON: ${e.message}`);
   }
-  const title = path2.basename(input, path2.extname(input));
+  const title = path7.basename(input, path7.extname(input));
   const doc = normaliseToJdf(parsed, title);
   let output;
   if (outputPath) {
-    output = path2.resolve(outputPath);
+    output = path7.resolve(outputPath);
   } else {
     const stem = input.replace(/\.json$/i, "");
     const wantJdfx = !options.forceJson && shouldUseJdfx(doc);
@@ -1512,11 +2166,11 @@ async function importJson(inputPath, outputPath, options = {}) {
   console.log(`Output:    ${output}`);
   if (output.toLowerCase().endsWith(".jdfx")) {
     const { bytes, manifest } = await packJdfx(doc);
-    fs.writeFileSync(output, bytes);
+    fs7.writeFileSync(output, bytes);
     console.log(`
 Done! Created ${doc.pages.length} page(s), ${manifest.assets.length} asset(s) bundled`);
   } else {
-    fs.writeFileSync(output, JSON.stringify(doc, null, 2));
+    fs7.writeFileSync(output, JSON.stringify(doc, null, 2));
     console.log(`
 Done! Created ${doc.pages.length} page(s)`);
   }
@@ -1592,6 +2246,47 @@ function wrapElements(elements, title, meta) {
     ]
   };
 }
+var DEFAULT_TRANSCRIPT_WINDOW = 45;
+var fmtTime = (sec) => {
+  const s = Math.max(0, Math.round(sec));
+  const h = Math.floor(s / 3600), m = Math.floor(s % 3600 / 60), r = s % 60;
+  return h ? `${h}:${String(m).padStart(2, "0")}:${String(r).padStart(2, "0")}` : `${String(m).padStart(2, "0")}:${String(r).padStart(2, "0")}`;
+};
+function transcriptChunks(el, elementId2, page, crumb, windowSec, maxTokens) {
+  const segs = Array.isArray(el?.transcript?.segments) ? el.transcript.segments : [];
+  if (!segs.length) return [];
+  const chapters = Array.isArray(el?.chapters) ? [...el.chapters].sort((a, b) => a.t - b.t) : [];
+  const chapterAt = (t) => {
+    let cur = null;
+    for (const c of chapters) {
+      if (c.t <= t + 1e-6) cur = c;
+      else break;
+    }
+    return cur;
+  };
+  const out = [];
+  let win = [];
+  const flush = () => {
+    if (!win.length) return;
+    const t0 = win[0].t0, t1 = win[win.length - 1].t1;
+    const body = win.map((sg) => sg.speaker ? `${sg.speaker}: ${sg.text}` : sg.text).join(" ").replace(/\s+/g, " ").trim();
+    const text = `[${fmtTime(t0)}\u2013${fmtTime(t1)}] ${body}`;
+    const chapter = chapterAt(t0);
+    const path9 = [...crumb, ...el.title ? [String(el.title)] : [], ...chapter ? [String(chapter.title)] : []];
+    out.push({ id: `${elementId2}@${Math.round(t0)}`, text, path: path9, page, types: ["video"], tokens: estimateTokens(text), hash: hashText(text), media: { element: elementId2, t0, t1 } });
+    win = [];
+  };
+  for (const sg of segs) {
+    if (typeof sg?.text !== "string" || !sg.text.trim()) continue;
+    const startsNewChapter = win.length && chapterAt(sg.t0) !== chapterAt(win[0].t0);
+    const spansWindow = win.length && sg.t1 - win[0].t0 > windowSec;
+    const overBudget = win.length && estimateTokens(win.map((w) => w.text).join(" ") + sg.text) > maxTokens;
+    if (startsNewChapter || spansWindow || overBudget) flush();
+    win.push(sg);
+  }
+  flush();
+  return out;
+}
 var DEFAULT_MAX_TOKENS = 512;
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
@@ -1614,11 +2309,11 @@ function serializeElement(el) {
     case "richtext":
       return (e.runs || []).map((r) => r.text ?? "").join("").trim();
     case "list": {
-      const walk = (items, depth = 0) => (items || []).flatMap((it) => {
+      const walk2 = (items, depth = 0) => (items || []).flatMap((it) => {
         const line = "  ".repeat(depth) + "- " + String(it.content ?? "").trim();
-        return it.children?.length ? [line, ...walk(it.children, depth + 1)] : [line];
+        return it.children?.length ? [line, ...walk2(it.children, depth + 1)] : [line];
       });
-      return walk(e.items).join("\n");
+      return walk2(e.items).join("\n");
     }
     case "table": {
       const headers = e.headers ?? e.columns?.map((c) => c.header || "").filter((h) => h) ?? [];
@@ -1649,6 +2344,8 @@ function serializeElement(el) {
       return `${e.checked ? "[x]" : "[ ]"} ${e.label ?? ""}`.trim();
     case "image":
       return e.alt ? `[image: ${e.alt}]` : "";
+    case "video":
+      return e.title ? `[video: ${e.title}]` : "";
     case "toc":
     case "shape":
     case "signature":
@@ -1688,8 +2385,15 @@ function makeChunk(group, breadcrumb) {
 function chunkDocument(doc, options = {}) {
   const strategy = options.strategy ?? "section";
   const maxTokens = options.maxTokens ?? DEFAULT_MAX_TOKENS;
+  const windowSec = options.transcriptWindowSec ?? DEFAULT_TRANSCRIPT_WINDOW;
   const flat = flatten(doc);
   const chunks = [];
+  const withTranscripts = (group, crumb2, c) => {
+    if (c) chunks.push(c);
+    for (const f of group) {
+      if (f.el.type === "video") chunks.push(...transcriptChunks(f.el, f.id, f.page, crumb2, windowSec, maxTokens));
+    }
+  };
   if (strategy === "element") {
     const crumb2 = [];
     for (const f of flat) {
@@ -1698,8 +2402,7 @@ function chunkDocument(doc, options = {}) {
         crumb2.length = Math.max(0, lvl - 1);
         crumb2[lvl - 1] = serializeElement(f.el);
       }
-      const c = makeChunk([f], crumb2);
-      if (c) chunks.push(c);
+      withTranscripts([f], crumb2, makeChunk([f], crumb2));
     }
     return chunks;
   }
@@ -1708,8 +2411,7 @@ function chunkDocument(doc, options = {}) {
     let buf2 = [];
     let bufTokens = 0;
     const flush = () => {
-      const c = makeChunk(buf2, crumb2);
-      if (c) chunks.push(c);
+      withTranscripts(buf2, crumb2, makeChunk(buf2, crumb2));
       buf2 = [];
       bufTokens = 0;
     };
@@ -1736,22 +2438,21 @@ function chunkDocument(doc, options = {}) {
     for (const f of buf) {
       const t = estimateTokens(serializeElement(f.el));
       if (subTokens + t > maxTokens && sub.length > 0) {
-        const c2 = makeChunk(sub, crumb);
-        if (c2) chunks.push(c2);
+        withTranscripts(sub, crumb, makeChunk(sub, crumb));
         sub = [];
         subTokens = 0;
       }
       sub.push(f);
       subTokens += t;
     }
-    const c = makeChunk(sub, crumb);
-    if (c) chunks.push(c);
+    withTranscripts(sub, crumb, makeChunk(sub, crumb));
     buf = [];
   };
   for (const f of flat) {
     const lvl = headingLevel(f.el);
     if (lvl != null) {
-      flushSection();
+      const onlyHeadings = buf.length > 0 && buf.every((b) => headingLevel(b.el) != null);
+      if (!onlyHeadings) flushSection();
       crumb.length = Math.max(0, lvl - 1);
       crumb[lvl - 1] = serializeElement(f.el);
     }
@@ -1762,34 +2463,34 @@ function chunkDocument(doc, options = {}) {
 }
 async function loadJdf(filePath) {
   if (filePath.toLowerCase().endsWith(".jdfx")) {
-    const zip = await JSZip.loadAsync(fs.readFileSync(filePath));
+    const zip = await JSZip.loadAsync(fs7.readFileSync(filePath));
     const docFile = zip.file(JDFX_DOCUMENT_PATH);
     if (!docFile) throw new Error(`Bundle missing ${JDFX_DOCUMENT_PATH}`);
     return JSON.parse(await docFile.async("string"));
   }
-  return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  return JSON.parse(fs7.readFileSync(filePath, "utf-8"));
 }
 async function chunkFile(inputPath, opts = {}) {
-  const input = path2.resolve(inputPath);
-  if (!fs.existsSync(input)) throw new Error(`File not found: ${input}`);
+  const input = path7.resolve(inputPath);
+  if (!fs7.existsSync(input)) throw new Error(`File not found: ${input}`);
   const doc = await loadJdf(input);
   const strategy = opts.strategy ?? "section";
-  const chunks = chunkDocument(doc, { strategy, maxTokens: opts.maxTokens });
+  const chunks = chunkDocument(doc, { strategy, maxTokens: opts.maxTokens, transcriptWindowSec: opts.transcriptWindowSec });
   const format = opts.format ?? "jsonl";
   console.log(`Chunking:  ${input}`);
   console.log(`Strategy:  ${strategy}${opts.maxTokens ? ` (max ${opts.maxTokens} tokens)` : ""}`);
   if (format === "inline") {
-    const out = opts.output ? path2.resolve(opts.output) : input.replace(/\.(jdf|jdfx)$/i, ".jdf");
+    const out = opts.output ? path7.resolve(opts.output) : input.replace(/\.(jdf|jdfx)$/i, ".jdf");
     const withIndex = { ...doc, index: { chunker: `jdf-${strategy}-v1`, chunks } };
-    fs.writeFileSync(out, JSON.stringify(withIndex, null, 2));
+    fs7.writeFileSync(out, JSON.stringify(withIndex, null, 2));
     console.log(`Output:    ${out}  (${chunks.length} chunks in "index" block)`);
   } else if (format === "json") {
-    const out = opts.output ? path2.resolve(opts.output) : input.replace(/\.(jdf|jdfx)$/i, ".chunks.json");
-    fs.writeFileSync(out, JSON.stringify(chunks, null, 2));
+    const out = opts.output ? path7.resolve(opts.output) : input.replace(/\.(jdf|jdfx)$/i, ".chunks.json");
+    fs7.writeFileSync(out, JSON.stringify(chunks, null, 2));
     console.log(`Output:    ${out}  (${chunks.length} chunks)`);
   } else {
-    const out = opts.output ? path2.resolve(opts.output) : input.replace(/\.(jdf|jdfx)$/i, ".chunks.jsonl");
-    fs.writeFileSync(out, chunks.map((c) => JSON.stringify(c)).join("\n") + "\n");
+    const out = opts.output ? path7.resolve(opts.output) : input.replace(/\.(jdf|jdfx)$/i, ".chunks.jsonl");
+    fs7.writeFileSync(out, chunks.map((c) => JSON.stringify(c)).join("\n") + "\n");
     console.log(`Output:    ${out}  (${chunks.length} chunks)`);
   }
   const totalTokens = chunks.reduce((a, c) => a + c.tokens, 0);
@@ -1961,17 +2662,17 @@ async function embedOpenAI(model, inputs) {
 }
 async function loadJdf2(filePath) {
   if (filePath.toLowerCase().endsWith(".jdfx")) {
-    const zip = await JSZip.loadAsync(fs.readFileSync(filePath));
+    const zip = await JSZip.loadAsync(fs7.readFileSync(filePath));
     const docFile = zip.file(JDFX_DOCUMENT_PATH);
     if (!docFile) throw new Error(`Bundle missing ${JDFX_DOCUMENT_PATH}`);
     return JSON.parse(await docFile.async("string"));
   }
-  return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  return JSON.parse(fs7.readFileSync(filePath, "utf-8"));
 }
 function loadCache(cachePath) {
   try {
-    if (!fs.existsSync(cachePath)) return null;
-    return JSON.parse(fs.readFileSync(cachePath, "utf-8"));
+    if (!fs7.existsSync(cachePath)) return null;
+    return JSON.parse(fs7.readFileSync(cachePath, "utf-8"));
   } catch {
     return null;
   }
@@ -1982,15 +2683,15 @@ function batched(items, size) {
   return out;
 }
 async function embedFile(inputPath, opts = {}) {
-  const input = path2.resolve(inputPath);
-  if (!fs.existsSync(input)) throw new Error(`File not found: ${input}`);
+  const input = path7.resolve(inputPath);
+  if (!fs7.existsSync(input)) throw new Error(`File not found: ${input}`);
   const provider = opts.provider ?? "ollama";
   const model = opts.model ?? DEFAULT_MODEL[provider];
   const strategy = opts.strategy ?? "section";
   const doc = await loadJdf2(input);
-  const chunks = chunkDocument(doc, { strategy, maxTokens: opts.maxTokens });
-  const output = opts.output ? path2.resolve(opts.output) : input.replace(/\.(jdf|jdfx)$/i, ".embeddings.json");
-  const cachePath = opts.cache ? path2.resolve(opts.cache) : output;
+  const chunks = chunkDocument(doc, { strategy, maxTokens: opts.maxTokens, transcriptWindowSec: opts.transcriptWindowSec });
+  const output = opts.output ? path7.resolve(opts.output) : input.replace(/\.(jdf|jdfx)$/i, ".embeddings.json");
+  const cachePath = opts.cache ? path7.resolve(opts.cache) : output;
   console.log(`Embedding: ${input}`);
   console.log(`Provider:  ${provider} / ${model}${provider === "ollama" ? " (local \u2014 no data leaves this machine)" : " (remote API)"}`);
   console.log(`Strategy:  ${strategy} \u2192 ${chunks.length} chunks`);
@@ -2029,11 +2730,295 @@ async function embedFile(inputPath, opts = {}) {
     chunker: `jdf-${strategy}-v1`,
     vectors
   };
-  fs.writeFileSync(output, JSON.stringify(sidecar));
+  fs7.writeFileSync(output, JSON.stringify(sidecar));
   console.log(`
 Done! ${Object.keys(vectors).length} vectors (${dims}-dim) \u2192 ${output}`);
   return sidecar;
 }
+var toSec = (ts) => {
+  const m = ts.trim().replace(",", ".").match(/^(?:(\d+):)?(\d{1,2}):(\d{2}(?:\.\d+)?)$/);
+  if (!m) throw new Error(`bad timestamp "${ts}"`);
+  return (m[1] ? Number(m[1]) * 3600 : 0) + Number(m[2]) * 60 + Number(m[3]);
+};
+function parseSubtitles(text, filename = "") {
+  const trimmed = text.replace(/^/, "").trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    const j = JSON.parse(trimmed);
+    const arr = Array.isArray(j) ? j : Array.isArray(j.segments) ? j.segments : [];
+    return arr.map((sg) => ({
+      t0: Number(sg.t0 ?? sg.start ?? sg.from ?? 0),
+      t1: Number(sg.t1 ?? sg.end ?? sg.to ?? 0),
+      text: String(sg.text ?? "").trim(),
+      ...sg.speaker ? { speaker: String(sg.speaker) } : {}
+    })).filter((sg) => sg.text);
+  }
+  const segs = [];
+  for (const block of trimmed.split(/\r?\n\r?\n+/)) {
+    const lines = block.split(/\r?\n/).filter((l) => l.trim() !== "" && l.trim() !== "WEBVTT");
+    const ti = lines.findIndex((l) => l.includes("-->"));
+    if (ti < 0) continue;
+    const [a, b] = lines[ti].split("-->").map((x) => x.trim().split(/\s+/)[0]);
+    const body = lines.slice(ti + 1).join(" ").replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
+    if (!body) continue;
+    segs.push({ t0: toSec(a), t1: toSec(b), text: body });
+  }
+  if (!segs.length) throw new Error(`no cues found in ${filename || "subtitle input"} (expected SRT, WebVTT or JSON segments)`);
+  return segs;
+}
+function parseChapters(text) {
+  const t = text.trim();
+  if (t.startsWith("[")) return JSON.parse(t).map((c) => ({ t: Number(c.t ?? c.start ?? 0), title: String(c.title ?? "") }));
+  return t.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).map((l) => {
+    const m = l.match(/^(\S+)\s+(.+)$/);
+    if (!m) throw new Error(`bad chapter line "${l}" (expected "mm:ss Title")`);
+    return { t: toSec(m[1]), title: m[2].trim() };
+  });
+}
+async function loadDoc(file) {
+  if (file.toLowerCase().endsWith(".jdfx")) {
+    const zip = await JSZip.loadAsync(fs7.readFileSync(file));
+    const f = zip.file(JDFX_DOCUMENT_PATH);
+    if (!f) throw new Error(`Bundle missing ${JDFX_DOCUMENT_PATH}`);
+    const doc = JSON.parse(await f.async("string"));
+    const manifest = zip.file("manifest.json") ? JSON.parse(await zip.file("manifest.json").async("string")) : { assets: [] };
+    for (const a of manifest.assets ?? []) {
+      const af = zip.file(a.path);
+      if (!af) continue;
+      const data = (await af.async("nodebuffer")).toString("base64");
+      const res = { src: "embedded", mimeType: a.mimeType, data };
+      doc.resources ??= {};
+      if (/^video\//i.test(a.mimeType || "")) (doc.resources.videos ??= {})[a.id] = res;
+      else (doc.resources.images ??= {})[a.id] = res;
+    }
+    return { doc, bundle: true, zip };
+  }
+  return { doc: JSON.parse(fs7.readFileSync(file, "utf-8")), bundle: false };
+}
+function findVideos(doc) {
+  const out = [];
+  const walk2 = (els, page) => {
+    for (const el of els ?? []) {
+      if (el?.type === "video") out.push({ el, page, index: out.length });
+      if (el?.elements) walk2(el.elements, page);
+    }
+  };
+  doc.pages.forEach((p, i) => walk2(p.elements, i + 1));
+  return out;
+}
+async function clipToTempFile(doc, el, docDir) {
+  const tmp = path7.join(fs7.mkdtempSync(path7.join(__require("os").tmpdir(), "jdf-transcribe-")), "clip.mp4");
+  const res = el.resource ? doc.resources?.videos?.[el.resource] ?? doc.resources?.images?.[el.resource] : void 0;
+  if (res?.data) {
+    fs7.writeFileSync(tmp, Buffer.from(res.data.replace(/^data:[^,]*,/, ""), "base64"));
+    return tmp;
+  }
+  if (res?.path) return path7.resolve(docDir, res.path);
+  const src = el.src;
+  if (!src) return null;
+  if (src.startsWith("data:")) {
+    fs7.writeFileSync(tmp, Buffer.from(src.replace(/^data:[^,]*,/, ""), "base64"));
+    return tmp;
+  }
+  if (/^https?:\/\//i.test(src)) {
+    const r = await fetch(src);
+    if (!r.ok) throw new Error(`download failed ${r.status}: ${src}`);
+    fs7.writeFileSync(tmp, Buffer.from(await r.arrayBuffer()));
+    return tmp;
+  }
+  const local = path7.resolve(docDir, src);
+  return fs7.existsSync(local) ? local : null;
+}
+function whisperCli(clip, model, language, prompt2) {
+  const ffmpeg = spawnSync("ffmpeg", ["-version"]);
+  if (ffmpeg.error) throw new Error("ffmpeg not found \u2014 needed to extract audio for whisper-cli (brew install ffmpeg)");
+  const wav = clip.replace(/\.[^.]+$/, "") + ".16k.wav";
+  const ex = spawnSync("ffmpeg", ["-y", "-i", clip, "-vn", "-ac", "1", "-ar", "16000", "-f", "wav", wav], { encoding: "utf-8" });
+  if (ex.status !== 0) throw new Error(`ffmpeg failed: ${ex.stderr.slice(-400)}`);
+  const args = ["-f", wav, "-oj", "-of", wav.replace(/\.wav$/, "")];
+  if (model) args.push("-m", model);
+  if (language) args.push("-l", language);
+  if (prompt2) args.push("--prompt", prompt2);
+  const run = spawnSync("whisper-cli", args, { encoding: "utf-8" });
+  if (run.error) throw new Error("whisper-cli not found \u2014 install whisper.cpp (brew install whisper-cpp) or use --from / --provider openai");
+  if (run.status !== 0) throw new Error(`whisper-cli failed: ${run.stderr.slice(-400)}`);
+  const j = JSON.parse(fs7.readFileSync(wav.replace(/\.wav$/, "") + ".json", "utf-8"));
+  const segs = j.transcription ?? j.segments ?? [];
+  const ms = (x) => typeof x === "number" ? x / 1e3 : toSec(String(x).replace(",", "."));
+  return segs.map((sg) => ({ t0: ms(sg.offsets?.from ?? sg.start), t1: ms(sg.offsets?.to ?? sg.end), text: String(sg.text ?? "").trim() })).filter((sg) => sg.text);
+}
+async function openaiTranscribe(clip, model, language, prompt2) {
+  const key = process.env.OPENAI_API_KEY;
+  if (!key) throw new Error("OPENAI_API_KEY is not set");
+  const base = process.env.OPENAI_BASE_URL || "https://api.openai.com/v1";
+  const form = new FormData();
+  form.append("file", new Blob([fs7.readFileSync(clip)]), path7.basename(clip));
+  form.append("model", model || "whisper-1");
+  form.append("response_format", "verbose_json");
+  form.append("timestamp_granularities[]", "segment");
+  if (language) form.append("language", language);
+  if (prompt2) form.append("prompt", prompt2);
+  const r = await fetch(`${base}/audio/transcriptions`, { method: "POST", headers: { Authorization: `Bearer ${key}` }, body: form });
+  if (!r.ok) throw new Error(`OpenAI transcription failed ${r.status}: ${(await r.text()).slice(0, 300)}`);
+  const j = await r.json();
+  return (j.segments ?? []).map((sg) => ({ t0: Number(sg.start), t1: Number(sg.end), text: String(sg.text).trim() })).filter((sg) => sg.text);
+}
+async function transcribeFile(inputPath, opts = {}) {
+  const input = path7.resolve(inputPath);
+  if (!fs7.existsSync(input)) throw new Error(`File not found: ${input}`);
+  const { doc, bundle } = await loadDoc(input);
+  const videos = findVideos(doc);
+  if (!videos.length) throw new Error("document has no video element");
+  let target = videos[0];
+  if (opts.element != null) {
+    const byId = videos.find((v) => v.el.id === opts.element);
+    const byIdx = /^\d+$/.test(opts.element) ? videos[Number(opts.element)] : void 0;
+    target = byId ?? byIdx ?? (() => {
+      throw new Error(`no video element "${opts.element}" (have: ${videos.map((v) => v.el.id ?? `#${v.index}`).join(", ")})`);
+    })();
+  } else if (videos.length > 1) {
+    throw new Error(`document has ${videos.length} videos \u2014 pick one with --element <id|index>`);
+  }
+  let segments;
+  let source;
+  if (opts.from) {
+    segments = parseSubtitles(fs7.readFileSync(path7.resolve(opts.from), "utf-8"), opts.from);
+    source = `${path7.extname(opts.from).slice(1).toLowerCase() || "file"}-import`;
+  } else {
+    const provider = opts.provider ?? "whisper-cli";
+    const clip = await clipToTempFile(doc, target.el, path7.dirname(input));
+    if (!clip) throw new Error("could not locate the clip bytes (no bundled asset, data URL, local path or http URL) \u2014 use --from to import subtitles instead");
+    segments = provider === "openai" ? await openaiTranscribe(clip, opts.model, opts.language, opts.prompt) : whisperCli(clip, opts.model, opts.language, opts.prompt);
+    source = provider === "openai" ? `openai:${opts.model || "whisper-1"}` : `whisper-cli${opts.model ? ":" + path7.basename(opts.model) : ""}`;
+  }
+  segments.sort((a, b) => a.t0 - b.t0);
+  const transcript = { ...opts.language ? { language: opts.language } : {}, source, created: (/* @__PURE__ */ new Date()).toISOString(), segments };
+  target.el.transcript = transcript;
+  if (opts.chapters) target.el.chapters = parseChapters(fs7.readFileSync(path7.resolve(opts.chapters), "utf-8"));
+  if (!target.el.id) target.el.id = `video-${target.index + 1}`;
+  const output = opts.output ? path7.resolve(opts.output) : input;
+  if (output.toLowerCase().endsWith(".jdfx") || bundle && !opts.output) {
+    const { bytes } = await packJdfx(doc);
+    fs7.writeFileSync(output, bytes);
+  } else {
+    fs7.writeFileSync(output, JSON.stringify(doc, null, 2));
+  }
+  const dur = segments.length ? segments[segments.length - 1].t1 : 0;
+  console.log(`Transcribed: ${path7.basename(input)} \u2192 element "${target.el.id}" (${segments.length} segments, ${Math.round(dur)} s, source ${source})`);
+  if (target.el.chapters) console.log(`Chapters:    ${target.el.chapters.length}`);
+  console.log(`Output:      ${output}
+Next:        jdf chunk ${path7.basename(output)}   # transcript \u2192 time-windowed chunks with media.t0/t1`);
+  return transcript;
+}
+var CONFIG_NAME = "jdf.rag.json";
+var OUT_DIR = ".jdf-rag";
+function walk(dir, acc = []) {
+  for (const ent of fs7.readdirSync(dir, { withFileTypes: true })) {
+    if (ent.name === "node_modules" || ent.name === OUT_DIR || ent.name.startsWith(".")) continue;
+    const p = path7.join(dir, ent.name);
+    if (ent.isDirectory()) walk(p, acc);
+    else if (/\.(jdf|jdfx)$/i.test(ent.name)) acc.push(p);
+  }
+  return acc.sort();
+}
+async function readDoc(file) {
+  if (file.toLowerCase().endsWith(".jdfx")) {
+    const zip = await JSZip.loadAsync(fs7.readFileSync(file));
+    return JSON.parse(await zip.file(JDFX_DOCUMENT_PATH).async("string"));
+  }
+  return JSON.parse(fs7.readFileSync(file, "utf-8"));
+}
+function videosIn(doc) {
+  const out = [];
+  const w = (els) => {
+    for (const el of els ?? []) {
+      if (el?.type === "video") out.push({ id: el.id, hasTranscript: !!el.transcript?.segments?.length });
+      if (el?.elements) w(el.elements);
+    }
+  };
+  for (const p of doc.pages ?? []) w(p.elements);
+  return out;
+}
+async function ragFolder(dirPath, cli = {}) {
+  const dir = path7.resolve(dirPath);
+  if (!fs7.existsSync(dir) || !fs7.statSync(dir).isDirectory()) throw new Error(`Not a directory: ${dir}`);
+  const cfgPath = path7.join(dir, CONFIG_NAME);
+  const cfg = fs7.existsSync(cfgPath) ? JSON.parse(fs7.readFileSync(cfgPath, "utf-8")) : {};
+  const opts = { ...cfg, ...Object.fromEntries(Object.entries(cli).filter(([, v]) => v !== void 0)) };
+  const provider = opts.provider ?? "ollama";
+  const transcribe = opts.transcribe ?? "none";
+  const outDir = path7.resolve(opts.out ?? path7.join(dir, OUT_DIR));
+  const files = walk(dir);
+  console.log(`jdf rag: ${dir}
+  files:      ${files.length} (.jdf/.jdfx)${fs7.existsSync(cfgPath) ? `
+  config:     ${CONFIG_NAME}` : ""}
+  embeddings: ${opts.noEmbed ? "skipped (--no-embed)" : `${provider}${opts.model ? " / " + opts.model : ""}`}
+  transcribe: ${transcribe}${opts.dryRun ? "\n  DRY RUN \u2014 nothing written" : ""}
+`);
+  if (!files.length) {
+    console.log("Nothing to do.");
+    return;
+  }
+  const manifest = { dir, created: (/* @__PURE__ */ new Date()).toISOString(), provider: opts.noEmbed ? null : provider, model: opts.model ?? null, strategy: opts.strategy ?? "section", transcribe, files: [], totals: { files: files.length, chunks: 0, videoChunks: 0, videos: 0, transcribed: 0, untranscribed: 0 } };
+  const indexLines = [];
+  for (const file of files) {
+    const rel = path7.relative(dir, file);
+    const doc = await readDoc(file);
+    const vids = videosIn(doc);
+    let transcribedHere = 0;
+    for (const v of vids) {
+      if (v.hasTranscript) continue;
+      if (transcribe === "none") {
+        manifest.totals.untranscribed++;
+        continue;
+      }
+      if (opts.dryRun) {
+        transcribedHere++;
+        continue;
+      }
+      try {
+        await transcribeFile(file, { provider: transcribe, element: v.id, model: opts.transcribeModel, language: opts.language, prompt: opts.prompt });
+        transcribedHere++;
+      } catch (e) {
+        console.warn(`  ! ${rel}: transcription failed for video ${v.id ?? "#?"}: ${e.message}`);
+        manifest.totals.untranscribed++;
+      }
+    }
+    manifest.totals.videos += vids.length;
+    manifest.totals.transcribed += transcribedHere;
+    if (opts.dryRun) {
+      manifest.files.push({ file: rel, videos: vids.length, wouldTranscribe: transcribedHere });
+      continue;
+    }
+    const chunkOpts = { strategy: opts.strategy, maxTokens: opts.maxTokens, transcriptWindowSec: opts.transcriptWindowSec };
+    const chunkOut = path7.join(outDir, "chunks", rel.replace(/\.(jdf|jdfx)$/i, ".chunks.jsonl"));
+    fs7.mkdirSync(path7.dirname(chunkOut), { recursive: true });
+    let chunks;
+    if (opts.noEmbed) {
+      chunks = await chunkFile(file, { ...chunkOpts, format: "jsonl", output: chunkOut });
+    } else {
+      const side = await embedFile(file, { ...chunkOpts, provider, model: opts.model, incremental: true });
+      chunks = await chunkFile(file, { ...chunkOpts, format: "jsonl", output: chunkOut });
+      manifest.files.push({ file: rel, chunks: chunks.length, vectors: Object.keys(side.vectors).length, sidecar: path7.relative(dir, file.replace(/\.(jdf|jdfx)$/i, ".embeddings.json")), videos: vids.length, transcribed: transcribedHere });
+    }
+    if (opts.noEmbed) manifest.files.push({ file: rel, chunks: chunks.length, videos: vids.length, transcribed: transcribedHere });
+    for (const c of chunks) {
+      indexLines.push(JSON.stringify({ file: rel, ...c }));
+      manifest.totals.chunks++;
+      if (c.media) manifest.totals.videoChunks++;
+    }
+  }
+  if (!opts.dryRun) {
+    fs7.mkdirSync(outDir, { recursive: true });
+    fs7.writeFileSync(path7.join(outDir, "index.jsonl"), indexLines.join("\n") + (indexLines.length ? "\n" : ""));
+    fs7.writeFileSync(path7.join(outDir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+  }
+  const t = manifest.totals;
+  console.log(`
+Done. ${t.files} files \u2192 ${t.chunks} chunks (${t.videoChunks} from video transcripts); videos ${t.videos}, transcribed now ${t.transcribed}, still without transcript ${t.untranscribed}${t.untranscribed && transcribe === "none" ? " (pass --transcribe whisper-cli|openai, or jdf transcribe --from subs.srt)" : ""}.`);
+  if (!opts.dryRun) console.log(`Index:  ${path7.join(outDir, "index.jsonl")}
+Report: ${path7.join(outDir, "manifest.json")}${opts.noEmbed ? "" : `
+Vectors: one <file>.embeddings.json next to each document (incremental \u2014 re-run any time)`}`);
+}
 
 // src/index.ts
 var HELP = `jdf \u2014 JSON Document Format CLI
@@ -2045,12 +3030,18 @@ The CLI exists for these workflows:
                      into a validated .jdf (or .jdfx) you can ship.
   \u2022 JDF \u2192 chunks     turn a document into retrieval-ready chunks (RAG).
   \u2022 JDF \u2192 vectors    embed those chunks, incrementally, for a vector store.
+  \u2022 video \u2192 text     attach a time-stamped transcript to a video element so
+                     RAG retrieves "video at 02:13", not just "a video".
+  \u2022 folder \u2192 index   one command over a directory of .jdf/.jdfx: transcribe,
+                     chunk, embed incrementally, write .jdf-rag/index.jsonl.
 
 Usage:
   jdf validate <file.jdf>
-  jdf convert  <file.{pdf,json,md}> [-o output.{jdf,jdfx}] [--json]
+  jdf convert  <file.{pdf,json,md}> [-o output.{jdf,jdfx}] [--json] [--password PW] [--drop-invisible-text]
   jdf chunk    <file.{jdf,jdfx}> [--strategy section|element|fixed] [--format jsonl|json|inline] [--max-tokens N] [-o out]
   jdf embed    <file.{jdf,jdfx}> [--provider ollama|openai] [--model NAME] [--strategy \u2026] [--incremental] [-o out]
+  jdf transcribe <file.{jdf,jdfx}> [--from subs.srt|.vtt|.json] [--provider whisper-cli|openai] [--element ID] [--chapters FILE] [-o out]
+  jdf rag      <dir> [--provider ollama|openai] [--model NAME] [--transcribe none|whisper-cli|openai] [--no-embed] [--dry-run] [--out DIR]
   jdf --help
 
 Commands:
@@ -2058,18 +3049,38 @@ Commands:
   convert    Convert a PDF, JSON, or Markdown file into JDF (alias: import)
   chunk      Split a JDF document into retrieval-ready chunks (offline, deterministic)
   embed      Compute embeddings for the chunks (local via Ollama by default)
+  transcribe Store time-stamped text on a video element (import SRT/VTT/JSON, or run Whisper)
+  rag        Make a whole folder retrieval-ready (finds .jdf/.jdfx, transcribes, chunks, embeds, indexes)
 
 Flags:
   -o, --output <path>   Explicit output path
       --json            convert: force pure JSON .jdf output (inline base64
                         instead of a .jdfx zip bundle)
+      --password <pw>   convert(pdf): password for an encrypted PDF
+      --drop-invisible-text
+                        convert(pdf): omit invisible (OCR-layer) text; by
+                        default it is kept with opacity 0 so RAG / search
+                        still see the words of a scanned PDF
       --strategy <s>    chunk/embed: section (default) | element | fixed
       --format <f>      chunk: jsonl (default) | json | inline
       --max-tokens <n>  chunk/embed: soft cap per chunk (default 512)
       --provider <p>    embed: ollama (default, local) | openai (remote API)
       --model <name>    embed: model id (default: nomic-embed-text / text-embedding-3-small)
       --incremental     embed: skip chunks whose content hash is unchanged
+      --cache <path>    embed: sidecar to reuse vectors from (default: the
+                        output path itself)
       --no-auto-start   embed(ollama): don't auto-launch Ollama via Docker
+      --from <file>     transcribe: import subtitles (.srt / .vtt / JSON segments) \u2014 offline, no model
+      --element <id|n>  transcribe: which video element (id, or 0-based index); default the only one
+      --chapters <file> transcribe: JSON [{t,title}] or "mm:ss Title" lines \u2192 chapter breadcrumbs
+      --language <tag>  transcribe: BCP-47 language hint for Whisper
+      --prompt <text>   transcribe: Whisper vocabulary hint (names, acronyms) \u2014 not an instruction
+      --window <sec>    chunk/embed/rag: transcript window per video chunk (default 45)
+      --transcribe <p>  rag: none (default) | whisper-cli | openai \u2014 for videos that have no transcript yet
+      --no-embed        rag: chunk + index only
+      --dry-run         rag: list what would happen, write nothing
+      --out <dir>       rag: index folder (default <dir>/.jdf-rag)
+                        rag reads defaults from <dir>/jdf.rag.json (same keys as the flags; flags win)
 
 Environment (embed):
   ollama:  OLLAMA_HOST (default http://localhost:11434)
@@ -2083,8 +3094,11 @@ Examples:
   jdf chunk report.jdf --format inline         # embed the chunk index into the .jdf
   jdf embed report.jdf                          # local embeddings via Ollama (auto-setup)
   jdf embed report.jdf --provider openai --incremental
+  jdf transcribe talk.jdfx --from talk.srt --chapters chapters.txt   # then: jdf chunk talk.jdfx
+  jdf transcribe talk.jdfx --provider openai --language en --prompt "JDF, jdfx, Ollama"
+  jdf rag ./knowledge-base --transcribe openai              # whole folder \u2192 .jdf-rag/index.jsonl
 `;
-var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["help", "h", "json", "verbose", "skip-validate", "incremental", "no-auto-start"]);
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["help", "h", "json", "verbose", "skip-validate", "incremental", "no-auto-start", "drop-invisible-text", "no-embed", "dry-run"]);
 function parseArgs(argv) {
   const positional = [];
   const flags = {};
@@ -2164,7 +3178,11 @@ async function main() {
           await importMarkdown(input, output);
           process.exit(0);
         } else if (lower.endsWith(".pdf")) {
-          await importPdf(input, output, { forceJson });
+          await importPdf(input, output, {
+            forceJson,
+            password: typeof flags.password === "string" ? flags.password : void 0,
+            dropInvisibleText: flags["drop-invisible-text"] === true
+          });
           process.exit(0);
         } else if (lower.endsWith(".json")) {
           await importJson(input, output, { forceJson });
@@ -2184,14 +3202,55 @@ async function main() {
           strategy: typeof flags.strategy === "string" ? flags.strategy : void 0,
           format: typeof flags.format === "string" ? flags.format : void 0,
           maxTokens: typeof flags["max-tokens"] === "string" ? parseInt(flags["max-tokens"], 10) : void 0,
+          transcriptWindowSec: typeof flags.window === "string" ? parseInt(flags.window, 10) : void 0,
           output: typeof flags.output === "string" ? flags.output : void 0
         });
         process.exit(0);
       }
+      case "transcribe": {
+        const input = positional[0];
+        if (!input) {
+          console.error("Usage: jdf transcribe <file.{jdf,jdfx}> [--from subs.srt|.vtt|.json] [--provider whisper-cli|openai] [--model M] [--language tag] [--element id|n] [--chapters file] [-o out]");
+          process.exit(1);
+        }
+        await transcribeFile(input, {
+          from: typeof flags.from === "string" ? flags.from : void 0,
+          provider: typeof flags.provider === "string" ? flags.provider : void 0,
+          model: typeof flags.model === "string" ? flags.model : void 0,
+          language: typeof flags.language === "string" ? flags.language : void 0,
+          prompt: typeof flags.prompt === "string" ? flags.prompt : void 0,
+          element: typeof flags.element === "string" ? flags.element : void 0,
+          chapters: typeof flags.chapters === "string" ? flags.chapters : void 0,
+          output: typeof flags.output === "string" ? flags.output : void 0
+        });
+        process.exit(0);
+      }
+      case "rag": {
+        const input = positional[0];
+        if (!input) {
+          console.error("Usage: jdf rag <dir> [--provider ollama|openai] [--model NAME] [--strategy \u2026] [--window sec] [--transcribe none|whisper-cli|openai] [--language tag] [--prompt text] [--no-embed] [--dry-run] [--out DIR]");
+          process.exit(1);
+        }
+        await ragFolder(input, {
+          provider: typeof flags.provider === "string" ? flags.provider : void 0,
+          model: typeof flags.model === "string" ? flags.model : void 0,
+          strategy: typeof flags.strategy === "string" ? flags.strategy : void 0,
+          maxTokens: typeof flags["max-tokens"] === "string" ? parseInt(flags["max-tokens"], 10) : void 0,
+          transcriptWindowSec: typeof flags.window === "string" ? parseInt(flags.window, 10) : void 0,
+          transcribe: typeof flags.transcribe === "string" ? flags.transcribe : void 0,
+          transcribeModel: typeof flags["transcribe-model"] === "string" ? flags["transcribe-model"] : void 0,
+          language: typeof flags.language === "string" ? flags.language : void 0,
+          prompt: typeof flags.prompt === "string" ? flags.prompt : void 0,
+          noEmbed: flags["no-embed"] === true,
+          dryRun: flags["dry-run"] === true,
+          out: typeof flags.out === "string" ? flags.out : void 0
+        });
+        process.exit(0);
+      }
       case "embed": {
         const input = positional[0];
         if (!input) {
-          console.error("Usage: jdf embed <file.{jdf,jdfx}> [--provider ollama|openai] [--model NAME] [--strategy \u2026] [--incremental] [--no-auto-start] [-o out]");
+          console.error("Usage: jdf embed <file.{jdf,jdfx}> [--provider ollama|openai] [--model NAME] [--strategy \u2026] [--incremental] [--cache prev.embeddings.json] [--no-auto-start] [-o out]");
           process.exit(1);
         }
         await embedFile(input, {
@@ -2200,8 +3259,10 @@ async function main() {
           strategy: typeof flags.strategy === "string" ? flags.strategy : void 0,
           maxTokens: typeof flags["max-tokens"] === "string" ? parseInt(flags["max-tokens"], 10) : void 0,
           incremental: flags.incremental === true,
+          transcriptWindowSec: typeof flags.window === "string" ? parseInt(flags.window, 10) : void 0,
           autoStart: flags["no-auto-start"] !== true,
-          output: typeof flags.output === "string" ? flags.output : void 0
+          output: typeof flags.output === "string" ? flags.output : void 0,
+          cache: typeof flags.cache === "string" ? flags.cache : void 0
         });
         process.exit(0);
       }