@uurtech/jdf-cli 0.1.26 → 0.2.1

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);
@@ -724,19 +958,36 @@ async function walkOps(page, OPS, viewport) {
     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,
+      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);
@@ -746,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") {
@@ -764,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)}`
         });
@@ -825,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
         });
@@ -1000,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) {
@@ -1008,6 +1265,7 @@ 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;
@@ -1172,10 +1430,10 @@ async function extractLinks(doc, 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;
     const destPage = url ? void 0 : await resolveDestPage(doc, a.dest);
@@ -1213,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}`,
@@ -1236,16 +1494,16 @@ async function extractFormWidgets(page, viewport) {
 async function flattenOutline(doc, outline) {
   if (!outline) return [];
   const out = [];
-  async function walk(items, depth) {
+  async function walk2(items, depth) {
     for (const item of items) {
       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, depth + 1);
+      if (item.items?.length) await walk2(item.items, depth + 1);
     }
   }
-  await walk(outline, 1);
+  await walk2(outline, 1);
   return out;
 }
 var normTitle = (s) => s.toLowerCase().replace(/[\s\u00a0]+/g, " ").replace(/[^\p{L}\p{N} ]/gu, "").trim();
@@ -1441,6 +1699,10 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       if (arr) arr.push(op);
       else opBins.set(key, [op]);
     }
+    const sizePenalty = (op, fontSize) => {
+      if (!op.fontSize || !fontSize) return 0;
+      return Math.abs(Math.log(op.fontSize / fontSize)) * 6;
+    };
     const findOp = (x, y, fontSize) => {
       let best = null;
       let bestD = Infinity;
@@ -1450,7 +1712,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
           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);
+            const d = Math.hypot(op.x - x, op.y - y) + sizePenalty(op, fontSize);
             if (d < bestD) {
               bestD = d;
               best = op;
@@ -1460,8 +1722,9 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       }
       if (best) return best;
       const tol = Math.max(2, fontSize * 0.6);
+      const sizeOk = (op) => !op.fontSize || !fontSize || op.fontSize / fontSize > 0.6 && op.fontSize / fontSize < 1.7;
       for (const op of ops.textOps) {
-        if (Math.abs(op.y - y) > tol) continue;
+        if (!sizeOk(op) || 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;
@@ -1470,6 +1733,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       }
       if (best) return best;
       for (const op of ops.textOps) {
+        if (!sizeOk(op)) continue;
         const d = Math.hypot(op.x - x, op.y - y);
         if (d < bestD) {
           bestD = d;
@@ -1488,6 +1752,7 @@ 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);
+      if (fontSize < 1.5) return;
       const op = findOp(vx, vy, fontSize);
       const mode = op?.mode ?? 0;
       if (mode === 7) return;
@@ -1498,12 +1763,12 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       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),
+        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)
       });
@@ -1511,6 +1776,12 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
     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];
