@uurtech/jdf-cli 0.1.5 → 0.1.8

package/dist/index.js

@@ -5,6 +5,8 @@ import { fileURLToPath } from 'url';
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
 import JSZip from 'jszip';
+import { createHash } from 'crypto';
+import { readFile } from 'fs/promises';
 
 // ../../packages/jdf-core/src/manifest.ts
 var JDFX_MANIFEST_VERSION = "1.0.0";
@@ -38,7 +40,14 @@ async function loadDocument(filePath) {
       } catch {
       }
     }
-    const assetCount = Object.values(zip.files).filter((f) => !f.dir && f.name.startsWith("assets/")).length;
+    const assetPrefix = `${JDFX_ASSET_DIR}/`;
+    const assetCount = Object.values(zip.files).filter((f) => !f.dir && f.name.startsWith(assetPrefix)).length;
+    for (const fname of Object.keys(zip.files)) {
+      if (fname.includes("..") || fname.startsWith("/")) {
+        console.error(`\u2717 Refusing zip entry with traversal: ${fname}`);
+        return null;
+      }
+    }
     return { doc, bundle: { manifest, assetCount } };
   }
   return { doc: JSON.parse(fs.readFileSync(filePath, "utf-8")) };
@@ -95,21 +104,59 @@ var GENERATOR = "@uurtech/jdf-cli";
 function decodeBase64(s) {
   return Buffer.from(s, "base64");
 }