@@ -1519,24 +1790,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",
@@ -1552,7 +1847,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);
@@ -1575,7 +1870,98 @@ 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;
+    const rowOf = /* @__PURE__ */ new Map();
+    const rowStartOf = /* @__PURE__ */ new Map();
+    const nextOnRow = /* @__PURE__ */ new Map();
+    {
+      const order = lines.map((_, i) => i).filter((i) => !consumedLines.has(i));
+      for (let a = 0; a < order.length; a++) {
+        const i = order[a], li = lines[i];
+        const tolY = Math.max(0.6, li.fontSize * PT_TO_MM2 * 0.35);
+        let bestNext = -1, bestX = Infinity;
+        for (let b = 0; b < order.length; b++) {
+          const j = order[b], lj = lines[j];
+          if (j === i || Math.abs(lj.y - li.y) > tolY || lj.x <= li.x) continue;
+          if (lj.x < bestX) {
+            bestX = lj.x;
+            bestNext = j;
+          }
+        }
+        if (bestNext >= 0) nextOnRow.set(i, bestNext);
+      }
+      const seen = /* @__PURE__ */ new Set();
+      for (const i of order) {
+        if (seen.has(i)) continue;
+        const row = [i];
+        seen.add(i);
+        let cur = i;
+        while (nextOnRow.has(cur)) {
+          const j = nextOnRow.get(cur), lc = lines[cur], lj = lines[j];
+          const em = Math.min(lc.fontSize, lj.fontSize) * PT_TO_MM2;
+          const gap = lj.x - (lc.x + lc.width);
+          if (gap < -em * 0.3 || gap > em * 0.6) break;
+          row.push(j);
+          seen.add(j);
+          cur = j;
+        }
+        rowOf.set(i, row);
+        for (const j of row) rowStartOf.set(j, i);
+      }
+    }
+    const runStyle = (l) => {
+      const cls = fontMap.get(l.fontName) || classifyFont(l.fontName || "");
+      return { cls, bold: cls.weight === "bold", italic: cls.style === "italic" };
+    };
+    lines.forEach((l, lineIdx) => {
+      const tableEl = tableAtLine.get(lineIdx);
+      if (tableEl) elements.push(tableEl);
+      if (consumedLines.has(lineIdx)) return;
+      const row = rowOf.get(lineIdx);
+      if (!row) return;
+      if (row.length > 1) {
+        const first = lines[row[0]], last = lines[row[row.length - 1]];
+        const base = runStyle(first);
+        const rowEnd = last.x + last.width;
+        const measuredW = Math.max((rowEnd - first.x) * 1.2 + first.fontSize * PT_TO_MM2 * 0.4, first.fontSize * PT_TO_MM2);
+        const nextIdx2 = nextOnRow.get(row[row.length - 1]);
+        const cap2 = nextIdx2 != null ? lines[nextIdx2].x - first.x - first.fontSize * PT_TO_MM2 * 0.3 : pageWmm - first.x;
+        const runs2 = [];
+        row.forEach((idx, k) => {
+          const r = lines[idx];
+          const st = runStyle(r);
+          let text2 = r.text;
+          if (k > 0) {
+            const prev2 = lines[row[k - 1]];
+            const gap = r.x - (prev2.x + prev2.width);
+            if (gap > r.fontSize * PT_TO_MM2 * 0.08 && !/\s$/.test(prev2.text) && !/^\s/.test(text2)) text2 = " " + text2;
+          }
+          const run = { text: text2 };
+          if (st.bold) run.bold = true;
+          if (st.italic) run.italic = true;
+          if (r.color !== "#000000") run.color = r.color;
+          if (Math.abs(r.fontSize - first.fontSize) >= 0.5) run.fontSize = Math.round(r.fontSize * 10) / 10;
+          if (st.cls.family !== base.cls.family) run.fontFamily = st.cls.family;
+          const lk = findLinkForRun2(r);
+          if (lk) run.link = lk.url ? lk.url : lk.destPage != null ? { type: "internal", target: `#page-${lk.destPage + 1}` } : void 0;
+          runs2.push(run);
+        });
+        const style2 = { fontSize: Math.round(first.fontSize * 10) / 10, fontFamily: base.cls.family };
+        if (first.opacity < 0.999) style2.opacity = Math.round(first.opacity * 100) / 100;
+        elements.push({
+          type: "richtext",
+          runs: runs2,
+          position: { x: Math.max(0, Math.round(first.x * 100) / 100), y: Math.max(0, Math.round(Math.min(...row.map((i) => lines[i].y)) * 100) / 100) },
+          width: Math.max(2, Math.round(Math.max(first.fontSize * PT_TO_MM2, Math.min(measuredW, cap2)) * 100) / 100),
+          style: style2
+        });
+        return;
+      }
       const cls = fontMap.get(l.fontName) || classifyFont(l.fontName || "");
       const style = {
         fontSize: Math.round(l.fontSize * 10) / 10,
@@ -1586,10 +1972,11 @@ 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 * 1.2 + 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 nextIdx = nextOnRow.get(lineIdx);
+      const cap = nextIdx != null ? Math.max(l.fontSize * PT_TO_MM2, lines[nextIdx].x - l.x - l.fontSize * PT_TO_MM2 * 0.3) : Infinity;
+      const elWidth = Math.min(measured, remaining, cap);
       const text = {
         type: "text",
         content: l.text,
@@ -1597,18 +1984,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 = {
@@ -1643,7 +2038,7 @@ 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
     });
@@ -1796,13 +2191,13 @@ 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, {
     password: options.password,
@@ -1811,7 +2206,7 @@ async function importPdf(inputPath, outputPath, options = {}) {
   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);
@@ -1820,11 +2215,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)`);
   }
@@ -1837,23 +2232,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);
@@ -1862,11 +2257,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)`);
   }
@@ -1942,6 +2337,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);
@@ -1964,11 +2400,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) ?? [];
@@ -1999,6 +2435,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":
@@ -2038,8 +2476,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) {
@@ -2048,8 +2493,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;
   }
@@ -2058,8 +2502,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;
     };
@@ -2086,22 +2529,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);
     }
@@ -2112,34 +2554,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);
@@ -2311,17 +2753,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;
   }
@@ -2332,15 +2774,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`);
@@ -2379,11 +2821,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
@@ -2395,12 +3121,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] [--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:
@@ -2408,6 +3140,8 @@ 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
@@ -2424,7 +3158,20 @@ Flags:
       --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)
@@ -2438,8 +3185,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", "drop-invisible-text"]);
+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 = {};
@@ -2543,14 +3293,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, {
@@ -2559,8 +3350,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);
       }