+function hashBytes(bytes) {
+  return createHash("sha1").update(bytes).digest("hex").slice(0, 16);
+}
+function rewriteResourceRefs(doc, oldKey, newKey) {
+  function walk(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);
+    }
+  }
+  for (const page of doc.pages || []) walk(page.elements);
+}
 function extractAssets(doc) {
   const assets = [];
   const cloned = JSON.parse(JSON.stringify(doc));
-  let counter = 0;
+  const usedIds = /* @__PURE__ */ new Set();
+  const hashToId = /* @__PURE__ */ new Map();
+  let inlineCounter = 0;
+  if (cloned.resources?.images) {
+    for (const key of Object.keys(cloned.resources.images)) {
+      usedIds.add(key);
+    }
+  }
+  function nextInlineId() {
+    while (true) {
+      inlineCounter++;
+      const id = `asset-${inlineCounter}`;
+      if (!usedIds.has(id)) {
+        usedIds.add(id);
+        return id;
+      }
+    }
+  }
+  function intern(bytes, mimeType, ext) {
+    const h = hashBytes(bytes);
+    const existing = hashToId.get(h);
+    if (existing) return existing;
+    const id = nextInlineId();
+    hashToId.set(h, id);
+    assets.push({ id, bytes, mimeType, ext });
+    return id;
+  }
   function walk(els) {
     if (!els) return;
     for (const el of els) {
       if (el?.type === "image" && typeof el.src === "string" && el.src.startsWith("data:")) {
         const m = el.src.match(/^data:([^;]+);base64,(.*)$/);
         if (m) {
-          counter++;
-          const id = `asset-${counter}`;
           const mimeType = m[1];
           const ext = mimeType.split("/")[1]?.replace("jpeg", "jpg") || "bin";
-          assets.push({ id, bytes: decodeBase64(m[2]), mimeType, ext });
+          const id = intern(decodeBase64(m[2]), mimeType, ext);
           delete el.src;
           el.resource = id;
         }
@@ -127,11 +174,25 @@ function extractAssets(doc) {
       const b64 = m ? m[2] : data;
       const mimeType = m ? m[1] : res.mimeType || "image/png";
       const ext = mimeType.split("/")[1]?.replace("jpeg", "jpg") || "bin";
-      counter++;
-      const id = key || `asset-${counter}`;
-      assets.push({ id, bytes: decodeBase64(b64), mimeType, ext });
+      const bytes = decodeBase64(b64);
+      const h = hashBytes(bytes);
+      let canonicalId = hashToId.get(h);
+      if (!canonicalId) {
+        canonicalId = key;
+        hashToId.set(h, canonicalId);
+        usedIds.add(canonicalId);
+        assets.push({ id: canonicalId, bytes, mimeType, ext });
+      }
+      const updated = { ...res };
+      delete updated.data;
+      updated.src = "embedded";
+      if (canonicalId !== key) {
+        delete cloned.resources.images[key];
+        rewriteResourceRefs(cloned, key, canonicalId);
+      } else {
+        cloned.resources.images[key] = updated;
+      }
     }
-    cloned.resources.images = {};
   }
   return { doc: cloned, assets };
 }
@@ -257,8 +318,12 @@ function convertMarkdownToJdf(md, title, baseDir = process.cwd()) {
         content: text,
         position: { x: 0, y },
         width: contentWidth,
-        heading: true,
+        // Emit the actual H1..H6 level instead of `heading: true`. RAG
+        // chunkers and the JDF TOC builder both key on the numeric level for
+        // hierarchy; the boolean form collapsed every heading to one bucket.
+        heading: level,
         tocEntry: text,
+        tocLevel: level,
         style: { fontFamily: "Inter", fontSize, fontWeight: "bold", color: level <= 2 ? "#0f172a" : "#1e293b" }
       });
       y += height2 + 4;
@@ -339,12 +404,20 @@ function convertMarkdownToJdf(md, title, baseDir = process.cwd()) {
     }
     if (line.startsWith("```")) {
       const codeLines = [];
+      const fenceLine = i;
       i++;
+      let closed = false;
       while (i < lines.length && !lines[i].startsWith("```")) {
         codeLines.push(lines[i]);
         i++;
       }
-      i++;
+      if (i < lines.length) {
+        closed = true;
+        i++;
+      }
+      if (!closed) {
+        console.warn(`[jdf-cli] warning: unterminated code fence at line ${fenceLine + 1} \u2014 content to EOF treated as code`);
+      }
       const code = codeLines.join("\n");
       const height2 = codeLines.length * 4 + 8;
       if (y + height2 > maxY) {
@@ -369,7 +442,7 @@ function convertMarkdownToJdf(md, title, baseDir = process.cwd()) {
       continue;
     }
     let para = "";
-    while (i < lines.length && lines[i].trim() !== "" && !lines[i].match(/^#{1,6}\s/) && !lines[i].match(/^\s*[-*+]\s/) && !lines[i].startsWith("```")) {
+    while (i < lines.length && lines[i].trim() !== "" && !lines[i].match(/^#{1,6}\s/) && !lines[i].match(/^\s*[-*+]\s/) && !lines[i].match(/^\s*\d+\.\s/) && !lines[i].startsWith("```")) {
       para += (para ? " " : "") + lines[i].trim();
       i++;
     }
@@ -409,30 +482,1001 @@ function convertMarkdownToJdf(md, title, baseDir = process.cwd()) {
   };
 }
 
+// ../../packages/jdf-pdf-import/src/core.ts
+var PT_TO_MM = 0.352778;
+function classifyFont(name) {
+  const n = (name || "").toLowerCase();
+  const bold = /bold|black|heavy|semibold|demibold|extrabold/.test(n);
+  const italic = /italic|oblique/.test(n);
+  let family = "Inter, Helvetica, Arial, sans-serif";
+  if (n.includes("times") || n.includes("serif") || n.includes("roman") || n.includes("georgia") || n.includes("garamond") || n.includes("baskerville")) {
+    family = "Times New Roman, serif";
+  } else if (n.includes("courier") || n.includes("mono") || n.includes("consolas") || n.includes("menlo") || n.includes("source code") || n.includes("fira code")) {
+    family = "JetBrains Mono, ui-monospace, monospace";
+  } else if (n.includes("helvetica") || n.includes("arial") || n.includes("sans") || n.includes("roboto") || n.includes("inter") || n.includes("noto")) {
+    family = "Inter, Helvetica, Arial, sans-serif";
+  }
+  return {
+    family,
+    weight: bold ? "bold" : void 0,
+    style: italic ? "italic" : void 0
+  };
+}
+function clampByte(v) {
+  return Math.max(0, Math.min(255, Math.round(v)));
+}
+function rgbToHex(r, g, b) {
+  const h = (n) => clampByte(n).toString(16).padStart(2, "0");
+  return `#${h(r)}${h(g)}${h(b)}`;
+}
+function multiplyCtm(a, b) {
+  return [
+    a[0] * b[0] + a[1] * b[2],
+    a[0] * b[1] + a[1] * b[3],
+    a[2] * b[0] + a[3] * b[2],
+    a[2] * b[1] + a[3] * b[3],
+    a[4] * b[0] + a[5] * b[2] + b[4],
+    a[4] * b[1] + a[5] * b[3] + b[5]
+  ];
+}
+function tx(ctm, x, y) {
+  return { x: ctm[0] * x + ctm[2] * y + ctm[4], y: ctm[1] * x + ctm[3] * y + ctm[5] };
+}
+async function walkOps(page, OPS, viewport) {
+  const toViewport = (x, y) => {
+    const [vx, vy] = viewport.convertToViewportPoint(x, y);
+    return { x: vx, y: vy };
+  };
+  const opList = await page.getOperatorList();
+  const fnArr = opList.fnArray;
+  const argsArr = opList.argsArray;
+  const gs = {
+    ctm: [1, 0, 0, 1, 0, 0],
+    fill: "#000000",
+    stroke: "#000000",
+    lineWidth: 1,
+    fillAlpha: 1,
+    strokeAlpha: 1,
+    textRenderingMode: 0
+  };
+  const stack = [];
+  const textColors = [];
+  const textOpacities = [];
+  const textRenderingModes = [];
+  const shapes = [];
+  const imagePositions = [];
+  let textIdx = 0;
+  let pathSegments = [];
+  let pathRect = null;
+  let pathStart = null;
+  let pathLast = null;
+  function flushPath(isFill, isStroke) {
+    if (pathRect) {
+      const tl = toViewport(pathRect.x, pathRect.y + pathRect.h);
+      const br = toViewport(pathRect.x + pathRect.w, pathRect.y);
+      const x = Math.min(tl.x, br.x);
+      const y = Math.min(tl.y, br.y);
+      const w = Math.abs(br.x - tl.x);
+      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,
+        fill: isFill ? gs.fill : void 0,
+        stroke: isStroke ? gs.stroke : void 0,
+        strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM : void 0,
+        opacity: isFill ? gs.fillAlpha : gs.strokeAlpha
+      });
+    } else if (pathSegments.length === 2 && pathSegments[0].type === "M" && pathSegments[1].type === "L") {
+      const a = pathSegments[0].pts;
+      const b = pathSegments[1].pts;
+      const va = toViewport(a[0], a[1]);
+      const vb = toViewport(b[0], b[1]);
+      const minX = Math.min(va.x, vb.x);
+      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;
+      shapes.push({
+        kind: "path",
+        x: minX * PT_TO_MM,
+        y: minY * PT_TO_MM,
+        width: Math.max(0.05, (maxX - minX) * PT_TO_MM),
+        height: Math.max(0.05, (maxY - minY) * PT_TO_MM),
+        stroke: isStroke ? gs.stroke : void 0,
+        strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM : void 0,
+        opacity: gs.strokeAlpha,
+        path: `M ${x1Local.toFixed(2)} ${y1Local.toFixed(2)} L ${x2Local.toFixed(2)} ${y2Local.toFixed(2)}`
+      });
+    } else if (pathSegments.length > 0) {
+      const vpSegments = pathSegments.map((seg) => {
+        if (seg.type === "Z") return seg;
+        const out = [];
+        for (let i = 0; i < seg.pts.length; i += 2) {
+          const v = toViewport(seg.pts[i], seg.pts[i + 1]);
+          out.push(v.x, v.y);
+        }
+        return { type: seg.type, pts: out };
+      });
+      let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+      for (const seg of vpSegments) {
+        for (let i = 0; i < seg.pts.length; i += 2) {
+          const x = seg.pts[i];
+          const y = seg.pts[i + 1];
+          if (x < minX) minX = x;
+          if (x > maxX) maxX = x;
+          if (y < minY) minY = y;
+          if (y > maxY) maxY = y;
+        }
+      }
+      if (isFinite(minX) && isFinite(minY)) {
+        const bw = maxX - minX;
+        const bh = maxY - minY;
+        const d = vpSegments.map((seg) => {
+          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));
+          }
+          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,
+          fill: isFill ? gs.fill : void 0,
+          stroke: isStroke ? gs.stroke : void 0,
+          strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM : void 0,
+          opacity: isFill ? gs.fillAlpha : gs.strokeAlpha,
+          path: d
+        });
+      }
+    }
+    pathSegments = [];
+    pathRect = null;
+    pathStart = null;
+    pathLast = null;
+  }
+  for (let i = 0; i < fnArr.length; i++) {
+    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 });
+    } else if (fn === OPS.restore) {
+      const s = stack.pop();
+      if (s) Object.assign(gs, s);
+    } else if (fn === OPS.transform) {
+      gs.ctm = multiplyCtm(gs.ctm, args);
+    } else if (fn === OPS.setFillRGBColor) {
+      gs.fill = rgbToHex(args[0], args[1], args[2]);
+    } else if (fn === OPS.setStrokeRGBColor) {
+      gs.stroke = rgbToHex(args[0], args[1], args[2]);
+    } else if (fn === OPS.setFillGray) {
+      gs.fill = rgbToHex(args[0], args[0], args[0]);
+    } else if (fn === OPS.setStrokeGray) {
+      gs.stroke = rgbToHex(args[0], args[0], args[0]);
+    } else if (fn === OPS.setFillCMYKColor || fn === OPS.setStrokeCMYKColor) {
+      const c = args[0], m = args[1], y = args[2], k = args[3];
+      const r = (1 - c) * (1 - k) * 255;
+      const g = (1 - m) * (1 - k) * 255;
+      const b = (1 - y) * (1 - k) * 255;
+      const hex = rgbToHex(r, g, b);
+      if (fn === OPS.setFillCMYKColor) gs.fill = hex;
+      else gs.stroke = hex;
+    } else if (fn === OPS.setLineWidth) {
+      gs.lineWidth = args[0];
+    } else if (fn === OPS.setTextRenderingMode) {
+      gs.textRenderingMode = args[0];
+    } else if (fn === OPS.setGState) {
+      const dict = args[0];
+      if (Array.isArray(dict)) {
+        for (const entry of dict) {
+          if (!Array.isArray(entry)) continue;
+          const [key, val] = entry;
+          if (key === "LW") gs.lineWidth = val;
+          else if (key === "ca") gs.fillAlpha = val;
+          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.rectangle) {
+      const [x, y, w, h] = args;
+      const p1 = tx(gs.ctm, x, y);
+      const p3 = tx(gs.ctm, x + w, y + h);
+      pathRect = {
+        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.constructPath) {
+      const [pathOps, pathArgs] = args;
+      let ai = 0;
+      for (const op of pathOps) {
+        if (op === OPS.moveTo) {
+          const p = tx(gs.ctm, pathArgs[ai], pathArgs[ai + 1]);
+          ai += 2;
+          pathSegments.push({ type: "M", pts: [p.x, p.y] });
+          pathStart = { x: p.x, y: p.y };
+          pathLast = { x: p.x, y: p.y };
+        } else if (op === OPS.lineTo) {
+          const p = tx(gs.ctm, pathArgs[ai], pathArgs[ai + 1]);
+          ai += 2;
+          pathSegments.push({ type: "L", pts: [p.x, p.y] });
+          pathLast = { x: p.x, y: p.y };
+        } else if (op === OPS.curveTo) {
+          const p1 = tx(gs.ctm, pathArgs[ai], pathArgs[ai + 1]);
+          ai += 2;
+          const p2 = tx(gs.ctm, pathArgs[ai], pathArgs[ai + 1]);
+          ai += 2;
+          const p3 = tx(gs.ctm, pathArgs[ai], pathArgs[ai + 1]);
+          ai += 2;
+          pathSegments.push({ type: "C", pts: [p1.x, p1.y, p2.x, p2.y, p3.x, p3.y] });
+          pathLast = { x: p3.x, y: p3.y };
+        } else if (op === OPS.curveTo2) {
+          const p2 = tx(gs.ctm, pathArgs[ai], pathArgs[ai + 1]);
+          ai += 2;
+          const p3 = tx(gs.ctm, pathArgs[ai], pathArgs[ai + 1]);
+          ai += 2;
+          const p1 = pathLast || { x: 0, y: 0 };
+          pathSegments.push({ type: "C", pts: [p1.x, p1.y, p2.x, p2.y, p3.x, p3.y] });
+          pathLast = { x: p3.x, y: p3.y };
+        } else if (op === OPS.curveTo3) {
+          const p1 = tx(gs.ctm, pathArgs[ai], pathArgs[ai + 1]);
+          ai += 2;
+          const p3 = tx(gs.ctm, pathArgs[ai], pathArgs[ai + 1]);
+          ai += 2;
+          pathSegments.push({ type: "C", pts: [p1.x, p1.y, p3.x, p3.y, p3.x, p3.y] });
+          pathLast = { x: p3.x, y: p3.y };
+        } else if (op === OPS.closePath) {
+          pathSegments.push({ type: "Z", pts: [] });
+          if (pathStart) pathLast = { ...pathStart };
+        }
+      }
+    } 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) {
+      const isFill = fn === OPS.fill || fn === OPS.fillStroke || fn === OPS.eoFill || fn === OPS.eoFillStroke || fn === OPS.closeFillStroke || fn === OPS.closeEOFillStroke;
+      const isStroke = fn === OPS.stroke || fn === OPS.fillStroke || fn === OPS.eoFillStroke || fn === OPS.closeFillStroke || fn === OPS.closeStroke || fn === OPS.closeEOFillStroke;
+      flushPath(isFill, isStroke);
+    } else if (fn === OPS.endPath || fn === OPS.clip || fn === OPS.eoClip) {
+      pathSegments = [];
+      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
+      });
+    }
+  }
+  return { textColors, textOpacities, textRenderingModes, shapes, imagePositions };
+}
+async function extractImages(page, positions, runtime, dataUrlCache) {
+  const tasks = positions.map(async (pos) => {
+    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);
+          }
+        }
+      });
+    } 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);
+    if (!dataUrl) return null;
+    dataUrlCache.set(pos.name, dataUrl);
+    return { pos, dataUrl };
+  });
+  const settled = await Promise.all(tasks);
+  return settled.filter((x) => x !== null);
+}
+async function extractLinks(page, viewport) {
+  const out = [];
+  let annots = [];
+  try {
+    annots = await page.getAnnotations();
+  } catch {
+    return out;
+  }
+  const conv = (x, y) => {
+    const [vx, vy] = viewport.convertToViewportPoint(x, y);
+    return { x: vx, y: vy };
+  };
+  for (const a of annots) {
+    if (a.subtype !== "Link") continue;
+    if (!a.rect || a.rect.length < 4) continue;
+    const [x1, y1, x2, y2] = a.rect;
+    const c1 = conv(x1, y1);
+    const c2 = conv(x2, y2);
+    const xMin = Math.min(c1.x, c2.x);
+    const yMin = Math.min(c1.y, c2.y);
+    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
+    };
+    const url = a.url || a.unsafeUrl;
+    out.push({ rectMm, url });
+  }
+  return out;
+}
+async function extractFormWidgets(page, viewport) {
+  const out = [];
+  let annots = [];
+  try {
+    annots = await page.getAnnotations();
+  } catch {
+    return out;
+  }
+  const conv = (x, y) => {
+    const [vx, vy] = viewport.convertToViewportPoint(x, y);
+    return { x: vx, y: vy };
+  };
+  for (const a of annots) {
+    if (a.subtype !== "Widget") continue;
+    if (!a.rect || a.rect.length < 4) continue;
+    const [x1, y1, x2, y2] = a.rect;
+    const c1 = conv(x1, y1);
+    const c2 = conv(x2, y2);
+    const xMin = Math.min(c1.x, c2.x);
+    const yMin = Math.min(c1.y, c2.y);
+    const xMax = Math.max(c1.x, c2.x);
+    const yMax = Math.max(c1.y, c2.y);
+    const flags = typeof a.fieldFlags === "number" ? a.fieldFlags : 0;
+    const options = Array.isArray(a.options) ? a.options.map((o) => ({
+      value: typeof o?.exportValue === "string" ? o.exportValue : typeof o?.value === "string" ? o.value : "",
+      label: typeof o?.displayValue === "string" ? o.displayValue : void 0
+    })).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
+      },
+      fieldType: a.fieldType || "",
+      fieldName: a.fieldName || `field-${out.length + 1}`,
+      fieldValue: a.fieldValue ?? a.buttonValue ?? "",
+      multiLine: (flags & 4096) !== 0,
+      multiSelect: (flags & 2097152) !== 0,
+      combo: (flags & 131072) !== 0,
+      pushButton: (flags & 65536) !== 0,
+      radio: (flags & 32768) !== 0,
+      options,
+      readonly: (flags & 1) !== 0,
+      required: (flags & 2) !== 0
+    });
+  }
+  return out;
+}
+async function flattenOutline(doc, outline) {
+  if (!outline) return [];
+  const out = [];
+  async function walk(items) {
+    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 {
+      }
+      if (item.items?.length) await walk(item.items);
+    }
+  }
+  await walk(outline);
+  return out;
+}
+async function importPdfToJdf(source, title, runtime, options = {}) {
+  const pdfjs = options.pdfjs || runtime.pdfjs;
+  if (!pdfjs) {
+    throw new Error("[@jdf/pdf-import] runtime did not provide a pdfjs module");
+  }
+  const OPS = pdfjs.OPS;
+  let data;
+  if (typeof source === "string") {
+    if (source.startsWith("data:") || source.startsWith("http")) {
+      const r = await fetch(source);
+      data = await r.arrayBuffer();
+    } else {
+      if (!runtime.readFile) {
+        throw new Error("[@jdf/pdf-import] cannot read file path: runtime has no readFile()");
+      }
+      data = await runtime.readFile(source);
+    }
+  } else {
+    data = source;
+  }
+  const doc = await 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
+    // `Worker` (worker_threads) that isn't compatible with PDF.js's worker
+    // protocol — the sniff would silently re-enable the broken path on
+    // newer Node. Browser entry leaves this unset (= false = real worker
+    // via GlobalWorkerOptions.workerSrc); node entry sets `true`.
+    disableWorker: runtime.disableWorker === true,
+    isEvalSupported: false
+  }).promise;
+  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);
+  for (let pi = 1; pi <= doc.numPages; pi++) {
+    let findLinkForRun2 = function(r) {
+      const cx = r.x + r.width / 2;
+      const cy = r.y + r.height / 2;
+      for (const a of links) {
+        if (cx >= a.rectMm.x && cx <= a.rectMm.x + a.rectMm.w && cy >= a.rectMm.y && cy <= a.rectMm.y + a.rectMm.h) {
+          return a;
+        }
+      }
+      return null;
+    };
+    const page = await doc.getPage(pi);
+    const viewport = page.getViewport({ scale: 1 });
+    const pageW = viewport.width;
+    const pageH = viewport.height;
+    const { canvas, context } = runtime.createCanvas(Math.ceil(pageW), Math.ceil(pageH));
+    try {
+      await page.render({ canvasContext: context, viewport, canvas }).promise;
+    } catch {
+    }
+    const ops = await walkOps(page, OPS, viewport);
+    const links = await extractLinks(page, viewport);
+    const formWidgets = await extractFormWidgets(page, viewport);
+    const textContent = await page.getTextContent({ disableCombineTextItems: false });
+    const items = textContent.items;
+    const fontMap = /* @__PURE__ */ new Map();
+    for (const k of Object.keys(textContent.styles || {})) {
+      const s = textContent.styles[k];
+      let realName = s.fontFamily || k;
+      try {
+        const has = typeof page.commonObjs.has === "function" ? page.commonObjs.has(k) : false;
+        if (has) {
+          await new Promise((resolve) => {
+            let settled = false;
+            const done = () => {
+              if (!settled) {
+                settled = true;
+                resolve();
+              }
+            };
+            try {
+              page.commonObjs.get(k, (font) => {
+                if (font?.name) realName = font.name;
+                else if (font?.loadedName) realName = font.loadedName;
+                done();
+              });
+            } catch {
+              done();
+            }
+            setTimeout(done, 100);
+          });
+        }
+      } catch {
+      }
+      const cls = classifyFont(realName);
+      if (!cls.weight && /bold/i.test(s.fontFamily || "")) cls.weight = "bold";
+      if (!cls.style && /italic|oblique/i.test(s.fontFamily || "")) cls.style = "italic";
+      fontMap.set(k, cls);
+    }
+    const runs = [];
+    const safeNum = (v, fallback) => {
+      const n = typeof v === "number" ? v : Number(v);
+      return Number.isFinite(n) ? n : fallback;
+    };
+    items.forEach((it, idx) => {
+      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);
+      const baseY = safeNum(tr?.[5], 0);
+      const conv = viewport.convertToViewportPoint(baseX, baseY);
+      const vx = safeNum(conv?.[0], 0);
+      const vy = safeNum(conv?.[1], 0);
+      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),
+        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)
+      });
+    });
+    runs.sort((a, b) => a.y - b.y || a.x - b.x);
+    const lines = [];
+    const Y_TOL = 0.6;
+    for (const r of runs) {
+      if (!r.text.length) continue;
+      const last = lines[lines.length - 1];
+      if (!last) {
+        lines.push({ ...r });
+        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;
+      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);
+      } else {
+        lines.push({ ...r });
+      }
+    }
+    const elements = [];
+    for (const sh of ops.shapes) {
+      if (sh.width < 0.3 && sh.height < 0.3) continue;
+      const shapeType = sh.kind;
+      const shape = {
+        type: "shape",
+        shape: shapeType,
+        position: { x: Math.round(sh.x * 100) / 100, y: Math.round(sh.y * 100) / 100 },
+        width: Math.max(0.1, Math.round(sh.width * 100) / 100),
+        height: Math.max(0.1, Math.round(sh.height * 100) / 100)
+      };
+      if (sh.fill) shape.fill = sh.fill;
+      if (sh.stroke) shape.stroke = { color: sh.stroke, width: sh.strokeWidth || 0.3 };
+      if (shapeType === "path" && sh.path) shape.path = sh.path;
+      if (sh.opacity != null && sh.opacity < 0.999) {
+        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);
+      if (!resourceKey) {
+        resourceKey = `img${imgCounter++}`;
+        resourceKeyByName.set(pos.name, resourceKey);
+        const base64 = dataUrl.replace(/^data:image\/[a-zA-Z+]+;base64,/, "");
+        imageResources[resourceKey] = {
+          src: "embedded",
+          mimeType: "image/png",
+          data: base64
+        };
+      }
+      elements.push({
+        type: "image",
+        resource: resourceKey,
+        position: { x: Math.round(pos.x * 100) / 100, y: Math.round(pos.y * 100) / 100 },
+        width: Math.max(1, Math.round(pos.w * 100) / 100),
+        height: Math.max(1, Math.round(pos.h * 100) / 100),
+        fit: "fill"
+      });
+    }
+    for (const l of lines) {
+      const cls = fontMap.get(l.fontName) || classifyFont(l.fontName || "");
+      const style = {
+        fontSize: Math.round(l.fontSize * 10) / 10,
+        fontFamily: cls.family
+      };
+      if (cls.weight === "bold") style.fontWeight = "bold";
+      if (cls.style === "italic") style.fontStyle = "italic";
+      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 remaining = Math.max(measured, pageWmm - l.x);
+      const elWidth = Math.min(measured, remaining);
+      const text = {
+        type: "text",
+        content: l.text,
+        position: { x: Math.max(0, Math.round(l.x * 100) / 100), y: Math.max(0, Math.round(l.y * 100) / 100) },
+        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 (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}` };
+      }
+      elements.push(text);
+    }
+    for (const w of formWidgets) {
+      if (w.pushButton) continue;
+      const baseEl = {
+        name: w.fieldName,
+        position: { x: Math.max(0, Math.round(w.rectMm.x * 100) / 100), y: Math.max(0, Math.round(w.rectMm.y * 100) / 100) },
+        width: Math.max(2, Math.round(w.rectMm.w * 100) / 100),
+        height: Math.max(2, Math.round(w.rectMm.h * 100) / 100)
+      };
+      if (w.readonly) baseEl.readonly = true;
+      if (w.required) baseEl.required = true;
+      if (w.fieldType === "Tx") {
+        if (w.multiLine) {
+          elements.push({ type: "textarea", ...baseEl, value: typeof w.fieldValue === "string" ? w.fieldValue : "" });
+        } else {
+          elements.push({ type: "input", ...baseEl, inputType: "text", value: typeof w.fieldValue === "string" ? w.fieldValue : "" });
+        }
+      } else if (w.fieldType === "Btn" && !w.radio) {
+        const checked = w.fieldValue !== "Off" && !!w.fieldValue;
+        elements.push({ type: "checkbox", ...baseEl, checked });
+      } else if (w.fieldType === "Ch") {
+        const value = typeof w.fieldValue === "string" ? w.fieldValue : "";
+        const values = Array.isArray(w.fieldValue) ? w.fieldValue : void 0;
+        const opts = w.options.length > 0 ? w.options : value ? [{ value }] : [];
+        if (w.multiSelect) {
+          elements.push({ type: "select", ...baseEl, options: opts, multiple: true, values: values ?? (value ? [value] : []) });
+        } else {
+          elements.push({ type: "select", ...baseEl, options: opts, value });
+        }
+      } else if (w.fieldType === "Sig") {
+        elements.push({ type: "signature", ...baseEl, value: "" });
+      }
+    }
+    pages.push({
+      id: `page-${pi}`,
+      pageSize: { width: Math.round(pageW * PT_TO_MM * 100) / 100, height: Math.round(pageH * PT_TO_MM * 100) / 100 },
+      margins: { top: 0, right: 0, bottom: 0, left: 0 },
+      elements
+    });
+  }
+  const result = {
+    $jdf: "1.0.0",
+    meta: {
+      title,
+      pageSize: pages[0]?.pageSize || "A4",
+      unit: "mm",
+      margins: { top: 0, right: 0, bottom: 0, left: 0 }
+    },
+    pages
+  };
+  if (Object.keys(imageResources).length > 0) {
+    result.resources = { images: imageResources };
+  }
+  return result;
+}
+
+// ../../packages/jdf-pdf-import/src/node.ts
+var pdfjsModule = null;
+var pdfjsLoadPromise = 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);
+    };
+    let lib;
+    try {
+      lib = await import('pdfjs-dist/build/pdf.mjs');
+    } finally {
+      console.warn = origWarn;
+    }
+    const workerPath = require_.resolve("pdfjs-dist/build/pdf.worker.mjs");
+    if (lib.GlobalWorkerOptions) {
+      lib.GlobalWorkerOptions.workerSrc = workerPath;
+    }
+    pdfjsModule = lib;
+    return lib;
+  })();
+  return pdfjsLoadPromise;
+}
+var canvasModule = null;
+async function loadCanvas() {
+  if (canvasModule) return canvasModule;
+  try {
+    canvasModule = await import('@napi-rs/canvas');
+    return canvasModule;
+  } catch (err) {
+    throw new Error(
+      "[@jdf/pdf-import/node] @napi-rs/canvas is required for the node entry point. Install it: pnpm add @napi-rs/canvas"
+    );
+  }
+}
+function makeNodeEncoder(canvasMod) {
+  return function encodePngNode(width, height, kind, data) {
+    const canvas = canvasMod.createCanvas(width, height);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return null;
+    const imgData = ctx.createImageData(width, height);
+    const buf = imgData.data;
+    if (kind === 3) {
+      for (let i = 0; i < data.length && i < buf.length; i++) buf[i] = data[i];
+    } else if (kind === 2) {
+      for (let i = 0, j = 0; i < data.length; i += 3, j += 4) {
+        buf[j] = data[i];
+        buf[j + 1] = data[i + 1];
+        buf[j + 2] = data[i + 2];
+        buf[j + 3] = 255;
+      }
+    } else if (kind === 1) {
+      for (let i = 0, j = 0; i < width * height; i++, j += 4) {
+        const byte = data[i >> 3];
+        const bit = byte >> 7 - (i & 7) & 1;
+        const v = bit ? 255 : 0;
+        buf[j] = v;
+        buf[j + 1] = v;
+        buf[j + 2] = v;
+        buf[j + 3] = 255;
+      }
+    } else {
+      for (let i = 0; i < data.length && i < buf.length; i++) buf[i] = data[i];
+    }
+    ctx.putImageData(imgData, 0, 0);
+    try {
+      const png = canvas.toBuffer("image/png");
+      return `data:image/png;base64,${png.toString("base64")}`;
+    } catch {
+      return null;
+    }
+  };
+}
+async function importPdfToJdf2(source, title, options = {}) {
+  const pdfjs = options.pdfjs || await loadNodePdfJs();
+  const canvasMod = await loadCanvas();
+  const runtime = {
+    pdfjs,
+    disableWorker: true,
+    createCanvas(width, height) {
+      const canvas = canvasMod.createCanvas(width, height);
+      const context = canvas.getContext("2d");
+      return { canvas, context };
+    },
+    encodePng: makeNodeEncoder(canvasMod),
+    async readFile(filePath) {
+      const buf = await readFile(filePath);
+      return new Uint8Array(buf);
+    }
+  };
+  return importPdfToJdf(source, title, runtime, options);
+}
+
 // src/commands/import-pdf.ts
-async function importPdfPlaceholder(_inputPath, _outputPath) {
-  console.error("PDF import via CLI is not yet wired up \u2014 run the JDF Reader app and use Open / drag-drop, which uses the Rust pdf-extract pipeline.");
-  console.error("Track progress at: https://github.com/uurtech/jdf");
-  process.exit(2);
+async function importPdf(inputPath, outputPath, options = {}) {
+  const input = path2.resolve(inputPath);
+  if (!fs.existsSync(input)) {
+    console.error(`File not found: ${input}`);
+    process.exit(1);
+  }
+  console.log(`Importing: ${input}`);
+  const title = path2.basename(input, path2.extname(input));
+  const t0 = Date.now();
+  const doc = await importPdfToJdf2(input, title);
+  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);
+  } else {
+    const stem = input.replace(/\.pdf$/i, "");
+    const wantJdfx = !options.forceJson && shouldUseJdfx(doc);
+    output = stem + (wantJdfx ? ".jdfx" : ".jdf");
+  }
+  console.log(`Output:    ${output}`);
+  if (output.toLowerCase().endsWith(".jdfx")) {
+    const { bytes, manifest } = await packJdfx(doc);
+    fs.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));
+    console.log(`
+Done! Created ${doc.pages.length} page(s)`);
+  }
+  console.log(`Open with: open -a "JDF Reader" "${output}"`);
+}
+var ImportJsonError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ImportJsonError";
+  }
+};
+async function importJson(inputPath, outputPath, options = {}) {
+  const input = path2.resolve(inputPath);
+  if (!fs.existsSync(input)) {
+    throw new ImportJsonError(`File not found: ${input}`);
+  }
+  console.log(`Importing: ${input}`);
+  const raw = fs.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 doc = normaliseToJdf(parsed, title);
+  let output;
+  if (outputPath) {
+    output = path2.resolve(outputPath);
+  } else {
+    const stem = input.replace(/\.json$/i, "");
+    const wantJdfx = !options.forceJson && shouldUseJdfx(doc);
+    output = stem + (wantJdfx ? ".jdfx" : ".jdf");
+  }
+  console.log(`Output:    ${output}`);
+  if (output.toLowerCase().endsWith(".jdfx")) {
+    const { bytes, manifest } = await packJdfx(doc);
+    fs.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));
+    console.log(`
+Done! Created ${doc.pages.length} page(s)`);
+  }
+  if (!options.skipValidate) {
+    console.log("");
+    const ok = await validate(output);
+    if (!ok) throw new ImportJsonError(`Schema validation failed for ${output}`);
+  }
+  console.log(`Open with: open -a "JDF Reader" "${output}"`);
+}
+function normaliseToJdf(input, title) {
+  if (input && typeof input === "object" && typeof input.$jdf === "string" && Array.isArray(input.pages)) {
+    if (input.pages.length === 0) {
+      throw new ImportJsonError("JDF document has zero pages \u2014 `pages` must contain at least one page");
+    }
+    const meta = input.meta && typeof input.meta === "object" ? { title: input.meta.title ?? title, pageSize: "A4", unit: "mm", ...input.meta } : { title, pageSize: "A4", unit: "mm" };
+    return {
+      $jdf: input.$jdf,
+      meta,
+      ...input.styles ? { styles: input.styles } : {},
+      ...input.resources ? { resources: input.resources } : {},
+      ...input.header ? { header: input.header } : {},
+      ...input.footer ? { footer: input.footer } : {},
+      pages: input.pages
+    };
+  }
+  if (Array.isArray(input)) {
+    if (input.length === 0) {
+      throw new ImportJsonError("Element array is empty \u2014 wrap at least one element");
+    }
+    return wrapElements(input, title);
+  }
+  if (input && typeof input === "object") {
+    if (Array.isArray(input.pages)) {
+      if (input.pages.length === 0) {
+        throw new ImportJsonError("`pages` is empty \u2014 provide at least one page");
+      }
+      return {
+        $jdf: input.$jdf || "1.0.0",
+        meta: { title, pageSize: "A4", unit: "mm", ...input.meta || {} },
+        ...input.styles ? { styles: input.styles } : {},
+        ...input.resources ? { resources: input.resources } : {},
+        ...input.header ? { header: input.header } : {},
+        ...input.footer ? { footer: input.footer } : {},
+        pages: input.pages
+      };
+    }
+    if (Array.isArray(input.elements)) {
+      if (input.elements.length === 0) {
+        throw new ImportJsonError("`elements` is empty \u2014 provide at least one element");
+      }
+      return wrapElements(input.elements, title, input.meta);
+    }
+  }
+  throw new ImportJsonError(
+    "Unrecognised JSON shape \u2014 expected a JDF document, an element array, or { pages: [...] } / { elements: [...] }"
+  );
+}
+function wrapElements(elements, title, meta) {
+  return {
+    $jdf: "1.0.0",
+    meta: {
+      title,
+      pageSize: "A4",
+      unit: "mm",
+      ...meta || {}
+    },
+    pages: [
+      {
+        id: "page-1",
+        elements
+      }
+    ]
+  };
 }
 
 // src/index.ts
 var HELP = `jdf \u2014 JSON Document Format CLI
 
+The CLI exists for two workflows:
+  \u2022 PDF \u2192 JDF        legacy documents become a structured JSON tree your
+                     RAG / agent / pipeline can read natively.
+  \u2022 JSON \u2192 JDF       LLMs and code emit JSON; this command wraps that JSON
+                     into a validated .jdf (or .jdfx) you can ship.
+
 Usage:
   jdf validate <file.jdf>
-  jdf import <file.{md,pdf}> [-o output.jdf]
+  jdf import <file.{pdf,json,md}> [-o output.{jdf,jdfx}] [--json]
   jdf --help
 
 Commands:
-  validate   Validate a .jdf file against the JDF schema
-  import     Convert a markdown or PDF file to JDF
+  validate   Validate a .jdf / .jdfx file against the JDF schema
+  import     Convert a PDF, JSON, or Markdown file into JDF
+
+Flags:
+  -o, --output <path>   Explicit output path (extension picks .jdf vs .jdfx)
+      --json            Force pure JSON .jdf output (documents with embedded
+                        images stay as a single base64-inlined .jdf instead
+                        of a .jdfx bundle). Useful for RAG / CI consumers
+                        that prefer one text file over a zip.
 
 Examples:
   jdf validate spec/examples/hello-world.jdf
+  jdf import paper.pdf                        # PDF \u2192 JDF (or .jdfx for images)
+  jdf import contract.pdf --json | jq .       # PDF \u2192 pure JSON, pipe-friendly
+  jdf import response.json -o response.jdf    # LLM JSON output \u2192 validated JDF
   jdf import README.md
-  jdf import paper.pdf -o paper.jdf
 `;
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["help", "h", "json", "verbose", "skip-validate"]);
 function parseArgs(argv) {
   const positional = [];
   const flags = {};
@@ -448,7 +1492,17 @@ function parseArgs(argv) {
       continue;
     }
     if (a.startsWith("--")) {
-      const k = a.slice(2);
+      const eq = a.indexOf("=");
+      const k = eq > 0 ? a.slice(2, eq) : a.slice(2);
+      const inlineVal = eq > 0 ? a.slice(eq + 1) : void 0;
+      if (inlineVal !== void 0) {
+        flags[k] = inlineVal;
+        continue;
+      }
+      if (BOOLEAN_FLAGS.has(k)) {
+        flags[k] = true;
+        continue;
+      }
       const next = argv[i + 1];
       if (next && !next.startsWith("-")) {
         flags[k] = next;
@@ -458,10 +1512,12 @@ function parseArgs(argv) {
     }
     if (a === "-o" || a === "--output") {
       const next = argv[i + 1];
-      if (next) {
-        flags["output"] = next;
-        i++;
+      if (next === void 0 || next.startsWith("-")) {
+        console.error(`Error: ${a} requires a path argument`);
+        process.exit(1);
       }
+      flags["output"] = next;
+      i++;
       continue;
     }
     positional.push(a);
@@ -487,20 +1543,25 @@ async function main() {
       case "import": {
         const input = positional[0];
         if (!input) {
-          console.error("Usage: jdf import <file.{md,pdf}> [-o output.jdf]");
+          console.error("Usage: jdf import <file.{pdf,json,md}> [-o output.jdf] [--json]");
           process.exit(1);
         }
         const output = typeof flags.output === "string" ? flags.output : void 0;
+        const forceJson = flags.json === true;
         const lower = input.toLowerCase();
         if (lower.endsWith(".md") || lower.endsWith(".markdown")) {
           await importMarkdown(input, output);
+          process.exit(0);
         } else if (lower.endsWith(".pdf")) {
-          await importPdfPlaceholder(input, output);
+          await importPdf(input, output, { forceJson });
+          process.exit(0);
+        } else if (lower.endsWith(".json")) {
+          await importJson(input, output, { forceJson });
+          process.exit(0);
         } else {
           console.error(`Unsupported file type: ${input}`);
           process.exit(1);
         }
-        break;
       }
       default:
         console.error(`Unknown command: ${command}`);
@@ -508,7 +1569,11 @@ async function main() {
         process.exit(1);
     }
   } catch (e) {
-    console.error(`Error: ${e.message || e}`);
+    if (e?.name === "ImportJsonError") {
+      console.error(`\u2717 ${e.message}`);
+    } else {
+      console.error(`Error: ${e?.message || e}`);
+    }
     process.exit(1);
   }
 }