aldus-pdf 0.3.0

package/dist/index.js

@@ -0,0 +1,4016 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../core/src/model.ts
+var FIELD_DEFAULT_SIZE;
+var init_model = __esm({
+  "../core/src/model.ts"() {
+    FIELD_DEFAULT_SIZE = {
+      text: { width: 160, height: 20 },
+      checkbox: { width: 14, height: 14 },
+      radio: { width: 14, height: 14 },
+      select: { width: 140, height: 20 },
+      list: { width: 140, height: 60 },
+      button: { width: 90, height: 24 },
+      signature: { width: 200, height: 50 }
+    };
+  }
+});
+
+// ../core/src/tokens.ts
+function avgCharWidth(run) {
+  const w = run.width / Math.max(1, run.text.length);
+  return Math.max(w, run.fontSize * 0.2);
+}
+function classifyGap(gap, prev, next) {
+  if (gap <= 0) return "none";
+  const ref = (avgCharWidth(prev) + avgCharWidth(next)) / 2;
+  if (gap > 2 * ref) return "column";
+  if (gap > 0.5 * ref) return "space";
+  return "none";
+}
+function splitSegments(runsSorted) {
+  const segments = [];
+  let current = [];
+  for (const run of runsSorted) {
+    if (current.length === 0) {
+      current.push(run);
+      continue;
+    }
+    const prev = current[current.length - 1];
+    const gap = run.x - (prev.x + prev.width);
+    if (classifyGap(gap, prev, run) === "column") {
+      segments.push(current);
+      current = [run];
+    } else {
+      current.push(run);
+    }
+  }
+  if (current.length) segments.push(current);
+  return segments;
+}
+function segmentText(runsSorted) {
+  let text = "";
+  for (let i = 0; i < runsSorted.length; i++) {
+    const run = runsSorted[i];
+    if (i > 0) {
+      const prev = runsSorted[i - 1];
+      const gap = run.x - (prev.x + prev.width);
+      if (classifyGap(gap, prev, run) === "space" && !text.endsWith(" ") && !run.text.startsWith(" ")) {
+        text += " ";
+      }
+    }
+    text += run.text;
+  }
+  return text;
+}
+var init_tokens = __esm({
+  "../core/src/tokens.ts"() {
+  }
+});
+
+// ../core/src/extractGraph.ts
+function mergeBlockSegments(lines) {
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.segments.length !== 1) {
+      out.push(...line.segments);
+      i++;
+      continue;
+    }
+    const chain = [line.segments[0]];
+    let j = i + 1;
+    while (j < lines.length) {
+      const prev = chain[chain.length - 1];
+      const next = lines[j].segments.length === 1 ? lines[j].segments[0] : null;
+      if (!next) break;
+      const step = prev.baseline - next.baseline;
+      const lead = prev.fontSize * 1.2;
+      const match = Math.abs(next.x - prev.x) <= 0.5 && Math.abs(next.fontSize - prev.fontSize) <= 0.1 && Math.abs(step - lead) <= prev.fontSize * 0.06;
+      if (!match) break;
+      chain.push(next);
+      j++;
+    }
+    if (chain.length === 1) {
+      out.push(chain[0]);
+    } else {
+      const first = chain[0];
+      const last = chain[chain.length - 1];
+      out.push({
+        ...first,
+        text: chain.map((s) => s.text).join("\n"),
+        runs: chain.flatMap((s) => s.runs),
+        width: Math.max(...chain.map((s) => s.width)),
+        y: last.y,
+        height: first.y + first.height - last.y
+      });
+    }
+    i = j;
+  }
+  return out;
+}
+function extractLinks(annots, page, x0, y0) {
+  const out = [];
+  for (const raw of annots) {
+    if (raw?.subtype !== "Link" || !Array.isArray(raw.rect)) continue;
+    const url = raw.url ?? raw.unsafeUrl;
+    if (!url) continue;
+    const [ax, ay, bx, by] = raw.rect;
+    out.push({
+      id: `p${page}-link${out.length}`,
+      kind: "link",
+      page,
+      url,
+      x: Math.min(ax, bx) - x0,
+      y: Math.min(ay, by) - y0,
+      width: Math.abs(bx - ax),
+      height: Math.abs(by - ay)
+    });
+  }
+  return out;
+}
+function extractHighlights(annots, page, x0, y0) {
+  const out = [];
+  const hx = (v) => Math.max(0, Math.min(255, Math.round(v <= 1 ? v * 255 : v))).toString(16).padStart(2, "0");
+  for (const raw of annots) {
+    if (raw?.subtype !== "Highlight" || !Array.isArray(raw.rect)) continue;
+    const [ax, ay, bx, by] = raw.rect;
+    const c = raw.color && raw.color.length >= 3 ? raw.color : null;
+    out.push({
+      id: `p${page}-hl${out.length}`,
+      kind: "highlight",
+      page,
+      x: Math.min(ax, bx) - x0,
+      y: Math.min(ay, by) - y0,
+      width: Math.abs(bx - ax),
+      height: Math.abs(by - ay),
+      color: c ? `#${hx(c[0])}${hx(c[1])}${hx(c[2])}` : "#ffd400"
+    });
+  }
+  return out;
+}
+function widgetKindOf(a2) {
+  if (a2.fieldType === "Tx") return "text";
+  if (a2.fieldType === "Sig") return "signature";
+  if (a2.fieldType === "Ch") return a2.combo ? "select" : "list";
+  if (a2.fieldType === "Btn") return a2.checkBox ? "checkbox" : a2.radioButton ? "radio" : "button";
+  return "text";
+}
+function extractWidgets(annots, page, x0, y0) {
+  const out = [];
+  for (const raw of annots) {
+    if (raw?.subtype !== "Widget" || !Array.isArray(raw.rect) || raw.hidden) continue;
+    const [ax, ay, bx, by] = raw.rect;
+    const kind = widgetKindOf(raw);
+    out.push({
+      id: `p${page}-w${out.length}`,
+      kind: "widget",
+      page,
+      fieldName: raw.fieldName ?? "",
+      widgetType: kind,
+      readOnly: raw.readOnly === true,
+      options: (kind === "select" || kind === "list") && Array.isArray(raw.options) ? raw.options.map((o) => o.displayValue || o.exportValue || "").filter(Boolean) : void 0,
+      // Valor actual (/V). pdf.js entrega '' para vacío y 'Off' para un
+      // checkbox/radio sin marcar → los normalizamos a "ausente".
+      value: (() => {
+        const v = raw.fieldValue;
+        if (Array.isArray(v)) return v.length ? v : void 0;
+        if (typeof v === "string" && v && v !== "Off") return v;
+        return void 0;
+      })(),
+      x: Math.min(ax, bx) - x0,
+      y: Math.min(ay, by) - y0,
+      width: Math.abs(bx - ax),
+      height: Math.abs(by - ay)
+    });
+  }
+  return out;
+}
+function extractImages(fnArray, argsArray, page, x0, y0) {
+  const images = [];
+  let ctm = [1, 0, 0, 1, 0, 0];
+  const stack = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (let i = 0; i < fnArray.length; i++) {
+    const fn = fnArray[i];
+    if (fn === OP_SAVE) stack.push(ctm);
+    else if (fn === OP_RESTORE) ctm = stack.pop() ?? [1, 0, 0, 1, 0, 0];
+    else if (fn === OP_TRANSFORM) {
+      const a2 = argsArray[i];
+      ctm = mulMat([a2[0], a2[1], a2[2], a2[3], a2[4], a2[5]], ctm);
+    } else if (PAINT_OPS.has(fn)) {
+      const [a2, b, c, d, e, f] = ctm;
+      const xs = [e, a2 + e, c + e, a2 + c + e];
+      const ys = [f, b + f, d + f, b + d + f];
+      const minX = Math.min(...xs);
+      const minY = Math.min(...ys);
+      const arg0 = argsArray[i][0];
+      const objId = (fn === OP_PAINT_IMAGE || fn === OP_PAINT_IMAGE_REPEAT) && typeof arg0 === "string" ? arg0 : void 0;
+      let id;
+      if (objId) {
+        const n = seen.get(objId) ?? 0;
+        seen.set(objId, n + 1);
+        id = n === 0 ? `p${page}-${objId}` : `p${page}-${objId}#${n}`;
+      } else {
+        id = `p${page}-img${images.length}`;
+      }
+      images.push({
+        id,
+        kind: "image",
+        page,
+        x: minX - x0,
+        y: minY - y0,
+        width: Math.max(...xs) - minX,
+        height: Math.max(...ys) - minY,
+        rotated: Math.abs(b) > 0.01 || Math.abs(c) > 0.01,
+        objId
+      });
+    }
+  }
+  return images;
+}
+function styleFromName(name) {
+  const n = name.toLowerCase();
+  const bold = /bold|black|heavy|semibold|demibold|extrabold|-bd\b|,bd\b/.test(n);
+  const italic = /italic|oblique/.test(n);
+  const bucket = /(mono|courier|consol|menlo|typewriter|fixed)/.test(n) ? "mono" : /(times|georgia|garamond|serif|roman|minion|antiqua|palatino|cambria|bodoni)/.test(n) ? "serif" : "sans";
+  return { bold, italic, bucket };
+}
+function fontInfoFor(page, loadedName, cache) {
+  const hit = cache.get(loadedName);
+  if (hit) return hit;
+  let raw = null;
+  try {
+    raw = page.commonObjs.get(loadedName);
+  } catch {
+    raw = null;
+  }
+  const ps = raw?.name || raw?.fallbackName || loadedName;
+  const style = styleFromName(ps);
+  const info = {
+    loadedName,
+    postScriptName: ps,
+    bold: raw?.bold ?? style.bold,
+    italic: raw?.italic ?? style.italic,
+    bucket: style.bucket,
+    ascent: typeof raw?.ascent === "number" && raw.ascent > 0 ? raw.ascent : 0.8,
+    descent: typeof raw?.descent === "number" && raw.descent < 0 ? raw.descent : -0.2,
+    embedded: raw != null && raw.missingFile !== true
+  };
+  cache.set(loadedName, info);
+  return info;
+}
+async function extractPageGraph(page) {
+  const opList = await page.getOperatorList();
+  const tc = await page.getTextContent({ disableNormalization: true });
+  const annots = await page.getAnnotations().catch(() => []);
+  const [x0, y0, x1, y1] = page.view;
+  const fontCache = /* @__PURE__ */ new Map();
+  const runs = [];
+  let i = 0;
+  for (const item of tc.items) {
+    if (typeof item.str !== "string" || item.str.trim().length === 0) continue;
+    const [a2, b, c, d, e, f] = item.transform;
+    runs.push({
+      id: `p${page.pageNumber}-r${i++}`,
+      kind: "text",
+      page: page.pageNumber,
+      text: item.str,
+      x: e - x0,
+      baseline: f - y0,
+      width: item.width,
+      fontSize: Math.hypot(c, d),
+      angle: Math.atan2(b, a2),
+      font: fontInfoFor(page, item.fontName, fontCache)
+    });
+  }
+  const lines = groupIntoLines(runs, page.pageNumber);
+  return {
+    page: page.pageNumber,
+    width: x1 - x0,
+    height: y1 - y0,
+    runs,
+    lines,
+    segments: mergeBlockSegments(lines),
+    images: extractImages(opList.fnArray, opList.argsArray, page.pageNumber, x0, y0),
+    widgets: extractWidgets(annots, page.pageNumber, x0, y0),
+    links: extractLinks(annots, page.pageNumber, x0, y0),
+    highlights: extractHighlights(annots, page.pageNumber, x0, y0)
+  };
+}
+function groupIntoLines(runs, page) {
+  const horizontal = runs.filter((r2) => Math.abs(r2.angle) < 0.01);
+  const rotated = runs.filter((r2) => Math.abs(r2.angle) >= 0.01);
+  const sorted = [...horizontal].sort((p, q) => q.baseline - p.baseline || p.x - q.x);
+  const groups = [];
+  for (const r2 of sorted) {
+    const current = groups[groups.length - 1];
+    const tol = Math.max(1, r2.fontSize * 0.35);
+    if (current && Math.abs(current[0].baseline - r2.baseline) <= tol) current.push(r2);
+    else groups.push([r2]);
+  }
+  for (const r2 of rotated) groups.push([r2]);
+  return groups.map((g, i) => lineFromRuns(g, page, i));
+}
+function bboxOf(runs) {
+  const x = runs[0].x;
+  const right = Math.max(...runs.map((r2) => r2.x + r2.width));
+  const baseline = runs[0].baseline;
+  const fontSize = Math.max(...runs.map((r2) => r2.fontSize));
+  const ascent = Math.max(...runs.map((r2) => r2.font.ascent * r2.fontSize));
+  const descent = Math.min(...runs.map((r2) => r2.font.descent * r2.fontSize));
+  return { x, baseline, width: right - x, y: baseline + descent, height: ascent - descent, fontSize };
+}
+function lineFromRuns(group, page, index) {
+  const runs = [...group].sort((a2, b) => a2.x - b.x);
+  void index;
+  const lineId = `p${page}-y${Math.round(runs[0].baseline)}`;
+  const segments = splitSegments(runs).map((segRuns) => ({
+    id: `${lineId}-x${Math.round(segRuns[0].x)}`,
+    kind: "segment",
+    page,
+    text: segmentText(segRuns),
+    runs: segRuns,
+    ...bboxOf(segRuns)
+  }));
+  return {
+    id: lineId,
+    kind: "line",
+    page,
+    text: segments.map((s) => s.text).join(" "),
+    segments,
+    ...bboxOf(runs)
+  };
+}
+var OP_SAVE, OP_RESTORE, OP_TRANSFORM, OP_PAINT_IMAGE, OP_PAINT_INLINE_IMAGE, OP_PAINT_IMAGE_MASK, OP_PAINT_IMAGE_REPEAT, PAINT_OPS, mulMat;
+var init_extractGraph = __esm({
+  "../core/src/extractGraph.ts"() {
+    init_tokens();
+    OP_SAVE = 10;
+    OP_RESTORE = 11;
+    OP_TRANSFORM = 12;
+    OP_PAINT_IMAGE = 85;
+    OP_PAINT_INLINE_IMAGE = 86;
+    OP_PAINT_IMAGE_MASK = 83;
+    OP_PAINT_IMAGE_REPEAT = 88;
+    PAINT_OPS = /* @__PURE__ */ new Set([OP_PAINT_IMAGE, OP_PAINT_INLINE_IMAGE, OP_PAINT_IMAGE_MASK, OP_PAINT_IMAGE_REPEAT]);
+    mulMat = (m, n) => [
+      m[0] * n[0] + m[1] * n[2],
+      m[0] * n[1] + m[1] * n[3],
+      m[2] * n[0] + m[3] * n[2],
+      m[2] * n[1] + m[3] * n[3],
+      m[4] * n[0] + m[5] * n[2] + n[4],
+      m[4] * n[1] + m[5] * n[3] + n[5]
+    ];
+  }
+});
+
+// ../core/src/edits.ts
+function originalStyledRuns(seg) {
+  const byLine = /* @__PURE__ */ new Map();
+  for (const r2 of seg.runs) {
+    const key = Math.round(r2.baseline * 10) / 10;
+    byLine.set(key, [...byLine.get(key) ?? [], r2]);
+  }
+  const lineKeys = [...byLine.keys()].sort((a2, b) => b - a2);
+  const out = [];
+  for (let li = 0; li < lineKeys.length; li++) {
+    const runs = [...byLine.get(lineKeys[li]) ?? []].sort((a2, b) => a2.x - b.x);
+    if (li > 0 && out.length) out[out.length - 1].text += "\n";
+    for (let i = 0; i < runs.length; i++) {
+      const r2 = runs[i];
+      let space = "";
+      if (i > 0) {
+        const prev = runs[i - 1];
+        const gap = r2.x - (prev.x + prev.width);
+        if (classifyGap(gap, prev, r2) === "space" && !out[out.length - 1]?.text.endsWith(" ") && !r2.text.startsWith(" ")) {
+          space = " ";
+        }
+      }
+      const last = out[out.length - 1];
+      if (last && last.bold === r2.font.bold && last.italic === r2.font.italic && last.color === r2.color) {
+        last.text += space + r2.text;
+      } else {
+        if (last && space) last.text += space;
+        out.push({ text: r2.text, bold: r2.font.bold, italic: r2.font.italic, color: r2.color, dx: r2.x - seg.x });
+      }
+    }
+  }
+  return out;
+}
+function styledRunsEqual(a2, b) {
+  if (a2.length !== b.length) return false;
+  for (let i = 0; i < a2.length; i++) {
+    if (a2[i].text !== b[i].text || a2[i].bold !== b[i].bold || a2[i].italic !== b[i].italic || a2[i].color !== b[i].color || !!a2[i].underline !== !!b[i].underline) return false;
+  }
+  return true;
+}
+function applyTextDiff(runs, newText) {
+  const oldText = styledText(runs);
+  if (oldText === newText) return runs;
+  if (!runs.length) return newText ? [{ text: newText, bold: false, italic: false, dx: 0 }] : runs;
+  let p = 0;
+  while (p < oldText.length && p < newText.length && oldText[p] === newText[p]) p++;
+  let s = 0;
+  while (s < oldText.length - p && s < newText.length - p && oldText[oldText.length - 1 - s] === newText[newText.length - 1 - s]) s++;
+  const inserted = newText.slice(p, newText.length - s);
+  let styleSrc = runs[runs.length - 1];
+  let pos = 0;
+  for (const r2 of runs) {
+    if (p < pos + r2.text.length || p === pos + r2.text.length && r2 === runs[runs.length - 1]) {
+      styleSrc = r2;
+      break;
+    }
+    pos += r2.text.length;
+  }
+  const out = [];
+  let cursor = 0;
+  const pushPiece = (piece) => {
+    const last = out[out.length - 1];
+    if (last && sameStyle(last, piece)) last.text += piece.text;
+    else out.push({ ...piece });
+  };
+  for (const r2 of runs) {
+    if (cursor >= p) break;
+    const take = Math.min(r2.text.length, p - cursor);
+    if (take > 0) pushPiece({ ...r2, text: r2.text.slice(0, take) });
+    cursor += r2.text.length;
+  }
+  const oldMid = oldText.slice(p, oldText.length - s);
+  if (inserted && oldMid && oldMid.length * inserted.length <= 25e4) {
+    const styleAt = [];
+    for (const r2 of runs) for (let i = 0; i < r2.text.length; i++) styleAt.push(r2);
+    let match;
+    if (oldMid.length === inserted.length) {
+      match = [...inserted].map((ch, i) => oldMid[i] === ch ? i : null);
+    } else {
+      const n = oldMid.length, m2 = inserted.length;
+      const dp = Array.from({ length: n + 1 }, () => new Uint32Array(m2 + 1));
+      for (let i = n - 1; i >= 0; i--) {
+        for (let j = m2 - 1; j >= 0; j--) {
+          dp[i][j] = oldMid[i] === inserted[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
+        }
+      }
+      match = new Array(m2).fill(null);
+      for (let i = 0, j = 0; i < n && j < m2; ) {
+        if (oldMid[i] === inserted[j]) {
+          match[j] = i;
+          i++;
+          j++;
+        } else if (dp[i + 1][j] >= dp[i][j + 1]) i++;
+        else j++;
+      }
+    }
+    let inherit = styleSrc;
+    for (let j = 0; j < inserted.length; j++) {
+      const oi = match[j];
+      const st = oi != null ? styleAt[p + oi] ?? inherit : inherit;
+      if (oi != null) inherit = st;
+      pushPiece({ ...st, text: inserted[j] });
+    }
+  } else if (inserted) {
+    pushPiece({ ...styleSrc, text: inserted });
+  }
+  const sufStart = oldText.length - s;
+  cursor = 0;
+  for (const r2 of runs) {
+    const end = cursor + r2.text.length;
+    if (end > sufStart) {
+      const from = Math.max(0, sufStart - cursor);
+      pushPiece({ ...r2, text: r2.text.slice(from) });
+    }
+    cursor = end;
+  }
+  return out.filter((r2) => r2.text.length > 0);
+}
+function segmentOriginal(seg) {
+  const dom = seg.runs.reduce((a2, b) => b.width > a2.width ? b : a2);
+  const baselines = [...new Set(seg.runs.map((r2) => Math.round(r2.baseline * 10) / 10))].sort((a2, b) => b - a2);
+  return {
+    text: seg.text,
+    x: seg.x,
+    baseline: seg.baseline,
+    width: seg.width,
+    fontSize: seg.fontSize,
+    bucket: dom.font.bucket,
+    bold: dom.font.bold,
+    italic: dom.font.italic,
+    runs: [...seg.runs].sort((a2, b) => a2.x - b.x).map((r2) => ({ x: r2.x, bold: r2.font.bold, italic: r2.font.italic })),
+    ...baselines.length > 1 ? { baselines } : {}
+  };
+}
+function mergeSegmentEdit(seg, prev, patch) {
+  const next = prev ? { ...prev } : {
+    segmentId: seg.id,
+    page: seg.page,
+    text: seg.text,
+    original: segmentOriginal(seg)
+  };
+  if (patch.runs !== void 0) {
+    if (patch.runs === null) delete next.runs;
+    else next.runs = patch.runs;
+  }
+  if (patch.text !== void 0) next.text = patch.text;
+  if (next.runs) {
+    if (styledRunsEqual(next.runs, originalStyledRuns(seg))) delete next.runs;
+    else next.text = styledText(next.runs);
+  }
+  for (const key of OVERRIDE_KEYS) {
+    const value = patch[key];
+    if (value === void 0) continue;
+    if (value === null) delete next[key];
+    else next[key] = value;
+  }
+  const noop = next.text === seg.text && next.runs === void 0 && OVERRIDE_KEYS.every((k) => next[k] === void 0);
+  return noop ? null : next;
+}
+function mergeImageEdit(img, prev, patch) {
+  const next = prev ? { ...prev } : {
+    imageId: img.id,
+    page: img.page,
+    original: { x: img.x, y: img.y, width: img.width, height: img.height }
+  };
+  for (const key of IMAGE_KEYS) {
+    const value = patch[key];
+    if (value === void 0) continue;
+    if (value === null) delete next[key];
+    else next[key] = value;
+  }
+  return IMAGE_KEYS.every((k) => next[k] === void 0) ? null : next;
+}
+function promoteMovedImages(edits) {
+  return edits.map((e) => !e.remove && !e.zOrder && (e.x != null || e.y != null || e.width != null || e.height != null) ? { ...e, zOrder: "front" } : e);
+}
+function mergeWidgetEdit(w, prev, patch) {
+  const next = prev ? { ...prev } : {
+    widgetId: w.id,
+    page: w.page,
+    original: { fieldName: w.fieldName, x: w.x, y: w.y, width: w.width, height: w.height }
+  };
+  for (const key of WIDGET_KEYS) {
+    const value = patch[key];
+    if (value === void 0) continue;
+    if (value === null) delete next[key];
+    else next[key] = value;
+  }
+  return WIDGET_KEYS.every((k) => next[k] === void 0) ? null : next;
+}
+function mergeHighlightEdit(h, prev, patch) {
+  const next = prev ? { ...prev } : {
+    highlightId: h.id,
+    page: h.page,
+    original: { x: h.x, y: h.y, width: h.width, height: h.height, color: h.color }
+  };
+  for (const key of HIGHLIGHT_KEYS) {
+    const value = patch[key];
+    if (value === void 0) continue;
+    if (value === null) delete next[key];
+    else next[key] = value;
+  }
+  return HIGHLIGHT_KEYS.every((k) => next[k] === void 0) ? null : next;
+}
+function mergeLinkEdit(l, prev, patch) {
+  const next = prev ? { ...prev } : {
+    linkId: l.id,
+    page: l.page,
+    original: { url: l.url, x: l.x, y: l.y, width: l.width, height: l.height }
+  };
+  for (const key of LINK_KEYS) {
+    const value = patch[key];
+    if (value === void 0) continue;
+    if (value === null) delete next[key];
+    else next[key] = value;
+  }
+  return LINK_KEYS.every((k) => next[k] === void 0) ? null : next;
+}
+function effectiveGeometry(seg, edit) {
+  const fontSize = edit?.fontSize ?? seg.fontSize;
+  const ratio = fontSize / seg.fontSize;
+  const x = edit?.x ?? seg.x;
+  const baseline = edit?.baseline ?? seg.baseline;
+  return {
+    x,
+    baseline,
+    fontSize,
+    y: baseline + (seg.y - seg.baseline) * ratio,
+    height: seg.height * ratio,
+    width: seg.width,
+    moved: edit?.x !== void 0 || edit?.baseline !== void 0
+  };
+}
+var OVERRIDE_KEYS, styledText, sameStyle, IMAGE_KEYS, WIDGET_KEYS, HIGHLIGHT_KEYS, LINK_KEYS;
+var init_edits = __esm({
+  "../core/src/edits.ts"() {
+    init_tokens();
+    OVERRIDE_KEYS = ["fontSize", "font", "x", "baseline", "remove", "charSpacing", "hScale", "color", "align"];
+    styledText = (runs) => runs.map((r2) => r2.text).join("");
+    sameStyle = (a2, b) => a2.bold === b.bold && a2.italic === b.italic && a2.color === b.color && !!a2.underline === !!b.underline;
+    IMAGE_KEYS = ["x", "y", "width", "height", "remove", "zOrder"];
+    WIDGET_KEYS = ["x", "y", "width", "height", "remove"];
+    HIGHLIGHT_KEYS = ["x", "y", "width", "height", "color", "remove"];
+    LINK_KEYS = ["x", "y", "width", "height", "remove"];
+  }
+});
+
+// ../core/src/coords.ts
+var init_coords = __esm({
+  "../core/src/coords.ts"() {
+  }
+});
+
+// ../core/src/log.ts
+var enabled, createLogger;
+var init_log = __esm({
+  "../core/src/log.ts"() {
+    enabled = () => {
+      try {
+        if (typeof process !== "undefined" && process.env?.ALDUS_DEBUG) return true;
+      } catch {
+      }
+      try {
+        if (typeof localStorage !== "undefined" && localStorage.getItem("aldusDebug")) return true;
+      } catch {
+      }
+      return false;
+    };
+    createLogger = (namespace) => (...args) => {
+      if (enabled()) console.log(`[${namespace}]`, ...args);
+    };
+  }
+});
+
+// ../core/src/index.ts
+var init_src = __esm({
+  "../core/src/index.ts"() {
+    init_model();
+    init_extractGraph();
+    init_tokens();
+    init_edits();
+    init_coords();
+    init_log();
+  }
+});
+
+// ../agent/src/graph.ts
+import { readFile } from "node:fs/promises";
+async function graphFromBytes(bytes, path = "(memoria)") {
+  const { getDocument } = await import("pdfjs-dist/legacy/build/pdf.mjs");
+  const doc = await getDocument({ data: bytes.slice(), verbosity: 0 }).promise;
+  const pages = [];
+  for (let n = 1; n <= doc.numPages; n++) {
+    const page = await doc.getPage(n);
+    pages.push(await extractPageGraph(page));
+  }
+  await doc.destroy();
+  return { path, bytes, pages };
+}
+async function loadDoc(path) {
+  return graphFromBytes(new Uint8Array(await readFile(path)), path);
+}
+var init_graph = __esm({
+  "../agent/src/graph.ts"() {
+    init_src();
+  }
+});
+
+// ../agent/src/serialize.ts
+function styleOf(s) {
+  const run = s.runs.reduce((a2, b) => b.fontSize > a2.fontSize ? b : a2, s.runs[0]);
+  if (!run) return "";
+  const bits = [];
+  if (run.font.bold) bits.push("bold");
+  if (run.font.italic) bits.push("italic");
+  bits.push(run.font.postScriptName || run.font.bucket);
+  if (run.color) bits.push(run.color);
+  return bits.join(" ");
+}
+function nearestLabel(w, segs) {
+  const cy = w.y + w.height / 2;
+  let best = null;
+  for (const s of segs) {
+    const sy = s.baseline;
+    const dyLine = Math.abs(sy - cy);
+    const leftGap = w.x - (s.x + s.width);
+    const aboveGap = sy - (w.y + w.height);
+    let score;
+    const belowGap = w.y - sy;
+    const hOverlap = s.x < w.x + w.width && s.x + s.width > w.x - 40;
+    if (dyLine <= w.height + 6 && leftGap >= -2 && leftGap < 220) score = leftGap;
+    else if (aboveGap >= -2 && aboveGap < 26 && hOverlap) score = 300 + aboveGap;
+    else if (belowGap >= -2 && belowGap < 20 && hOverlap) score = 600 + belowGap;
+    else continue;
+    if (!best || score < best.score) best = { s, score };
+  }
+  if (!best) return void 0;
+  const t = best.s.text.replace(/\s+/g, " ").trim();
+  return t.length > 40 ? t.slice(0, 40) + "\u2026" : t;
+}
+function readingView(p) {
+  const items = [];
+  const placed = /* @__PURE__ */ new Set();
+  for (const s of p.segments) {
+    const inline = p.widgets.filter((w) => Math.abs(w.y + w.height / 2 - (s.baseline + 4)) < Math.max(12, w.height) && w.x + w.width > s.x && w.x < s.x + s.width).sort((a2, b) => a2.x - b.x);
+    const runs = [];
+    for (const m of s.text.matchAll(/_{2,}/g)) {
+      const start = m.index;
+      const end = start + m[0].length;
+      runs.push({
+        start,
+        end,
+        x0: s.x + s.width * start / s.text.length,
+        x1: s.x + s.width * end / s.text.length,
+        ids: []
+      });
+    }
+    for (const w of inline) {
+      if (!runs.length) break;
+      const cx = w.x + w.width / 2;
+      const best = runs.reduce((a2, b) => Math.abs(cx - (a2.x0 + a2.x1) / 2) <= Math.abs(cx - (b.x0 + b.x1) / 2) ? a2 : b);
+      if (cx > best.x0 - 35 && cx < best.x1 + 35) {
+        best.ids.push(w.id);
+        placed.add(w.id);
+      }
+    }
+    let text = "";
+    let cursor = 0;
+    for (const run of runs) {
+      text += s.text.slice(cursor, run.start);
+      text += run.ids.length ? run.ids.map((id) => `[[${id}]]`).join(" ") : " ";
+      cursor = run.end;
+    }
+    text += s.text.slice(cursor);
+    if (text.trim()) items.push({ x: s.x, y: s.baseline, text });
+  }
+  for (const w of p.widgets) {
+    if (!placed.has(w.id)) items.push({ x: w.x, y: w.y + w.height / 2 - 4, text: `[[${w.id}]]` });
+  }
+  items.sort((a2, b) => b.y - a2.y || a2.x - b.x);
+  const lines = [];
+  for (const it of items) {
+    const line = lines[lines.length - 1];
+    if (line && Math.abs(line[0].y - it.y) <= 8) line.push(it);
+    else lines.push([it]);
+  }
+  const out = [];
+  for (const line of lines) {
+    const txt = line.sort((a2, b) => a2.x - b.x).map((i) => i.text).join(" ").replace(/\s+/g, " ").trim();
+    if (txt) out.push(txt);
+  }
+  return out;
+}
+function serializeDoc(doc, pages) {
+  const out = [];
+  const want = pages == null ? null : new Set(Array.isArray(pages) ? pages : [pages]);
+  const list = want ? doc.pages.filter((p) => want.has(p.page)) : doc.pages;
+  for (const p of list) {
+    out.push(`## P\xE1gina ${p.page} \u2014 ${r(p.width)}\xD7${r(p.height)} pt`);
+    if (p.widgets.length) {
+      out.push("### Lectura (texto con los campos [[id]] intercalados donde caen \u2014 as\xED se entiende qu\xE9 va en cada uno)");
+      out.push(...readingView(p));
+    }
+    if (p.segments.length) {
+      out.push('### Texto  (id @(x,baseline) ancho\xD7alto tama\xF1o estilo: "contenido")');
+      out.push('  (si un nodo tiene varios tramos, "tramos:" da la x y el ancho EXACTOS de cada uno \u2014 para geometr\xEDa fina, p. ej. ubicar un placeholder dentro del nodo)');
+      const segs = [...p.segments].sort((a2, b) => b.baseline - a2.baseline || a2.x - b.x);
+      for (const s of segs) {
+        const t = s.text.replace(/\n/g, "\\n");
+        out.push(`- ${s.id} @(${r(s.x)},${r(s.baseline)}) ${r(s.width)}\xD7${r(s.height)} ${r(s.fontSize)}pt ${styleOf(s)}: ${JSON.stringify(t)}`);
+        if (s.runs.length > 1) {
+          const tr = s.runs.map((run) => `@${r(run.x)} w${r(run.width)}${run.font.bold ? " bold" : ""}${run.font.italic ? " italic" : ""} ${JSON.stringify(run.text)}`).join(" | ");
+          out.push(`    tramos: ${tr}`);
+        }
+      }
+    }
+    if (p.images.length) {
+      out.push("### Im\xE1genes  (id @(x,y) ancho\xD7alto)");
+      for (const im of p.images) {
+        out.push(`- ${im.id} @(${r(im.x)},${r(im.y)}) ${r(im.width)}\xD7${r(im.height)}`);
+      }
+    }
+    if (p.widgets.length) {
+      out.push('### Campos de formulario  (nombre tipo [valor] near "label" @(x,y) ancho\xD7alto)');
+      out.push('  (los nombres suelen ser opacos \u2192 us\xE1 "near" (el texto pegado al campo) para saber QU\xC9 va en cada uno)');
+      for (const w of p.widgets) {
+        const val = w.value != null ? ` = ${JSON.stringify(Array.isArray(w.value) ? w.value.join(", ") : w.value)}` : " (vac\xEDo)";
+        const opts = w.options?.length ? ` opciones:[${w.options.join(", ")}]` : "";
+        const label = nearestLabel(w, p.segments);
+        const near = label ? ` near ${JSON.stringify(label)}` : "";
+        out.push(`- ${w.id} ${JSON.stringify(w.fieldName)} ${w.widgetType}${val}${opts}${near} @(${r(w.x)},${r(w.y)}) ${r(w.width)}\xD7${r(w.height)}${w.readOnly ? " read-only" : ""}`);
+      }
+    }
+    if (p.highlights.length) {
+      out.push("### Resaltados  (id color @(x,y) ancho\xD7alto)");
+      for (const h of p.highlights) out.push(`- ${h.id} ${h.color} @(${r(h.x)},${r(h.y)}) ${r(h.width)}\xD7${r(h.height)}`);
+    }
+    if (p.links.length) {
+      out.push("### Links  (id \u2192 url @(x,y) ancho\xD7alto)");
+      for (const l of p.links) out.push(`- ${l.id} \u2192 ${JSON.stringify(l.url)} @(${r(l.x)},${r(l.y)}) ${r(l.width)}\xD7${r(l.height)}`);
+    }
+    out.push("");
+  }
+  return out.join("\n").trimEnd();
+}
+var r;
+var init_serialize = __esm({
+  "../agent/src/serialize.ts"() {
+    r = (n) => Math.round(n);
+  }
+});
+
+// ../agent/src/tools.ts
+import { tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+function buildToolServer(session) {
+  const ok = (t) => ({ content: [{ type: "text", text: t }] });
+  const tools = TOOL_DEFS.map(
+    (d) => tool(d.name, d.description, d.shape, async (args) => ok(await d.run(session, args)))
+  );
+  return createSdkMcpServer({ name: "aldus", version: "0.0.1", tools });
+}
+function buildRouterServer(onRoute) {
+  return createSdkMcpServer({
+    name: "aldus",
+    version: "0.0.1",
+    tools: [
+      tool("edit_document", ROUTE_DESC, ROUTE_SHAPE, async (args) => {
+        onRoute({ pages: args.pages ?? [], request: String(args.request ?? "") });
+        return { content: [{ type: "text", text: "\u2713 delegado al editor \u2014 las ediciones corren a continuaci\xF3n; no repitas la llamada." }] };
+      })
+    ]
+  });
+}
+function openaiTools() {
+  return TOOL_DEFS.map((d) => ({
+    type: "function",
+    function: { name: d.name, description: d.description, parameters: z.toJSONSchema(z.object(d.shape)) }
+  }));
+}
+function openaiRouterTool() {
+  return { type: "function", function: { name: "edit_document", description: ROUTE_DESC, parameters: z.toJSONSchema(z.object(ROUTE_SHAPE)) } };
+}
+async function runTool(session, name, args) {
+  const d = TOOL_DEFS.find((x) => x.name === name);
+  if (!d) return `\u26A0\uFE0F tool desconocida: ${name}`;
+  try {
+    return await d.run(session, args);
+  } catch (err) {
+    return `\u26A0\uFE0F ${name}: ${err instanceof Error ? err.message : "error"}`;
+  }
+}
+var FIELD_TYPES, a, TOOL_DEFS, TOOL_NAMES, ROUTE_SHAPE, ROUTE_DESC;
+var init_tools = __esm({
+  "../agent/src/tools.ts"() {
+    FIELD_TYPES = ["text", "checkbox", "radio", "select", "list", "button", "signature"];
+    a = (o) => o;
+    TOOL_DEFS = [
+      // ── texto existente ──
+      {
+        name: "edit_text",
+        description: "Reemplaza el CONTENIDO de un nodo de texto (conserva su estilo). Si el texto nuevo es M\xC1S LARGO que el rengl\xF3n, el p\xE1rrafo se reconstruye solo (reflow) \u2014 no calcules nada, escrib\xED el texto final.",
+        shape: { id: z.string().describe("id del nodo de texto, p. ej. p1-y708-x72"), text: z.string().describe("texto nuevo") },
+        run: (s, { id, text }) => s.editText(id, text)
+      },
+      {
+        name: "set_text_style",
+        description: "Pone o saca NEGRITA/IT\xC1LICA a un nodo de texto entero. Si el PDF no trae embebida esa variante de la fuente, se usa la est\xE1ndar equivalente (se reporta).",
+        shape: { id: z.string(), bold: z.boolean().optional(), italic: z.boolean().optional() },
+        run: (s, { id, bold, italic }) => s.styleText(id, { bold, italic })
+      },
+      {
+        name: "move_text",
+        description: "Mueve un nodo de texto. Coordenadas en puntos PDF: x\u2192derecha, y (baseline)\u2192arriba, origen abajo-izquierda. Omit\xED la coordenada que no cambia.",
+        shape: { id: z.string(), x: z.number().optional(), y: z.number().optional() },
+        run: (s, { id, x, y }) => s.moveText(id, x, y)
+      },
+      {
+        name: "set_text_color",
+        description: "Cambia el color de un nodo de texto (hex #rrggbb).",
+        shape: { id: z.string(), color: z.string().describe("#rrggbb") },
+        run: (s, { id, color }) => s.colorText(id, color)
+      },
+      {
+        name: "set_text_size",
+        description: "Cambia el tama\xF1o de fuente de un nodo de texto (puntos).",
+        shape: { id: z.string(), size: z.number().positive() },
+        run: (s, { id, size }) => s.resizeText(id, size)
+      },
+      {
+        name: "delete_text",
+        description: "Elimina un nodo de texto del documento.",
+        shape: { id: z.string() },
+        run: (s, { id }) => s.deleteText(id)
+      },
+      // ── imagen existente ──
+      {
+        name: "move_image",
+        description: "Mueve y/o escala una imagen. Coordenadas/tama\xF1o en puntos PDF (origen abajo-izquierda). Omit\xED lo que no cambia.",
+        shape: { id: z.string(), x: z.number().optional(), y: z.number().optional(), width: z.number().positive().optional(), height: z.number().positive().optional() },
+        run: (s, { id, x, y, width, height }) => s.moveImage(id, a({ x, y, width, height }))
+      },
+      {
+        name: "delete_image",
+        description: "Elimina una imagen del documento.",
+        shape: { id: z.string() },
+        run: (s, { id }) => s.deleteImage(id)
+      },
+      // ── resaltados (/Annots) ──
+      {
+        name: "highlight_text",
+        description: "Resalta (marcador) un nodo de texto EXISTENTE por su id. El resaltado cubre el texto y lo sigue si lo mov\xE9s. Color hex opcional (default amarillo).",
+        shape: { id: z.string().describe("id del nodo de texto a resaltar"), color: z.string().optional().describe("#rrggbb") },
+        run: (s, { id, color }) => s.highlightText(id, color)
+      },
+      {
+        name: "set_highlight_color",
+        description: "Cambia el color de un resaltado YA EXISTENTE (id de highlight del grafo, p. ej. p1-hl0). Hex #rrggbb.",
+        shape: { id: z.string(), color: z.string().describe("#rrggbb") },
+        run: (s, { id, color }) => s.recolorHighlight(id, color)
+      },
+      {
+        name: "delete_highlight",
+        description: "Elimina un resaltado existente (id de highlight del grafo).",
+        shape: { id: z.string() },
+        run: (s, { id }) => s.deleteHighlight(id)
+      },
+      // ── links (/Annots) ──
+      {
+        name: "add_link",
+        description: "Pone un LINK clickeable sobre un nodo de texto EXISTENTE (por su id) hacia una URL.",
+        shape: { id: z.string().describe("id del nodo de texto"), url: z.string().describe("URL destino") },
+        run: (s, { id, url }) => s.linkText(id, url)
+      },
+      {
+        name: "delete_link",
+        description: "Elimina un link existente (id de link del grafo, p. ej. p1-link0).",
+        shape: { id: z.string() },
+        run: (s, { id }) => s.deleteLink(id)
+      },
+      // ── creación de contenido nuevo ──
+      {
+        name: "add_text",
+        description: "Agrega un p\xE1rrafo de texto NUEVO. (x,y) = esquina superior-izquierda en puntos PDF (origen abajo-izq). Si la posici\xF3n pisa texto existente, BAJA sola hasta un hueco libre (se reporta). Se re-extrae como un nodo editable.",
+        shape: {
+          page: z.number().int().min(1),
+          x: z.number(),
+          y: z.number(),
+          text: z.string(),
+          size: z.number().positive().optional(),
+          bold: z.boolean().optional(),
+          italic: z.boolean().optional(),
+          color: z.string().optional().describe("#rrggbb")
+        },
+        run: (s, { page, x, y, text, size, bold, italic, color }) => s.addTextNode(a({ page, x, y, text, size, bold, italic, color }))
+      },
+      {
+        name: "insert_image",
+        description: "Inserta una imagen (PNG/JPEG) desde una RUTA de archivo local. (x,y) = esquina superior-izquierda en puntos PDF.",
+        shape: { page: z.number().int().min(1), x: z.number(), y: z.number(), path: z.string().describe("ruta a un .png/.jpg local"), maxWidth: z.number().positive().optional() },
+        run: (s, { page, x, y, path, maxWidth }) => s.insertImageFile(page, x, y, path, maxWidth)
+      },
+      {
+        name: "add_watermark",
+        description: "Marca de agua de texto diagonal en TODAS las p\xE1ginas.",
+        shape: { text: z.string(), color: z.string().optional().describe("#rrggbb"), opacity: z.number().min(0).max(1).optional() },
+        run: (s, { text, color, opacity }) => s.watermark(text, color, opacity)
+      },
+      {
+        name: "add_header_footer",
+        description: "Agrega encabezado y/o pie de p\xE1gina (texto) y opcionalmente n\xFAmeros de p\xE1gina, en todas las p\xE1ginas.",
+        shape: { header: z.string().optional(), footer: z.string().optional(), pageNumbers: z.boolean().optional() },
+        run: (s, { header, footer, pageNumbers }) => s.headerFooter(a({ header, footer, pageNumbers }))
+      },
+      {
+        name: "add_form_field",
+        description: "Crea un campo de formulario nuevo (text/checkbox/radio/select/list/button/signature). (x,y) = esquina inferior-izquierda en puntos PDF.",
+        shape: {
+          type: z.enum(FIELD_TYPES),
+          page: z.number().int().min(1),
+          x: z.number(),
+          y: z.number(),
+          width: z.number().positive().optional(),
+          height: z.number().positive().optional(),
+          name: z.string().optional()
+        },
+        run: (s, { type, page, x, y, width, height, name }) => s.addField(type, page, x, y, width, height, name)
+      },
+      {
+        name: "placeholders_to_fields",
+        description: "Convierte placeholders (XXXX/xxx/***/____ que VOS detect\xE1s) en campos de formulario. Reconstruye el P\xC1RRAFO ENTERO de `id`: llamala UNA SOLA VEZ por p\xE1rrafo con TODOS sus placeholders (de todas las l\xEDneas) en fields[], en orden de lectura \u2014 NO una vez por l\xEDnea (rehace el reflow y se pisan). El c\xF3digo calcula la geometr\xEDa exacta y es imposible que pise texto. NO pases coordenadas; nunca edit_text+add_form_field a mano para esto.",
+        shape: {
+          id: z.string().describe("id del nodo de texto con los placeholders"),
+          fields: z.array(z.object({
+            placeholder: z.string().describe('el substring EXACTO del placeholder tal como aparece en el nodo, p. ej. "XXXXXXXXX" o "xxxxxxx"'),
+            name: z.string().describe('nombre descriptivo del campo (snake_case), p. ej. "razon_social"'),
+            width: z.number().positive().optional().describe("ancho \xDATIL deseado en puntos seg\xFAn lo que se va a escribir (nombre/direcci\xF3n ~110, DNI/RUC ~55). Opcional: si lo omit\xEDs se estima por el nombre. El campo se ensancha hasta ah\xED empujando el texto, con tope en el borde de p\xE1gina.")
+          })).min(1).describe("un item por hueco, EN ORDEN de aparici\xF3n")
+        },
+        run: (s, { id, fields }) => s.placeholdersToFields(id, fields)
+      },
+      {
+        name: "fill_field",
+        description: 'COMPLETA un campo de formulario por su fieldName O por su id de widget (el [[id]] de la Lectura, p. ej. p1-w3): texto para text/select/radio; para checkbox pas\xE1 "true"/"false". Pod\xE9s llamarla varias veces para completar todo el form.',
+        shape: { name: z.string().describe("fieldName o id de widget (p1-w3)"), value: z.string().describe('valor (para checkbox: "true"/"false")') },
+        run: (s, { name, value }) => s.fillField(name, value === "true" ? true : value === "false" ? false : value)
+      },
+      {
+        name: "fill_fields",
+        description: 'Completa VARIOS campos DE UNA SOLA VEZ (prefer\xED esta sobre llamar fill_field N veces \u2014 es mucho m\xE1s r\xE1pido). Pas\xE1 una lista {name, value}; name = fieldName o id de widget ([[p1-w3]]); para checkbox value = "true"/"false".',
+        shape: { fields: z.array(z.object({ name: z.string(), value: z.string() })).describe("lista de campos a completar") },
+        run: (s, { fields }) => s.fillFields(
+          fields.map((f) => ({ name: f.name, value: f.value === "true" ? true : f.value === "false" ? false : f.value }))
+        )
+      },
+      {
+        name: "move_field",
+        description: "Mueve un campo de formulario EXISTENTE (id de widget del grafo). Coordenadas en puntos PDF; omit\xED lo que no cambia.",
+        shape: { id: z.string(), x: z.number().optional(), y: z.number().optional() },
+        run: (s, { id, x, y }) => s.moveField(id, x, y)
+      },
+      {
+        name: "delete_field",
+        description: "Elimina un campo de formulario existente (id de widget del grafo).",
+        shape: { id: z.string() },
+        run: (s, { id }) => s.deleteField(id)
+      }
+    ];
+    TOOL_NAMES = TOOL_DEFS.map((d) => `mcp__aldus__${d.name}`);
+    ROUTE_SHAPE = {
+      pages: z.array(z.number().int().min(1)).min(1).describe("n\xFAmeros de p\xE1gina del PDF donde van las ediciones, p. ej. [1,3,4]"),
+      request: z.string().describe("la instrucci\xF3n COMPLETA y autocontenida para el editor (inclu\xED todos los datos/valores que dio el usuario, en su idioma)")
+    };
+    ROUTE_DESC = "Deleg\xE1 TODA modificaci\xF3n del PDF (editar/mover/borrar texto, resaltar, links, im\xE1genes, watermark, encabezados, campos de formulario, completar valores) al agente EDITOR. Llamala UNA sola vez con todas las p\xE1ginas a tocar y el pedido completo.";
+  }
+});
+
+// ../agent/src/verify.ts
+function charXMap(s) {
+  const map = new Array(s.text.length + 1).fill(s.x);
+  let cursor = 0;
+  let lastEnd = s.x;
+  for (const r2 of s.runs) {
+    const at = s.text.indexOf(r2.text, cursor);
+    if (at < 0) continue;
+    for (let k = cursor; k <= at; k++) map[k] = lastEnd + (r2.x - lastEnd) * (k - cursor) / Math.max(1, at - cursor);
+    const w = r2.width / Math.max(1, r2.text.length);
+    for (let k = 0; k <= r2.text.length; k++) map[at + k] = r2.x + w * k;
+    cursor = at + r2.text.length;
+    lastEnd = r2.x + r2.width;
+  }
+  for (let k = cursor; k <= s.text.length; k++) map[k] = lastEnd;
+  return map;
+}
+function pageIssues(p) {
+  const out = [];
+  for (const w of p.widgets) {
+    for (const s of p.segments) {
+      if (s.baseline < w.y - 2 || s.baseline > w.y + Math.min(w.height, 9)) continue;
+      const map = charXMap(s);
+      let hit = "";
+      for (let i = 0; i < s.text.length; i++) {
+        if (s.text[i] === " ") continue;
+        const mid = (map[i] + map[i + 1]) / 2;
+        if (mid > w.x + 1 && mid < w.x + w.width - 1) hit += s.text[i];
+      }
+      const onlyPlaceholder = /^[_.·\-–—\s]*$/.test(hit);
+      if (hit.trim().length > 0 && !onlyPlaceholder) {
+        out.push(
+          `- el campo "${w.fieldName}" (p${p.page}, x ${Math.round(w.x)}\u2013${Math.round(w.x + w.width)}) PISA el texto ${JSON.stringify(hit.trim().slice(0, 30))} del nodo ${s.id} (que arranca en x=${Math.round(s.x)}). Arreglo: move_text ${s.id} a x=${Math.round(w.x + w.width + 6)}, o mov\xE9/achic\xE1 el campo.`
+        );
+      }
+    }
+    for (const o of p.widgets) {
+      if (o === w || w.x > o.x) continue;
+      const vov = Math.min(w.y + w.height, o.y + o.height) - Math.max(w.y, o.y);
+      if (vov < w.height * 0.5) continue;
+      const ov = Math.min(w.x + w.width, o.x + o.width) - Math.max(w.x, o.x);
+      if (ov > 2) out.push(`- los campos "${w.fieldName}" y "${o.fieldName}" (p${p.page}) se solapan ${Math.round(ov)}pt en el mismo rengl\xF3n \u2014 mov\xE9 uno con move_field.`);
+    }
+  }
+  return out;
+}
+async function overlapReport(session) {
+  const { pdf } = await session.bake();
+  const doc = await graphFromBytes(pdf.slice());
+  return doc.pages.flatMap(pageIssues);
+}
+function verifyMessage(issues) {
+  return [
+    `Verificaci\xF3n de layout del editor Aldus: horne\xE9 tus cambios y med\xED el grafo real.`,
+    `Detect\xE9 ${issues.length} solape(s) que probablemente no quer\xEDas. Cada l\xEDnea trae`,
+    `el arreglo sugerido (move_text/move_field, o delete_field + add_form_field m\xE1s`,
+    `angosto). Aplic\xE1 los que correspondan; si alguno es intencional, dejalo y segu\xED.`,
+    ...issues
+  ].join("\n");
+}
+var init_verify = __esm({
+  "../agent/src/verify.ts"() {
+    init_graph();
+  }
+});
+
+// ../agent/src/config.ts
+var provider, config;
+var init_config = __esm({
+  "../agent/src/config.ts"() {
+    provider = process.env.ALDUS_PROVIDER === "openrouter" ? "openrouter" : "subscription";
+    config = {
+      provider,
+      model: process.env.ALDUS_MODEL || "claude-sonnet-5",
+      chatModel: process.env.ALDUS_CHAT_MODEL || "claude-haiku-4-5",
+      maxTurns: Number(process.env.ALDUS_MAX_TURNS || 24),
+      openrouter: {
+        key: process.env.OPENROUTER_API_KEY || "",
+        baseUrl: (process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1").replace(/\/$/, ""),
+        // Combo recomendado (mejor calidad/costo, medido): el CHAT ve TODO el doc
+        // (input grande) → conviene el BARATO (flash-lite, $0.25/M in); el EDITOR
+        // hace el tool-calling fino → el bueno (3.5-flash). ~1.8¢/turno en un doc de
+        // 9 págs — la mitad que todo-3.5-flash, misma calidad y MÁS rápido (el
+        // chat-lite rutea en ~1.3s). Todo-lite es ~0.6¢ pero el editor se ensucia
+        // (mete tools de más, llena menos campos).
+        model: process.env.ALDUS_OPENROUTER_MODEL || "google/gemini-3.5-flash",
+        chatModel: process.env.ALDUS_OPENROUTER_CHAT_MODEL || "google/gemini-3.1-flash-lite"
+      }
+    };
+  }
+});
+
+// ../agent/src/openrouter.ts
+var openrouter_exports = {};
+__export(openrouter_exports, {
+  runTurnOpenRouter: () => runTurnOpenRouter
+});
+async function streamCompletion(model, messages, tools, agent, onEvent) {
+  const res = await fetch(`${config.openrouter.baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${config.openrouter.key}`,
+      "content-type": "application/json",
+      "http-referer": "https://bernardocastro.dev",
+      "x-title": "Aldus PDF Agent"
+    },
+    body: JSON.stringify({
+      model,
+      messages,
+      tools,
+      tool_choice: "auto",
+      stream: true,
+      // Sesgo a proveedores de alta throughput — OpenRouter a veces rutea a un
+      // backend encolado (primera llamada de minutos); esto lo evita.
+      provider: { sort: "throughput" }
+    })
+  });
+  if (!res.ok || !res.body) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`OpenRouter ${res.status}: ${body.slice(0, 300)}`);
+  }
+  let content = "";
+  const calls = [];
+  const reader = res.body.getReader();
+  const dec = new TextDecoder();
+  let buf = "";
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += dec.decode(value, { stream: true });
+    const lines = buf.split("\n");
+    buf = lines.pop() ?? "";
+    for (const line of lines) {
+      const t = line.trim();
+      if (!t.startsWith("data:")) continue;
+      const data = t.slice(5).trim();
+      if (!data || data === "[DONE]") continue;
+      let json;
+      try {
+        json = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      if (json.error) throw new Error(`OpenRouter (stream): ${json.error.message || JSON.stringify(json.error)}`);
+      const delta = json.choices?.[0]?.delta;
+      if (!delta) continue;
+      if (delta.content) {
+        content += delta.content;
+        onEvent?.({ type: "text", delta: delta.content, agent });
+      }
+      for (const tc of delta.tool_calls ?? []) {
+        const i = tc.index ?? 0;
+        calls[i] ??= { id: "", type: "function", function: { name: "", arguments: "" } };
+        if (tc.id) calls[i].id = tc.id;
+        if (tc.function?.name) calls[i].function.name += tc.function.name;
+        if (tc.function?.arguments) calls[i].function.arguments += tc.function.arguments;
+      }
+    }
+  }
+  return { content, toolCalls: calls.filter(Boolean) };
+}
+async function runTurnOpenRouter(opts) {
+  if (!config.openrouter.key) throw new Error("falta OPENROUTER_API_KEY (o un token de sesi\xF3n del llm-proxy)");
+  const t0 = Date.now();
+  log(`turno OR: "${opts.prompt.slice(0, 80)}" (chat=${config.openrouter.chatModel}, editor=${config.openrouter.model})`);
+  const chatMsgs = [
+    { role: "system", content: chatSystemPrompt(opts.doc, opts.page) },
+    { role: "user", content: opts.prompt }
+  ];
+  const r1 = await streamCompletion(config.openrouter.chatModel, chatMsgs, [openaiRouterTool()], "chat", opts.onEvent);
+  const routeCall = r1.toolCalls.find((c) => c.function.name === "edit_document");
+  if (!routeCall) {
+    log(`chat-only listo en ${Date.now() - t0}ms`);
+    return { text: r1.content, toolCalls: 0 };
+  }
+  log(`chat \u2192 edit_document (${Date.now() - t0}ms)`);
+  opts.onEvent?.({ type: "tool", name: "mcp__aldus__edit_document", agent: "chat" });
+  let route = { pages: [], request: opts.prompt };
+  try {
+    const args = JSON.parse(routeCall.function.arguments || "{}");
+    route = {
+      pages: Array.isArray(args.pages) ? args.pages.filter((n) => Number.isFinite(n)) : [],
+      request: typeof args.request === "string" && args.request ? args.request : opts.prompt
+    };
+  } catch {
+  }
+  const pages = route.pages.length ? route.pages : opts.page != null ? [opts.page] : void 0;
+  const messages = [
+    { role: "system", content: systemPrompt(opts.doc, pages) },
+    { role: "user", content: `${opts.prompt}
+
+[Plan del asistente]: ${route.request}` }
+  ];
+  let text = r1.content;
+  let toolCalls = 0;
+  const usedTools = /* @__PURE__ */ new Set();
+  let verified = false;
+  for (let turn = 0; turn < config.maxTurns; turn++) {
+    const { content, toolCalls: calls } = await streamCompletion(config.openrouter.model, messages, openaiTools(), "editor", opts.onEvent);
+    text += content;
+    if (!calls.length) {
+      const movedByHand = MANUAL_GEOMETRY.some((t) => usedTools.has(t));
+      if (movedByHand && !verified) {
+        verified = true;
+        const issues = await overlapReport(opts.session).catch(() => []);
+        if (issues.length) {
+          log(`verify: ${issues.length} issues \u2192 pasada correctiva`);
+          opts.onEvent?.({ type: "tool", name: "mcp__aldus__verify_layout", agent: "editor" });
+          messages.push({ role: "assistant", content: content || null });
+          messages.push({ role: "user", content: verifyMessage(issues) });
+          continue;
+        }
+      }
+      break;
+    }
+    messages.push({ role: "assistant", content: content || null, tool_calls: calls });
+    for (const tc of calls) {
+      toolCalls++;
+      usedTools.add(tc.function.name);
+      log(`editor tool #${toolCalls}: ${tc.function.name} (${Date.now() - t0}ms)`);
+      opts.onEvent?.({ type: "tool", name: `mcp__aldus__${tc.function.name}`, agent: "editor" });
+      let args = {};
+      try {
+        args = JSON.parse(tc.function.arguments || "{}");
+      } catch {
+      }
+      const result = await runTool(opts.session, tc.function.name, args);
+      messages.push({ role: "tool", tool_call_id: tc.id, content: result });
+    }
+  }
+  log(`turno OR listo en ${Date.now() - t0}ms (toolCalls=${toolCalls}, tools=[${[...usedTools].join(",")}])`);
+  return { text, toolCalls };
+}
+var log, MANUAL_GEOMETRY;
+var init_openrouter = __esm({
+  "../agent/src/openrouter.ts"() {
+    init_src();
+    init_config();
+    init_agent();
+    init_tools();
+    init_verify();
+    log = createLogger("aldus:openrouter");
+    MANUAL_GEOMETRY = ["move_text", "move_field", "move_image"];
+  }
+});
+
+// ../agent/src/agent.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+function systemPrompt(doc, page) {
+  const pages = doc.pages.length;
+  const scoped = page == null ? null : Array.isArray(page) ? page : [page];
+  return [
+    "Sos Aldus, un agente experto en documentos PDF. Ten\xE9s EMBEBIDO abajo el",
+    "contenido completo del documento como un grafo. Sos CONSCIENTE de TODO:",
+    "de cada nodo de texto conoc\xE9s su `id`, posici\xF3n (x, baseline), ancho\xD7alto,",
+    "tama\xF1o de fuente, negrita/it\xE1lica y familia (y color si figura); de cada",
+    "imagen, campo, resaltado y link su `id`, rect y datos. Us\xE1 esa geometr\xEDa y",
+    "ese estilo para ubicar y emparejar lo que hagas (p. ej. escribir alineado a",
+    "un label, o crear un campo del tama\xF1o justo).",
+    "",
+    "C\xF3mo trabaj\xE1s:",
+    "- PREGUNTAS sobre el contenido \u2192 respond\xE9 directo leyendo el grafo. NO hay",
+    "  tool de lectura: ya ten\xE9s todo el documento ac\xE1. Si el usuario pide los",
+    "  datos en un formato (JSON, tabla, lista), devolvelos EXACTAMENTE as\xED.",
+    "- CAMBIOS \u2192 us\xE1 las tools referenciando los `id` EXACTOS del grafo. Pod\xE9s",
+    "  encadenar varias. No inventes ids. Ten\xE9s las MISMAS capacidades que un",
+    "  humano en el editor:",
+    "  \xB7 Texto existente: edit_text (si el texto nuevo es m\xE1s largo, el p\xE1rrafo se",
+    "    reconstruye solo \u2014 no calcules nada), move_text, set_text_style (negrita/",
+    "    it\xE1lica), set_text_color, set_text_size, delete_text.",
+    "  \xB7 Imagen existente: move_image, delete_image.",
+    "  \xB7 Resaltar: highlight_text (sobre un id de texto). Sobre resaltados que ya",
+    "    existen: set_highlight_color, delete_highlight.",
+    "  \xB7 Links: add_link (sobre un id de texto \u2192 URL), delete_link.",
+    "  \xB7 Crear: add_text, insert_image (desde una ruta local), add_watermark,",
+    "    add_header_footer, add_form_field (type = text/checkbox/radio/select/",
+    "    list/button/signature \u2014 pod\xE9s poner inputs NUEVOS: firmas, radios, checks\u2026).",
+    '  \xB7 Formularios: las p\xE1ginas con campos traen una secci\xF3n "Lectura" \u2014 el',
+    "    texto en orden con cada campo [[id]] intercalado DONDE CAE. Esa lectura",
+    "    es LA fuente de verdad para saber qu\xE9 va en cada campo (le\xE9 la oraci\xF3n",
+    "    alrededor del [[id]], como un humano). Cada campo muestra su VALOR",
+    '    actual (o "(vac\xEDo)") \u2014 para "extraer"/leer un form respond\xE9 desde el',
+    "    grafo. Para COMPLETAR VARIOS campos us\xE1 fill_fields (UNA sola llamada con",
+    "    la lista {name,value}) \u2014 mucho m\xE1s r\xE1pido que fill_field N veces; us\xE1",
+    "    fill_field solo para uno. name = fieldName o el [[id]] de la Lectura.",
+    "    Campos existentes: move_field, delete_field.",
+    "    Un PDF PLANO (sin campos, con l\xEDneas/labels) se puede volver fillable:",
+    "    add_form_field en cada hueco (mir\xE1 los labels y su geometr\xEDa) y opcionalmente",
+    "    fill_field. O simplemente escribir la respuesta con add_text al lado del label.",
+    "",
+    "Coordenadas: puntos PDF, origen ABAJO-IZQUIERDA, x\u2192derecha, y\u2192arriba. Para el",
+    "texto la `y` es la baseline. El tama\xF1o de cada p\xE1gina est\xE1 en su encabezado.",
+    "Para NO perder contenido, no coloques nada fuera de los l\xEDmites de la p\xE1gina.",
+    'LLENAR UNA L\xCDNEA "____" YA EXISTENTE (label + rengl\xF3n): el valor se apoya',
+    "ENCIMA del rengl\xF3n, NO debajo. Us\xE1 la MISMA baseline del label de esa l\xEDnea",
+    "(su `y` exacto, o +2pt). NUNCA restes: y menor = el texto cae DEBAJO de la",
+    "l\xEDnea (mal). Si el hueco est\xE1 a la derecha del label, x = x del label + su",
+    'ancho + ~6pt. El texto va SOBRE los "____", no en otro rengl\xF3n.',
+    "",
+    'CONVERTIR PLACEHOLDERS EN INPUTS ("XXXX", "xxx", "____", "***", "\u2026" o',
+    "cualquier relleno de plantilla): DETECTALOS VOS leyendo el texto y us\xE1 SIEMPRE",
+    "placeholders_to_fields(id, fields=[{placeholder,name}]).",
+    "\u26A0\uFE0F CR\xCDTICO \u2014 UNA SOLA LLAMADA POR P\xC1RRAFO (no por l\xEDnea/nodo): la tool",
+    "reconstruye el P\xC1RRAFO ENTERO al que pertenece `id`, as\xED que junt\xE1 TODOS los",
+    "placeholders del p\xE1rrafo (aunque est\xE9n en varias l\xEDneas) en UN solo fields[],",
+    "EN ORDEN DE LECTURA, y llamala UNA vez con el id de cualquiera de esas l\xEDneas.",
+    "Llamarla 2+ veces sobre el mismo p\xE1rrafo rehace todo el reflow cada vez (lento)",
+    "y se pisan entre s\xED. `placeholder` = el substring EXACTO del texto; `name` =",
+    "snake_case (mir\xE1 el label del hueco). NO pases coordenadas, NO uses edit_text/",
+    'add_form_field para esto, NO dejes "_" ni "XXXX". Un "____" ya dibujado YA es el',
+    "campo: complet\xE1 encima. Nunca agregues bold/italic que no exist\xEDa.",
+    "",
+    "Respond\xE9 en el idioma del usuario, conciso. Si una edici\xF3n es ambigua o el id",
+    "no existe, decilo en vez de adivinar.",
+    "",
+    scoped ? `=== DOCUMENTO: ${doc.path} (${pages} p\xE1ginas en total) \u2014 MOSTRANDO SOLO ${scoped.length === 1 ? `LA P\xC1GINA ${scoped[0]}` : `LAS P\xC1GINAS ${scoped.join(", ")}`}. Trabaj\xE1 sobre esas p\xE1ginas. ===` : `=== DOCUMENTO: ${doc.path} (${pages} ${pages === 1 ? "p\xE1gina" : "p\xE1ginas"}) ===`,
+    serializeDoc(doc, page)
+  ].join("\n");
+}
+function chatSystemPrompt(doc, page) {
+  const total = doc.pages.length;
+  const current = page ?? 1;
+  return [
+    "Sos CASPER, el asistente del editor de PDF Aldus. Ten\xE9s embebido abajo el",
+    `grafo COMPLETO del documento (${total} ${total === 1 ? "p\xE1gina" : "p\xE1ginas"}).`,
+    `El usuario est\xE1 viendo la p\xE1gina ${current}.`,
+    "",
+    "C\xF3mo trabaj\xE1s:",
+    "- PREGUNTAS sobre el contenido (resumir, extraer, listar campos, explicar) \u2192",
+    "  respond\xE9 DIRECTO leyendo el grafo. Pod\xE9s mirar CUALQUIER p\xE1gina, no solo la",
+    "  que el usuario ve. Devolv\xE9 el formato que pida (JSON, tabla\u2026).",
+    "- CUALQUIER MODIFICACI\xD3N del PDF (editar/mover/borrar texto, resaltar, links,",
+    "  im\xE1genes, watermark, encabezados, campos, completar formularios) \u2192 NO la",
+    "  hagas vos: llam\xE1 edit_document UNA sola vez con TODO el pedido.",
+    "  \xB7 pages = LAS P\xC1GINAS EXACTAS donde hay que trabajar. Mir\xE1 el grafo entero y",
+    "    eleg\xED SOLO las que el cambio realmente toca (p. ej. [3] o [1,4]). Al editor",
+    "    le inyectamos \xDANICAMENTE esas p\xE1ginas \u2014 si inclu\xEDs de m\xE1s, lo confund\xEDs con",
+    "    contenido irrelevante; si te falta una, trabaja a ciegas. Eleg\xED con",
+    `    precisi\xF3n. Si el pedido es sobre lo que el usuario ve y no menciona otra,`,
+    `    es [${current}].`,
+    "  \xB7 request = la instrucci\xF3n COMPLETA y autocontenida para el editor:",
+    "    repet\xED todos los datos/valores/textos que dio el usuario, en su idioma, y",
+    "    dec\xED expl\xEDcitamente en qu\xE9 p\xE1gina(s) va cada cosa.",
+    "  Despu\xE9s de llamar edit_document, dec\xED UNA sola frase corta en presente",
+    '  ("Le ped\xED al editor que complete los campos con datos de prueba."). VOS NO',
+    '  EDIT\xC1S NADA: NO digas "Listo", NO afirmes que ya se hizo, NO enumeres',
+    "  resultados ni valores que no pod\xE9s conocer \u2014 el editor reporta \xE9l mismo al",
+    "  terminar, y tu invento quedar\xEDa duplicado y posiblemente mal.",
+    "  \u26A0\uFE0F Si el pedido de modificaci\xF3n es claro, DELEG\xC1 YA (llam\xE1 edit_document) \u2014",
+    '  NO pidas confirmaci\xF3n ni preguntes "\xBFes esto lo que quer\xE9s?". Solo pregunt\xE1',
+    "  si es genuinamente ambiguo qu\xE9 cambiar.",
+    '  \u26A0\uFE0F "convertir/reemplazar los XXXX/placeholders por inputs/campos/completable"',
+    "  = CREAR campos de formulario VAC\xCDOS. NO necesit\xE1s valores para eso: deleg\xE1",
+    "  directo (el editor crea los campos). Solo ped\xED valores si el usuario dice",
+    '  expl\xEDcitamente "COMPLET\xC1/LLEN\xC1 con estos datos". Ej: usuario "reemplaza los',
+    '  XXXX por inputs" \u2192 edit_document({pages:[1], request:"convertir los',
+    '  placeholders XXXX/xxxx de la p\xE1gina 1 en campos de formulario"}).',
+    "",
+    "Respond\xE9 en el idioma del usuario, conciso.",
+    "",
+    `=== DOCUMENTO: ${doc.path} (${total} ${total === 1 ? "p\xE1gina" : "p\xE1ginas"}) \u2014 el usuario ve la ${current} ===`,
+    serializeDoc(doc)
+  ].join("\n");
+}
+async function runTurn(opts) {
+  if (config.provider === "openrouter") {
+    const { runTurnOpenRouter: runTurnOpenRouter2 } = await Promise.resolve().then(() => (init_openrouter(), openrouter_exports));
+    return runTurnOpenRouter2(opts);
+  }
+  const t0 = Date.now();
+  log2(`turno: "${opts.prompt.slice(0, 80)}" (page=${opts.page}, resume=${!!opts.resume})`);
+  let route = null;
+  let text = "";
+  let sessionId;
+  for await (const message of query({
+    prompt: opts.prompt,
+    options: {
+      model: config.chatModel,
+      systemPrompt: chatSystemPrompt(opts.doc, opts.page),
+      mcpServers: { aldus: buildRouterServer((r2) => {
+        route = r2;
+      }) },
+      includePartialMessages: true,
+      canUseTool: async (name, input) => name === "mcp__aldus__edit_document" ? { behavior: "allow", updatedInput: input } : { behavior: "deny", message: "El chat solo puede delegar con edit_document." },
+      maxTurns: 4,
+      ...opts.resume ? { resume: opts.resume } : {}
+    }
+  })) {
+    if (message.type === "stream_event") {
+      const ev = message.event;
+      if (ev.type === "content_block_delta" && ev.delta?.type === "text_delta" && ev.delta.text) {
+        text += ev.delta.text;
+        opts.onEvent?.({ type: "text", delta: ev.delta.text, agent: "chat" });
+      } else if (ev.type === "content_block_start" && ev.content_block?.type === "tool_use" && ev.content_block.name === "mcp__aldus__edit_document") {
+        log2(`chat \u2192 edit_document (${Date.now() - t0}ms)`);
+        opts.onEvent?.({ type: "tool", name: "mcp__aldus__edit_document", agent: "chat" });
+      }
+    } else if (message.type === "result") {
+      sessionId = message.session_id;
+    }
+  }
+  if (!route) {
+    log2(`turno chat-only listo en ${Date.now() - t0}ms`);
+    return { text, sessionId, toolCalls: 0 };
+  }
+  const routed = route;
+  const pages = routed.pages.length ? routed.pages : opts.page != null ? [opts.page] : void 0;
+  const server = buildToolServer(opts.session);
+  let toolCalls = 0;
+  const usedTools = /* @__PURE__ */ new Set();
+  let editorSession;
+  const editorPass = async (prompt, resume) => {
+    for await (const message of query({
+      prompt,
+      options: {
+        model: config.model,
+        systemPrompt: systemPrompt(opts.doc, pages),
+        mcpServers: { aldus: server },
+        // Deltas token a token → el panel muestra la respuesta escribiéndose y las
+        // tools ejecutándose, en vez de quedarse mudo 20-40s en "Pensando".
+        includePartialMessages: true,
+        // En headless no hay prompt de permisos interactivo: `canUseTool` es el
+        // ÚNICO gate — auto-aprueba las tools de Aldus y niega cualquier otra (sin
+        // `allowedTools`, que las auto-aprobaría antes y shadowearía este callback).
+        canUseTool: async (name, input) => name.startsWith("mcp__aldus__") ? { behavior: "allow", updatedInput: input } : { behavior: "deny", message: "Aldus solo permite sus propias tools de edici\xF3n." },
+        maxTurns: config.maxTurns,
+        // La fase editora es una conversación propia (el hilo del CHAT vive en
+        // la fase 1 — su sessionId es el que se devuelve al panel).
+        ...resume ? { resume } : {}
+      }
+    })) {
+      if (message.type === "stream_event") {
+        const ev = message.event;
+        if (ev.type === "content_block_delta" && ev.delta?.type === "text_delta" && ev.delta.text) {
+          text += ev.delta.text;
+          opts.onEvent?.({ type: "text", delta: ev.delta.text, agent: "editor" });
+        } else if (ev.type === "content_block_start" && ev.content_block?.type === "tool_use") {
+          const name = ev.content_block.name ?? "tool";
+          if (name.startsWith("mcp__aldus__")) {
+            toolCalls++;
+            const bare = name.replace("mcp__aldus__", "");
+            usedTools.add(bare);
+            log2(`editor tool #${toolCalls}: ${bare} (${Date.now() - t0}ms)`);
+            opts.onEvent?.({ type: "tool", name, agent: "editor" });
+          }
+        }
+      } else if (message.type === "result") {
+        editorSession = message.session_id;
+      }
+    }
+  };
+  await editorPass(`${opts.prompt}
+
+[Plan del asistente]: ${routed.request}`);
+  const MANUAL_GEOMETRY2 = ["move_text", "move_field", "move_image"];
+  const movedByHand = MANUAL_GEOMETRY2.some((t) => usedTools.has(t));
+  if (movedByHand) {
+    const issues = await overlapReport(opts.session).catch(() => []);
+    if (issues.length) {
+      log2(`verify: ${issues.length} issues \u2192 pasada correctiva`);
+      opts.onEvent?.({ type: "tool", name: "mcp__aldus__verify_layout", agent: "editor" });
+      await editorPass(verifyMessage(issues), editorSession);
+    }
+  }
+  log2(`turno listo en ${Date.now() - t0}ms (toolCalls=${toolCalls}, tools=[${[...usedTools].join(",")}])`);
+  return { text, sessionId, toolCalls };
+}
+var log2;
+var init_agent = __esm({
+  "../agent/src/agent.ts"() {
+    init_src();
+    init_tools();
+    init_serialize();
+    init_verify();
+    init_config();
+    log2 = createLogger("aldus:agent");
+  }
+});
+
+// ../agent/src/index.ts
+init_graph();
+init_serialize();
+
+// ../agent/src/session.ts
+init_src();
+import { readFile as readFile2, writeFile } from "node:fs/promises";
+
+// ../core/src/bake/bake.ts
+import { PDFDocument as PDFDocument8 } from "pdf-lib";
+
+// ../core/src/bake/tokenizer.ts
+var isWs = (c) => c === 0 || c === 9 || c === 10 || c === 12 || c === 13 || c === 32;
+var isDelim = (c) => c === 40 || c === 41 || c === 60 || c === 62 || c === 91 || c === 93 || c === 123 || c === 125 || c === 47 || c === 37;
+var latin1 = (bytes, a2, b) => {
+  let s = "";
+  for (let i = a2; i < b; i++) s += String.fromCharCode(bytes[i]);
+  return s;
+};
+function tokenizeContentStream(src) {
+  const ops = [];
+  let operands = [];
+  let i = 0;
+  const n = src.length;
+  const skipWs = () => {
+    while (i < n) {
+      if (isWs(src[i])) {
+        i++;
+        continue;
+      }
+      if (src[i] === 37) {
+        while (i < n && src[i] !== 10 && src[i] !== 13) i++;
+        continue;
+      }
+      break;
+    }
+  };
+  const parseString = () => {
+    const start = i;
+    i++;
+    const out = [];
+    let depth = 1;
+    while (i < n && depth > 0) {
+      const c = src[i];
+      if (c === 92) {
+        const e = src[i + 1];
+        i += 2;
+        if (e === 110) out.push(10);
+        else if (e === 114) out.push(13);
+        else if (e === 116) out.push(9);
+        else if (e === 98) out.push(8);
+        else if (e === 102) out.push(12);
+        else if (e === 40 || e === 41 || e === 92) out.push(e);
+        else if (e >= 48 && e <= 55) {
+          let v = e - 48;
+          for (let k = 0; k < 2 && src[i] >= 48 && src[i] <= 55; k++) {
+            v = v * 8 + (src[i] - 48);
+            i++;
+          }
+          out.push(v & 255);
+        } else if (e === 10) {
+        } else if (e === 13) {
+          if (src[i] === 10) i++;
+        } else if (e !== void 0) out.push(e);
+      } else {
+        if (c === 40) depth++;
+        else if (c === 41) {
+          depth--;
+          if (depth === 0) {
+            i++;
+            break;
+          }
+        }
+        out.push(c);
+        i++;
+        continue;
+      }
+    }
+    return { kind: "str", raw: latin1(src, start, i), bytes: Uint8Array.from(out), start, end: i };
+  };
+  const parseHex = () => {
+    const start = i;
+    i++;
+    const digits = [];
+    while (i < n && src[i] !== 62) {
+      const c = src[i];
+      if (!isWs(c)) digits.push(c);
+      i++;
+    }
+    i++;
+    let hex = digits.map((c) => String.fromCharCode(c)).join("");
+    if (hex.length % 2) hex += "0";
+    const out = new Uint8Array(hex.length / 2);
+    for (let k = 0; k < out.length; k++) out[k] = parseInt(hex.slice(k * 2, k * 2 + 2), 16);
+    return { kind: "hex", raw: latin1(src, start, i), bytes: out, start, end: i };
+  };
+  const parseName = () => {
+    const start = i;
+    i++;
+    let name = "";
+    while (i < n && !isWs(src[i]) && !isDelim(src[i])) {
+      if (src[i] === 35 && i + 2 < n) {
+        name += String.fromCharCode(parseInt(latin1(src, i + 1, i + 3), 16));
+        i += 3;
+      } else {
+        name += String.fromCharCode(src[i]);
+        i++;
+      }
+    }
+    return { kind: "name", value: name, raw: latin1(src, start, i), start, end: i };
+  };
+  const parseNumber = () => {
+    const start = i;
+    while (i < n && !isWs(src[i]) && !isDelim(src[i])) i++;
+    const raw = latin1(src, start, i);
+    return { kind: "num", value: parseFloat(raw), raw, start, end: i };
+  };
+  const parseDict = () => {
+    const start = i;
+    i += 2;
+    let depth = 1;
+    while (i < n && depth > 0) {
+      if (src[i] === 60 && src[i + 1] === 60) {
+        depth++;
+        i += 2;
+        continue;
+      }
+      if (src[i] === 62 && src[i + 1] === 62) {
+        depth--;
+        i += 2;
+        continue;
+      }
+      if (src[i] === 40) {
+        parseString();
+        continue;
+      }
+      i++;
+    }
+    return { kind: "dict", raw: latin1(src, start, i), start, end: i };
+  };
+  const parseArray = () => {
+    const start = i;
+    i++;
+    const items = [];
+    while (i < n) {
+      skipWs();
+      if (src[i] === 93) {
+        i++;
+        break;
+      }
+      items.push(parseOne());
+    }
+    return { kind: "arr", items, raw: latin1(src, start, i), start, end: i };
+  };
+  const parseKeyword = () => {
+    const start = i;
+    while (i < n && !isWs(src[i]) && !isDelim(src[i])) i++;
+    const kw = latin1(src, start, i);
+    return { kind: "kw", value: kw, raw: kw, start, end: i };
+  };
+  const parseOne = () => {
+    const c = src[i];
+    if (c === 40) return parseString();
+    if (c === 60) return src[i + 1] === 60 ? parseDict() : parseHex();
+    if (c === 47) return parseName();
+    if (c === 91) return parseArray();
+    if (c >= 48 && c <= 57 || c === 43 || c === 45 || c === 46) return parseNumber();
+    return parseKeyword();
+  };
+  while (i < n) {
+    skipWs();
+    if (i >= n) break;
+    const tok = parseOne();
+    if (tok.kind === "kw") {
+      const op = tok.value;
+      if (op === "BI") {
+        while (i < n) {
+          if (isWs(src[i - 1]) && src[i] === 69 && src[i + 1] === 73 && (i + 2 >= n || isWs(src[i + 2]) || isDelim(src[i + 2]))) {
+            i += 2;
+            break;
+          }
+          i++;
+        }
+        operands = [];
+        continue;
+      }
+      ops.push({
+        op,
+        operands,
+        start: operands.length ? operands[0].start : tok.start,
+        end: tok.end
+      });
+      operands = [];
+    } else {
+      operands.push(tok);
+    }
+  }
+  return ops;
+}
+
+// ../core/src/bake/splice.ts
+var fmt = (v) => {
+  const r2 = Math.round(v * 1e4) / 1e4;
+  return Object.is(r2, -0) ? "0" : String(r2);
+};
+var latin12 = (bytes, a2, b) => {
+  let s = "";
+  for (let i = a2; i < b; i++) s += String.fromCharCode(bytes[i]);
+  return s;
+};
+var toBytes = (s) => {
+  const out = new Uint8Array(s.length);
+  for (let i = 0; i < s.length; i++) out[i] = s.charCodeAt(i) & 255;
+  return out;
+};
+var hexString = (bytes) => `<${[...bytes].map((b) => b.toString(16).padStart(2, "0")).join("")}>`;
+function rebuild(src, splices, prepend = "", append = "") {
+  const sorted = [...splices].sort((a2, b) => a2.start - b.start || a2.end - a2.start - (b.end - b.start));
+  let out = prepend ? `${prepend}
+` : "";
+  let pos = 0;
+  for (const s of sorted) {
+    if (s.start < pos) continue;
+    out += latin12(src, pos, s.start);
+    if (s.text) out += `
+${s.text}
+`;
+    pos = s.end;
+  }
+  out += latin12(src, pos, src.length);
+  if (append) out += `
+${append}
+`;
+  return toBytes(out);
+}
+
+// ../core/src/bake/color.ts
+function hexToRg(hex) {
+  const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+  if (!m) return void 0;
+  const v = parseInt(m[1], 16);
+  const c = (n) => fmt(n / 255);
+  return `${c(v >> 16 & 255)} ${c(v >> 8 & 255)} ${c(v & 255)} rg`;
+}
+function rawFillToRgb(raw) {
+  if (!raw) return null;
+  const nums = (raw.match(/-?\d*\.?\d+/g) ?? []).map(Number);
+  if (/\brg\b/.test(raw) && nums.length >= 3) return { r: nums[0], g: nums[1], b: nums[2] };
+  if (/\bg\b/.test(raw) && !/\brg\b/.test(raw) && nums.length >= 1) return { r: nums[0], g: nums[0], b: nums[0] };
+  if (/\bk\b/.test(raw) && nums.length >= 4) {
+    const [c, m, y, kk] = nums;
+    return { r: (1 - c) * (1 - kk), g: (1 - m) * (1 - kk), b: (1 - y) * (1 - kk) };
+  }
+  if (nums.length >= 3) return { r: nums[nums.length - 3], g: nums[nums.length - 2], b: nums[nums.length - 1] };
+  if (nums.length === 1) return { r: nums[0], g: nums[0], b: nums[0] };
+  return null;
+}
+var hexToRgbObj = (hex) => {
+  const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+  const v = m ? parseInt(m[1], 16) : 0;
+  return { r: (v >> 16 & 255) / 255, g: (v >> 8 & 255) / 255, b: (v & 255) / 255 };
+};
+var rgbToHex = (c) => {
+  const h = (v) => Math.max(0, Math.min(255, Math.round(v * 255))).toString(16).padStart(2, "0");
+  return `#${h(c.r)}${h(c.g)}${h(c.b)}`;
+};
+function isWhiteFill(rawFill) {
+  const toks = rawFill.trim().split(/\s+/);
+  if (toks.length < 2) return false;
+  const nums = toks.filter((t) => /^[-+.\d]/.test(t)).map(Number).filter(Number.isFinite);
+  const op = toks[toks.length - 1];
+  if (op === "g" && nums.length >= 1) return nums[nums.length - 1] >= 0.99;
+  if (op === "rg" && nums.length >= 3) return nums.slice(-3).every((v) => v >= 0.99);
+  if (op === "k" && nums.length >= 4) return nums.slice(-4).every((v) => v <= 0.01);
+  if ((op === "sc" || op === "scn") && nums.length >= 1) {
+    const vals = nums.slice(-Math.min(nums.length, 3));
+    return vals.every((v) => v >= 0.99);
+  }
+  return false;
+}
+
+// ../core/src/bake/textWalk.ts
+var IDENTITY = [1, 0, 0, 1, 0, 0];
+function mul(m, n) {
+  return [
+    m[0] * n[0] + m[1] * n[2],
+    m[0] * n[1] + m[1] * n[3],
+    m[2] * n[0] + m[3] * n[2],
+    m[2] * n[1] + m[3] * n[3],
+    m[4] * n[0] + m[5] * n[2] + n[4],
+    m[4] * n[1] + m[5] * n[3] + n[5]
+  ];
+}
+function invert(m) {
+  const det = m[0] * m[3] - m[1] * m[2];
+  if (!det) return null;
+  const ia = m[3] / det;
+  const ib = -m[1] / det;
+  const ic = -m[2] / det;
+  const id = m[0] / det;
+  return [ia, ib, ic, id, -(m[4] * ia + m[5] * ic), -(m[4] * ib + m[5] * id)];
+}
+function walkContent(src) {
+  const ops = tokenizeContentStream(src);
+  const shows = [];
+  const xobjects = [];
+  const fillRects = [];
+  let simple = null;
+  const isRectPoly = (pts) => {
+    if (pts.length !== 4) return false;
+    for (let i = 0; i < 4; i++) {
+      const [x1, y1] = pts[i];
+      const [x2, y2] = pts[(i + 1) % 4];
+      if (Math.abs(y2 - y1) > 0.01 && Math.abs(x2 - x1) > 0.01) return false;
+    }
+    return true;
+  };
+  let ctm = IDENTITY;
+  let clip = null;
+  let clipPending = false;
+  const stack = [];
+  let tm = IDENTITY;
+  let tlm = IDENTITY;
+  let fontName = "";
+  let fontSize = 0;
+  let charSpacing = 0;
+  let wordSpacing = 0;
+  let hScale = 100;
+  let leading = 0;
+  let stale = false;
+  let fillColorRaw = "";
+  let csRaw = "";
+  let backstop = null;
+  let pathStart = null;
+  const markContent = (at) => {
+    if (!backstop) backstop = at;
+  };
+  const raw = (rec) => {
+    let s = "";
+    for (let k = rec.start; k < rec.end; k++) s += String.fromCharCode(src[k]);
+    return s;
+  };
+  const num = (rec, idx) => {
+    const t = rec.operands[idx];
+    return t && t.kind === "num" ? t.value : 0;
+  };
+  const setTd = (tx, ty) => {
+    tlm = mul([1, 0, 0, 1, tx, ty], tlm);
+    tm = tlm;
+    stale = false;
+  };
+  const record = (rec, op) => {
+    const m = mul(tm, ctm);
+    shows.push({
+      record: rec,
+      op,
+      x: m[4],
+      y: m[5],
+      matrix: m,
+      ctm,
+      fontName,
+      fontSize,
+      charSpacing,
+      wordSpacing,
+      hScale,
+      fillColorRaw,
+      stale,
+      clip
+    });
+    stale = true;
+  };
+  const absRectOf = (p) => {
+    const m = p.ctm;
+    const corners = p.rect ? [[p.rect[0], p.rect[1]], [p.rect[0] + p.rect[2], p.rect[1] + p.rect[3]]] : isRectPoly(p.pts) ? p.pts : [];
+    if (!corners.length || Math.abs(m[1]) > 0.01 || Math.abs(m[2]) > 0.01) return null;
+    const xs = corners.map(([px]) => m[0] * px + m[4]);
+    const ys = corners.map(([, py]) => m[3] * py + m[5]);
+    const x = Math.min(...xs);
+    const y = Math.min(...ys);
+    return { x, y, width: Math.max(...xs) - x, height: Math.max(...ys) - y };
+  };
+  const consumeClip = () => {
+    if (!clipPending) return;
+    clipPending = false;
+    const r2 = simple?.valid ? absRectOf(simple) : null;
+    if (!r2) return;
+    if (!clip) {
+      clip = r2;
+      return;
+    }
+    const x = Math.max(clip.x, r2.x);
+    const y = Math.max(clip.y, r2.y);
+    clip = {
+      x,
+      y,
+      width: Math.max(0, Math.min(clip.x + clip.width, r2.x + r2.width) - x),
+      height: Math.max(0, Math.min(clip.y + clip.height, r2.y + r2.height) - y)
+    };
+  };
+  for (const rec of ops) {
+    switch (rec.op) {
+      case "q":
+        stack.push({ ctm, clip });
+        break;
+      case "Q": {
+        const s = stack.pop();
+        ctm = s?.ctm ?? IDENTITY;
+        clip = s?.clip ?? null;
+        break;
+      }
+      case "cm":
+        ctm = mul([num(rec, 0), num(rec, 1), num(rec, 2), num(rec, 3), num(rec, 4), num(rec, 5)], ctm);
+        break;
+      // ── backstop: construcción y pintado de paths ──
+      case "m":
+        if (!pathStart) pathStart = { offset: rec.start, ctm };
+        if (simple) simple.valid = false;
+        else simple = { start: rec.start, ctm, fill: fillColorRaw, pts: [[num(rec, 0), num(rec, 1)]], valid: true };
+        break;
+      case "l":
+        if (simple && simple.valid && !simple.rect && simple.pts.length < 5) simple.pts.push([num(rec, 0), num(rec, 1)]);
+        else if (simple) simple.valid = false;
+        break;
+      case "c":
+      case "v":
+      case "y":
+        if (simple) simple.valid = false;
+        break;
+      case "h":
+        break;
+      // cerrar el subpath no cambia el bbox
+      case "re":
+        if (!pathStart) pathStart = { offset: rec.start, ctm };
+        if (simple) simple.valid = false;
+        else simple = { start: rec.start, ctm, fill: fillColorRaw, rect: [num(rec, 0), num(rec, 1), num(rec, 2), num(rec, 3)], pts: [], valid: true };
+        break;
+      case "W":
+      case "W*":
+        clipPending = true;
+        break;
+      case "n":
+        consumeClip();
+        pathStart = null;
+        simple = null;
+        break;
+      // solo clip — no es contenido
+      case "f":
+      case "F":
+      case "f*":
+      case "b":
+      case "b*":
+      case "B":
+      case "B*": {
+        consumeClip();
+        if (!isWhiteFill(fillColorRaw)) markContent(pathStart ?? { offset: rec.start, ctm });
+        if (simple?.valid) {
+          const r2 = absRectOf(simple);
+          if (r2) fillRects.push({ start: simple.start, end: rec.end, ...r2, fillColorRaw: simple.fill });
+        }
+        pathStart = null;
+        simple = null;
+        break;
+      }
+      case "S":
+      case "s":
+        consumeClip();
+        markContent(pathStart ?? { offset: rec.start, ctm });
+        pathStart = null;
+        simple = null;
+        break;
+      case "sh":
+        markContent({ offset: rec.start, ctm });
+        break;
+      case "BI":
+        markContent({ offset: rec.start, ctm });
+        break;
+      case "BT":
+        markContent({ offset: rec.start, ctm });
+        tm = IDENTITY;
+        tlm = IDENTITY;
+        stale = false;
+        break;
+      case "ET":
+        break;
+      case "Tf": {
+        const t = rec.operands[0];
+        fontName = t && t.kind === "name" ? t.value : fontName;
+        fontSize = num(rec, 1);
+        break;
+      }
+      case "Tc":
+        charSpacing = num(rec, 0);
+        break;
+      case "Tw":
+        wordSpacing = num(rec, 0);
+        break;
+      case "Tz":
+        hScale = num(rec, 0);
+        break;
+      case "TL":
+        leading = num(rec, 0);
+        break;
+      case "Td":
+        setTd(num(rec, 0), num(rec, 1));
+        break;
+      case "TD":
+        leading = -num(rec, 1);
+        setTd(num(rec, 0), num(rec, 1));
+        break;
+      case "Tm":
+        tlm = [num(rec, 0), num(rec, 1), num(rec, 2), num(rec, 3), num(rec, 4), num(rec, 5)];
+        tm = tlm;
+        stale = false;
+        break;
+      case "T*":
+        setTd(0, -leading);
+        break;
+      case "Tj":
+        record(rec, "Tj");
+        break;
+      case "TJ":
+        record(rec, "TJ");
+        break;
+      case "'":
+        setTd(0, -leading);
+        record(rec, "'");
+        break;
+      case '"':
+        wordSpacing = num(rec, 0);
+        charSpacing = num(rec, 1);
+        setTd(0, -leading);
+        record(rec, '"');
+        break;
+      case "g":
+      case "rg":
+      case "k":
+        fillColorRaw = raw(rec);
+        break;
+      case "cs":
+        csRaw = raw(rec);
+        break;
+      case "sc":
+      case "scn":
+        fillColorRaw = csRaw ? `${csRaw} ${raw(rec)}` : raw(rec);
+        break;
+      case "Do": {
+        const t = rec.operands[0];
+        if (t && t.kind === "name") xobjects.push({ record: rec, name: t.value, matrix: ctm });
+        markContent({ offset: rec.start, ctm });
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return { shows, xobjects, fillRects, backstop: backstop ?? { offset: 0, ctm: IDENTITY } };
+}
+
+// ../core/src/bake/pageContent.ts
+import {
+  PDFArray,
+  PDFName,
+  PDFRawStream,
+  PDFRef,
+  decodePDFRawStream
+} from "pdf-lib";
+function pageContentBytes(doc, page) {
+  const ctx = doc.context;
+  const resolve = (o) => o instanceof PDFRef ? ctx.lookup(o) : o;
+  const contents = resolve(page.node.get(PDFName.of("Contents")));
+  const streams = [];
+  if (contents instanceof PDFArray) {
+    for (let i = 0; i < contents.size(); i++) {
+      const s = resolve(contents.get(i));
+      if (s instanceof PDFRawStream) streams.push(s);
+      else throw new Error("Content stream no soportado (no es PDFRawStream).");
+    }
+  } else if (contents instanceof PDFRawStream) {
+    streams.push(contents);
+  } else if (contents != null) {
+    throw new Error("Content stream no soportado.");
+  }
+  const parts = streams.map((s) => decodePDFRawStream(s).decode());
+  const total = parts.reduce((a2, p) => a2 + p.length + 1, 0);
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const p of parts) {
+    out.set(p, off);
+    off += p.length;
+    out[off++] = 10;
+  }
+  return out;
+}
+function setPageContents(doc, page, bytes) {
+  const stream = doc.context.stream(bytes);
+  const ref = doc.context.register(stream);
+  page.node.set(PDFName.of("Contents"), ref);
+}
+
+// ../core/src/bake/locate.ts
+import { PDFDict, PDFName as PDFName2, PDFRawStream as PDFRawStream2, PDFRef as PDFRef2 } from "pdf-lib";
+var Y_TOL = 1.8;
+var X_TOL = 1.8;
+function xobjectRect(m) {
+  const [a2, b, c, d, e, f] = m;
+  const xs = [e, a2 + e, c + e, a2 + c + e];
+  const ys = [f, b + f, d + f, b + d + f];
+  const x = Math.min(...xs);
+  const y = Math.min(...ys);
+  return { x, y, width: Math.max(...xs) - x, height: Math.max(...ys) - y, rotated: Math.abs(b) > 0.01 || Math.abs(c) > 0.01 };
+}
+function imageResourceNames(doc, page) {
+  const out = /* @__PURE__ */ new Set();
+  try {
+    const res = page.node.Resources();
+    const xo = res?.lookup(PDFName2.of("XObject"));
+    if (!(xo instanceof PDFDict)) return out;
+    for (const [key, val] of xo.entries()) {
+      const obj = val instanceof PDFRef2 ? doc.context.lookup(val) : val;
+      const dict = obj instanceof PDFRawStream2 ? obj.dict : obj instanceof PDFDict ? obj : null;
+      if (dict?.get(PDFName2.of("Subtype")) === PDFName2.of("Image")) {
+        out.add(key.toString().replace(/^\//, ""));
+      }
+    }
+  } catch {
+  }
+  return out;
+}
+function matchImage(xobjects, orig) {
+  const tol = Math.max(2, orig.width * 0.02, orig.height * 0.02);
+  return xobjects.find((o) => {
+    const r2 = xobjectRect(o.matrix);
+    return Math.abs(r2.x - orig.x) <= tol && Math.abs(r2.y - orig.y) <= tol && Math.abs(r2.width - orig.width) <= tol && Math.abs(r2.height - orig.height) <= tol;
+  }) ?? null;
+}
+function matchOps(shows, orig) {
+  const lines = orig.baselines?.length ? orig.baselines : [orig.baseline];
+  const inLine = shows.filter((s) => lines.some((b) => Math.abs(s.y - b) <= Y_TOL));
+  if (inLine.some((s) => s.stale)) {
+    return { ops: [], conflict: "la l\xEDnea tiene shows encadenados sin reposicionar (x desconocida sin widths)" };
+  }
+  const inside = inLine.filter((s) => s.x >= orig.x - X_TOL && s.x <= orig.x + orig.width + X_TOL);
+  if (!inside.length) {
+    return { ops: [], conflict: "ning\xFAn operador de texto arranca dentro del segmento (\xBFun TJ de otra columna lo contiene?)" };
+  }
+  return { ops: inside, conflict: null };
+}
+
+// ../core/src/bake/images.ts
+function applyImageEditsToPage(args) {
+  const { doc, page, pageImgEdits, xobjects, backstop, splices, appendBlocks, report } = args;
+  if (!pageImgEdits.length) return;
+  const imgNames = imageResourceNames(doc, page);
+  const imageOps = xobjects.filter((o) => imgNames.has(o.name));
+  for (const edit of pageImgEdits) {
+    const op = matchImage(imageOps, edit.original);
+    if (!op) {
+      report.warn(`${edit.imageId}: no se encontr\xF3 el XObject en la posici\xF3n original \u2014 sin cambios`);
+      continue;
+    }
+    if (edit.remove) {
+      splices.push({ start: op.record.start, end: op.record.end, text: "" });
+      report.apply(`${edit.imageId}: eliminada`);
+      continue;
+    }
+    const r2 = xobjectRect(op.matrix);
+    if (r2.rotated) {
+      report.warn(`${edit.imageId}: la imagen tiene rotaci\xF3n \u2014 mover/escalar no soportado a\xFAn, queda intacta`);
+      continue;
+    }
+    const [a2, , , d] = op.matrix;
+    const newW = edit.width ?? r2.width;
+    const newH = edit.height ?? r2.height;
+    const newX = edit.x ?? r2.x;
+    const newY = edit.y ?? r2.y;
+    const na = a2 * (newW / r2.width);
+    const nd = d * (newH / r2.height);
+    const ne = newX - Math.min(0, na);
+    const nf = newY - Math.min(0, nd);
+    const abs = [na, 0, 0, nd, ne, nf];
+    if (edit.zOrder) {
+      splices.push({ start: op.record.start, end: op.record.end, text: "" });
+      if (edit.zOrder === "back") {
+        const binv = invert(backstop.ctm);
+        const m = binv ? mul(abs, binv) : abs;
+        const block = `q ${fmt(m[0])} ${fmt(m[1])} ${fmt(m[2])} ${fmt(m[3])} ${fmt(m[4])} ${fmt(m[5])} cm /${op.name} Do Q`;
+        splices.push({ start: backstop.offset, end: backstop.offset, text: block });
+      } else {
+        appendBlocks.push(`q ${fmt(abs[0])} ${fmt(abs[1])} ${fmt(abs[2])} ${fmt(abs[3])} ${fmt(abs[4])} ${fmt(abs[5])} cm /${op.name} Do Q`);
+      }
+      report.apply(`${edit.imageId}: enviada ${edit.zOrder === "back" ? "al fondo" : "al frente"}`);
+      continue;
+    }
+    const inv = invert(op.matrix);
+    if (!inv) {
+      report.warn(`${edit.imageId}: matriz degenerada \u2014 sin cambios`);
+      continue;
+    }
+    const rel = mul(abs, inv);
+    splices.push({
+      start: op.record.start,
+      end: op.record.end,
+      text: `q ${fmt(rel[0])} ${fmt(rel[1])} ${fmt(rel[2])} ${fmt(rel[3])} ${fmt(rel[4])} ${fmt(rel[5])} cm /${op.name} Do Q`
+    });
+    report.apply(`${edit.imageId}: reubicada/escalada`);
+  }
+}
+
+// ../core/src/bake/fonts.ts
+import { PDFArray as PDFArray2, PDFDict as PDFDict2, PDFName as PDFName3, PDFNumber, PDFRawStream as PDFRawStream3, StandardFonts, decodePDFRawStream as decodePDFRawStream2 } from "pdf-lib";
+
+// ../core/src/bake/toUnicode.ts
+var hexToBytes = (hex) => {
+  const out = [];
+  for (let i = 0; i + 1 < hex.length; i += 2) out.push(parseInt(hex.slice(i, i + 2), 16));
+  return out;
+};
+var bytesToUnicode = (bytes) => {
+  const units = [];
+  for (let i = 0; i + 1 < bytes.length; i += 2) units.push(bytes[i] << 8 | bytes[i + 1]);
+  return String.fromCharCode(...units);
+};
+function parseToUnicode(cmapText) {
+  const map = /* @__PURE__ */ new Map();
+  const hexRe = /<([0-9a-fA-F]+)>/g;
+  const takeHexes = (chunk) => {
+    const out = [];
+    let m2;
+    hexRe.lastIndex = 0;
+    while (m2 = hexRe.exec(chunk)) out.push(m2[1]);
+    return out;
+  };
+  const bfcharRe = /beginbfchar([\s\S]*?)endbfchar/g;
+  let m;
+  while (m = bfcharRe.exec(cmapText)) {
+    const hexes = takeHexes(m[1]);
+    for (let i = 0; i + 1 < hexes.length; i += 2) {
+      const uni = bytesToUnicode(hexToBytes(hexes[i + 1]));
+      if (uni && !map.has(uni)) map.set(uni, hexToBytes(hexes[i]));
+    }
+  }
+  const bfrangeRe = /beginbfrange([\s\S]*?)endbfrange/g;
+  while (m = bfrangeRe.exec(cmapText)) {
+    const body = m[1];
+    const lineRe = /<([0-9a-fA-F]+)>\s*<([0-9a-fA-F]+)>\s*(<[0-9a-fA-F]+>|\[[\s\S]*?\])/g;
+    let lm;
+    while (lm = lineRe.exec(body)) {
+      const lo = parseInt(lm[1], 16);
+      const hi = parseInt(lm[2], 16);
+      const codeLen = Math.ceil(lm[1].length / 2);
+      const dst = lm[3];
+      const codeBytes = (code) => {
+        const out = [];
+        for (let k = codeLen - 1; k >= 0; k--) out.push(code >> 8 * k & 255);
+        return out;
+      };
+      if (dst.startsWith("[")) {
+        const dsts = takeHexes(dst);
+        for (let c = lo, idx = 0; c <= hi && idx < dsts.length; c++, idx++) {
+          const uni = bytesToUnicode(hexToBytes(dsts[idx]));
+          if (uni && !map.has(uni)) map.set(uni, codeBytes(c));
+        }
+      } else {
+        const startBytes = hexToBytes(dst.replace(/[<>]/g, ""));
+        const startUnits = [];
+        for (let i = 0; i + 1 < startBytes.length; i += 2) startUnits.push(startBytes[i] << 8 | startBytes[i + 1]);
+        for (let c = lo; c <= hi && c - lo < 65536; c++) {
+          const units = [...startUnits];
+          units[units.length - 1] += c - lo;
+          const uni = String.fromCharCode(...units);
+          if (uni && !map.has(uni)) map.set(uni, codeBytes(c));
+        }
+      }
+    }
+  }
+  return {
+    encode(text) {
+      const out = [];
+      for (const ch of text) {
+        const bytes = map.get(ch);
+        if (!bytes) return null;
+        out.push(...bytes);
+      }
+      return Uint8Array.from(out);
+    }
+  };
+}
+var MAC_ROMAN_HI = [
+  196,
+  197,
+  199,
+  201,
+  209,
+  214,
+  220,
+  225,
+  224,
+  226,
+  228,
+  227,
+  229,
+  231,
+  233,
+  232,
+  234,
+  235,
+  237,
+  236,
+  238,
+  239,
+  241,
+  243,
+  242,
+  244,
+  246,
+  245,
+  250,
+  249,
+  251,
+  252,
+  8224,
+  176,
+  162,
+  163,
+  167,
+  8226,
+  182,
+  223,
+  174,
+  169,
+  8482,
+  180,
+  168,
+  8800,
+  198,
+  216,
+  8734,
+  177,
+  8804,
+  8805,
+  165,
+  181,
+  8706,
+  8721,
+  8719,
+  960,
+  8747,
+  170,
+  186,
+  937,
+  230,
+  248,
+  191,
+  161,
+  172,
+  8730,
+  402,
+  8776,
+  8710,
+  171,
+  187,
+  8230,
+  160,
+  192,
+  195,
+  213,
+  338,
+  339,
+  8211,
+  8212,
+  8220,
+  8221,
+  8216,
+  8217,
+  247,
+  9674,
+  255,
+  376,
+  8260,
+  8364,
+  8249,
+  8250,
+  64257,
+  64258,
+  8225,
+  183,
+  8218,
+  8222,
+  8240,
+  194,
+  202,
+  193,
+  203,
+  200,
+  205,
+  206,
+  207,
+  204,
+  211,
+  212,
+  63743,
+  210,
+  218,
+  219,
+  217,
+  305,
+  710,
+  732,
+  175,
+  728,
+  729,
+  730,
+  184,
+  733,
+  731,
+  711
+];
+var WIN_ANSI_80_9F = [
+  8364,
+  0,
+  8218,
+  402,
+  8222,
+  8230,
+  8224,
+  8225,
+  710,
+  8240,
+  352,
+  8249,
+  338,
+  0,
+  381,
+  0,
+  0,
+  8216,
+  8217,
+  8220,
+  8221,
+  8226,
+  8211,
+  8212,
+  732,
+  8482,
+  353,
+  8250,
+  339,
+  0,
+  382,
+  376
+];
+function encodingChar(encoding, code) {
+  if (code < 128) return String.fromCharCode(code);
+  const cp = encoding === "MacRomanEncoding" ? MAC_ROMAN_HI[code - 128] : code <= 159 ? WIN_ANSI_80_9F[code - 128] : code;
+  return cp ? String.fromCodePoint(cp) : "";
+}
+function encoderFromSimpleEncoding(encoding, firstChar, lastChar, widths) {
+  const map = /* @__PURE__ */ new Map();
+  for (let code = firstChar; code <= lastChar && code <= 255; code++) {
+    if (widths && !(widths[code - firstChar] > 0)) continue;
+    const uni = encodingChar(encoding, code);
+    if (uni && !map.has(uni)) map.set(uni, code);
+  }
+  return {
+    encode(text) {
+      const out = [];
+      for (const ch of text) {
+        const code = map.get(ch);
+        if (code === void 0) return null;
+        out.push(code);
+      }
+      return Uint8Array.from(out);
+    }
+  };
+}
+
+// ../core/src/bake/fonts.ts
+var STD_FONTS = {
+  sans: [StandardFonts.Helvetica, StandardFonts.HelveticaBold, StandardFonts.HelveticaOblique, StandardFonts.HelveticaBoldOblique],
+  serif: [StandardFonts.TimesRoman, StandardFonts.TimesRomanBold, StandardFonts.TimesRomanItalic, StandardFonts.TimesRomanBoldItalic],
+  mono: [StandardFonts.Courier, StandardFonts.CourierBold, StandardFonts.CourierOblique, StandardFonts.CourierBoldOblique]
+};
+function stdFontFor(bucket, bold, italic) {
+  return STD_FONTS[bucket][(bold ? 1 : 0) + (italic ? 2 : 0)];
+}
+function encoderForFont(doc, page, fontName, cache) {
+  const hit = cache.get(fontName);
+  if (hit !== void 0) return hit;
+  let enc = null;
+  try {
+    const res = page.node.Resources();
+    const fonts = res?.lookup(PDFName3.of("Font"));
+    const fdict = fonts instanceof PDFDict2 ? fonts.lookup(PDFName3.of(fontName)) : null;
+    const tu = fdict instanceof PDFDict2 ? fdict.lookup(PDFName3.of("ToUnicode")) : null;
+    if (tu instanceof PDFRawStream3) {
+      const decoded = decodePDFRawStream2(tu).decode();
+      enc = parseToUnicode(latin12(decoded, 0, decoded.length));
+    } else if (fdict instanceof PDFDict2) {
+      enc = simpleEncodingEncoder(fdict);
+    }
+  } catch {
+    enc = null;
+  }
+  cache.set(fontName, enc);
+  return enc;
+}
+function simpleEncodingEncoder(fdict) {
+  const subtype = fdict.lookupMaybe(PDFName3.of("Subtype"), PDFName3)?.decodeText();
+  if (subtype !== "TrueType" && subtype !== "Type1") return null;
+  const encRaw = fdict.lookup(PDFName3.of("Encoding"));
+  let encName;
+  if (encRaw instanceof PDFName3) encName = encRaw.decodeText();
+  else if (encRaw instanceof PDFDict2) {
+    if (encRaw.has(PDFName3.of("Differences"))) return null;
+    encName = encRaw.lookupMaybe(PDFName3.of("BaseEncoding"), PDFName3)?.decodeText();
+  }
+  if (encName !== "MacRomanEncoding" && encName !== "WinAnsiEncoding") return null;
+  const firstChar = fdict.lookupMaybe(PDFName3.of("FirstChar"), PDFNumber)?.asNumber();
+  const lastChar = fdict.lookupMaybe(PDFName3.of("LastChar"), PDFNumber)?.asNumber();
+  if (firstChar === void 0 || lastChar === void 0) return null;
+  let widths = null;
+  const w = fdict.lookupMaybe(PDFName3.of("Widths"), PDFArray2);
+  if (w) widths = w.asArray().map((v) => v instanceof PDFNumber ? v.asNumber() : 0);
+  return encoderFromSimpleEncoding(encName, firstChar, lastChar, widths);
+}
+
+// ../core/src/bake/textEmit.ts
+function relTm(o, ratio, x, y) {
+  const m = o.matrix;
+  const abs = [m[0] * ratio, m[1] * ratio, m[2] * ratio, m[3] * ratio, x, y];
+  const inv = invert(o.ctm);
+  return inv ? mul(abs, inv) : null;
+}
+function reemitBlock(o, src, ratio, x, y, ov = {}) {
+  const show = o.op === "Tj" || o.op === "TJ" ? latin12(src, o.record.start, o.record.end) : o.op === "'" ? `${o.record.operands[0]?.raw ?? "()"} Tj` : `${o.record.operands[2]?.raw ?? "()"} Tj`;
+  const t = relTm(o, ratio, x, y);
+  if (!t) return null;
+  const colorRaw = ov.colorRaw ?? o.fillColorRaw;
+  const color = colorRaw ? `${colorRaw} ` : "";
+  const tc = ov.charSpacing ?? o.charSpacing * ratio;
+  const tz = ov.hScale ?? o.hScale;
+  return `q BT ${color}/${o.fontName} ${fmt(o.fontSize)} Tf ${fmt(tc)} Tc ${fmt(o.wordSpacing * ratio)} Tw ${fmt(tz)} Tz ${fmt(t[0])} ${fmt(t[1])} ${fmt(t[2])} ${fmt(t[3])} ${fmt(t[4])} ${fmt(t[5])} Tm ${show} ET Q`;
+}
+function newTextBlock(o, ratio, x, y, bytes, ov = {}) {
+  const t = relTm(o, ratio, x, y);
+  if (!t) return null;
+  const colorRaw = ov.colorRaw ?? o.fillColorRaw;
+  const color = colorRaw ? `${colorRaw} ` : "";
+  const tc = ov.charSpacing ?? 0;
+  const tz = ov.hScale ?? o.hScale;
+  return `q BT ${color}/${o.fontName} ${fmt(o.fontSize)} Tf ${fmt(tc)} Tc 0 Tw ${fmt(tz)} Tz ${fmt(t[0])} ${fmt(t[1])} ${fmt(t[2])} ${fmt(t[3])} ${fmt(t[4])} ${fmt(t[5])} Tm ${hexString(bytes)} Tj ET Q`;
+}
+
+// ../core/src/bake/text.ts
+var underlineRectsFor = (edit, fillRects) => {
+  const size = edit.original.fontSize;
+  const lines = edit.original.baselines?.length ? edit.original.baselines : [edit.original.baseline];
+  const x0 = edit.original.x - 2;
+  const x1 = edit.original.x + edit.original.width + 2;
+  return fillRects.filter(
+    (r2) => r2.height <= Math.max(1.5, size * 0.12) && r2.x < x1 && r2.x + r2.width > x0 && lines.some((b) => Math.abs(r2.y - (b - size * 0.11)) <= size * 0.2)
+  );
+};
+var escapesClip = (o, x, y) => {
+  if (!o.clip) return false;
+  const m = 1;
+  return x < o.clip.x - m || x > o.clip.x + o.clip.width + m || y < o.clip.y - m || y > o.clip.y + o.clip.height + m;
+};
+var atStreamEnd = (o) => ({ ...o, ctm: IDENTITY });
+var editBasics = (edit) => ({
+  ratio: (edit.fontSize ?? edit.original.fontSize) / edit.original.fontSize,
+  newX: edit.x ?? edit.original.x,
+  newBaseline: edit.baseline ?? edit.original.baseline,
+  styleOv: {
+    charSpacing: edit.charSpacing,
+    hScale: edit.hScale,
+    colorRaw: edit.color ? hexToRg(edit.color) : void 0
+  }
+});
+var VerbatimReemit = class {
+  canHandle(edit) {
+    return edit.text === edit.original.text && edit.font === void 0 && !edit.runs;
+  }
+  emit({ edit, ops, src, fillRects, splices, appendBlocks, report }) {
+    const { ratio, newX, newBaseline, styleOv } = editBasics(edit);
+    const editSplices = [];
+    const editAppends = [];
+    for (const o of ops) {
+      const nx = newX + (o.x - edit.original.x) * ratio;
+      const ny = newBaseline + (o.y - edit.original.baseline) * ratio;
+      const escaped = escapesClip(o, nx, ny);
+      const block = reemitBlock(escaped ? atStreamEnd(o) : o, src, ratio, nx, ny, styleOv);
+      if (!block) {
+        report.warn(`${edit.segmentId}: matriz degenerada \u2014 sin cambios`);
+        return;
+      }
+      if (escaped) {
+        editSplices.push({ start: o.record.start, end: o.record.end, text: "" });
+        editAppends.push(block);
+      } else {
+        editSplices.push({ start: o.record.start, end: o.record.end, text: block });
+      }
+    }
+    splices.push(...editSplices);
+    appendBlocks.push(...editAppends);
+    for (const r2 of underlineRectsFor(edit, fillRects)) {
+      splices.push({ start: r2.start, end: r2.end, text: "" });
+      const nx = newX + (r2.x - edit.original.x) * ratio;
+      const ny = newBaseline + (r2.y - edit.original.baseline) * ratio;
+      const fill = r2.fillColorRaw || "0 0 0 rg";
+      appendBlocks.push(`q ${fill} ${fmt(nx)} ${fmt(ny)} ${fmt(r2.width * ratio)} ${fmt(r2.height * ratio)} re f Q`);
+    }
+    report.apply(`${edit.segmentId}: reubicado/escalado (${ops.length} op${ops.length > 1 ? "s" : ""})`);
+  }
+};
+var StyledRunsReemit = class {
+  canHandle() {
+    return true;
+  }
+  emit(ctx) {
+    const { edit, ops, doc, page, pageNum, encCache, splices, appendBlocks, fallbackDraws, report } = ctx;
+    const { ratio, newX, newBaseline, styleOv } = editBasics(edit);
+    const familyChanged = edit.font !== void 0;
+    for (const o of ops.slice(1)) splices.push({ start: o.record.start, end: o.record.end, text: "" });
+    for (const r2 of underlineRectsFor(edit, ctx.fillRects)) splices.push({ start: r2.start, end: r2.end, text: "" });
+    const firstOp = ops[0];
+    const inlineBlocks = [];
+    const runsToEmit = edit.runs ?? [{
+      text: edit.text,
+      bold: edit.original.bold ?? false,
+      italic: edit.original.italic ?? false,
+      dx: 0
+    }];
+    const fontForStyle = /* @__PURE__ */ new Map();
+    for (const or of edit.original.runs ?? []) {
+      const op = ops.find((o) => Math.abs(o.x - or.x) <= 2.5);
+      const key = `${or.bold}|${or.italic}`;
+      if (op && !fontForStyle.has(key)) fontForStyle.set(key, op.fontName);
+    }
+    const lineRuns = [[]];
+    for (const sr of runsToEmit) {
+      const parts = sr.text.split("\n");
+      parts.forEach((p, i) => {
+        if (i > 0) lineRuns.push([]);
+        if (p) lineRuns[lineRuns.length - 1].push({ ...sr, text: p });
+      });
+    }
+    const leading = (edit.fontSize ?? edit.original.fontSize) * 1.2;
+    const escaped = lineRuns.some((_, li) => escapesClip(firstOp, newX, newBaseline - li * leading));
+    let substituted = 0;
+    for (let li = 0; li < lineRuns.length; li++) {
+      const lineBase = newBaseline - li * leading;
+      for (const sr of lineRuns[li]) {
+        if (!sr.text) continue;
+        const x = newX + sr.dx * ratio;
+        const fontName = familyChanged ? void 0 : fontForStyle.get(`${sr.bold}|${sr.italic}`);
+        const bytes = fontName ? encoderForFont(doc, page, fontName, encCache)?.encode(sr.text) ?? null : null;
+        const runOv = {
+          ...styleOv,
+          colorRaw: sr.color ? hexToRg(sr.color) : styleOv.colorRaw
+        };
+        const srcForBlock = ops.find((o) => o.fontName === fontName) ?? firstOp;
+        const inlineBlock = fontName && bytes ? newTextBlock(escaped ? atStreamEnd(srcForBlock) : srcForBlock, ratio, x, lineBase, bytes, runOv) : null;
+        if (inlineBlock) {
+          inlineBlocks.push(inlineBlock);
+          if (sr.underline && sr.w) {
+            const size = edit.fontSize ?? edit.original.fontSize;
+            const c = sr.color ? hexToRgbObj(sr.color) : edit.color ? hexToRgbObj(edit.color) : rawFillToRgb((ops.find((o) => o.fontName === fontName) ?? firstOp)?.fillColorRaw) ?? { r: 0, g: 0, b: 0 };
+            appendBlocks.push(
+              `q ${fmt(c.r)} ${fmt(c.g)} ${fmt(c.b)} rg ${fmt(x)} ${fmt(lineBase - size * 0.11)} ${fmt(sr.w * ratio)} ${fmt(size * 0.055)} re f Q`
+            );
+          }
+        } else {
+          if (!/^\s+$/.test(sr.text)) {
+            const srcOp = ops.find((o) => o.fontName === fontName) ?? firstOp;
+            const color = sr.color ? hexToRgbObj(sr.color) : edit.color ? hexToRgbObj(edit.color) : rawFillToRgb(srcOp?.fillColorRaw) ?? void 0;
+            fallbackDraws.push({
+              page: pageNum,
+              text: sr.text,
+              x,
+              y: lineBase,
+              size: edit.fontSize ?? edit.original.fontSize,
+              bucket: edit.font ?? edit.original.bucket ?? "sans",
+              bold: sr.bold,
+              italic: sr.italic,
+              color: color ?? void 0,
+              underline: sr.underline
+            });
+          }
+          substituted++;
+        }
+      }
+    }
+    if (escaped) {
+      splices.push({ start: firstOp.record.start, end: firstOp.record.end, text: "" });
+      if (inlineBlocks.length) appendBlocks.push(inlineBlocks.join("\n"));
+    } else {
+      splices.push({ start: firstOp.record.start, end: firstOp.record.end, text: inlineBlocks.join("\n") });
+    }
+    if (substituted && !familyChanged) {
+      report.warn(`${edit.segmentId}: ${substituted} tramo${substituted > 1 ? "s" : ""} sin fuente original disponible (estilo nuevo o subset insuficiente) \u2014 sustituido por est\xE1ndar`);
+    }
+    report.apply(familyChanged ? `${edit.segmentId}: redibujado con fuente est\xE1ndar (cambio de familia)` : `${edit.segmentId}: reescrito por tramos (${runsToEmit.length})`);
+  }
+};
+var textEmitStrategies = [
+  new VerbatimReemit(),
+  new StyledRunsReemit()
+];
+function applySegmentEditsToPage(args) {
+  const { doc, page, pageNum, pageEdits, shows, fillRects, src, splices, appendBlocks, fallbackDraws, report } = args;
+  const encCache = /* @__PURE__ */ new Map();
+  for (const edit of pageEdits) {
+    const { ops, conflict } = matchOps(shows, edit.original);
+    if (conflict) {
+      report.warn(`${edit.segmentId}: ${conflict} \u2014 sin cambios`);
+      continue;
+    }
+    const colorOp = ops.find((o) => rawFillToRgb(o.fillColorRaw));
+    if (colorOp) {
+      const c = rawFillToRgb(colorOp.fillColorRaw);
+      if (c) report.color(edit.segmentId, rgbToHex(c));
+    }
+    if (edit.remove) {
+      for (const o of ops) splices.push({ start: o.record.start, end: o.record.end, text: "" });
+      for (const r2 of underlineRectsFor(edit, fillRects)) splices.push({ start: r2.start, end: r2.end, text: "" });
+      report.apply(`${edit.segmentId}: eliminado`);
+      continue;
+    }
+    const ctx = { doc, page, pageNum, edit, ops, src, encCache, fillRects, splices, appendBlocks, fallbackDraws, report };
+    for (const strategy of textEmitStrategies) {
+      if (strategy.canHandle(edit)) {
+        strategy.emit(ctx);
+        break;
+      }
+    }
+  }
+}
+
+// ../core/src/bake/widgets.ts
+function applyWidgetEdits(doc, edits, report) {
+  if (!edits.length) return;
+  let form;
+  try {
+    form = doc.getForm();
+  } catch {
+    report.warn("el documento no tiene AcroForm \u2014 ediciones de campos saltadas");
+    return;
+  }
+  let touched = false;
+  for (const edit of edits) {
+    const tol = 2.5;
+    let matchedField = null;
+    let matchedWidget = null;
+    for (const field of form.getFields()) {
+      if (field.getName() !== edit.original.fieldName) continue;
+      for (const widget of field.acroField.getWidgets()) {
+        const r2 = widget.getRectangle();
+        if (Math.abs(r2.x - edit.original.x) <= tol && Math.abs(r2.y - edit.original.y) <= tol && Math.abs(r2.width - edit.original.width) <= tol && Math.abs(r2.height - edit.original.height) <= tol) {
+          matchedField = field;
+          matchedWidget = widget;
+          break;
+        }
+      }
+      if (matchedField) break;
+    }
+    if (!matchedField || !matchedWidget) {
+      report.warn(`${edit.widgetId}: campo "${edit.original.fieldName}" no encontrado en su rect \u2014 sin cambios`);
+      continue;
+    }
+    if (edit.remove) {
+      try {
+        form.removeField(matchedField);
+        report.apply(`${edit.widgetId}: campo "${edit.original.fieldName}" eliminado`);
+        touched = true;
+      } catch (err) {
+        report.warn(`${edit.widgetId}: no se pudo eliminar (${err instanceof Error ? err.message : "error"})`);
+      }
+      continue;
+    }
+    matchedWidget.setRectangle({
+      x: edit.x ?? edit.original.x,
+      y: edit.y ?? edit.original.y,
+      width: edit.width ?? edit.original.width,
+      height: edit.height ?? edit.original.height
+    });
+    report.apply(`${edit.widgetId}: campo "${edit.original.fieldName}" reubicado/escalado`);
+    touched = true;
+  }
+  if (touched) {
+    try {
+      form.updateFieldAppearances();
+    } catch {
+    }
+  }
+}
+
+// ../core/src/bake/highlights.ts
+import { PDFArray as PDFArray5, PDFDict as PDFDict5, PDFDocument as PDFDocument6, PDFName as PDFName6, PDFNumber as PDFNumber2, PDFRef as PDFRef5 } from "pdf-lib";
+
+// ../core/src/bake/annotEdits.ts
+import { PDFArray as PDFArray3, PDFDict as PDFDict3, PDFName as PDFName4, PDFRef as PDFRef3 } from "pdf-lib";
+var rectNums = (rect) => {
+  if (rect.size() !== 4) return null;
+  const nums = [0, 1, 2, 3].map((k) => Number(rect.get(k).asNumber?.() ?? NaN));
+  return nums.some(Number.isNaN) ? null : nums;
+};
+function applyAnnotRectEdits(doc, subtype, label, edits, report, onRect) {
+  if (!edits.length) return;
+  const tol = 2;
+  for (const edit of edits) {
+    const page = doc.getPages()[edit.page - 1];
+    if (!page) {
+      report.warn(`${edit.id}: p\xE1gina ${edit.page} fuera de rango \u2014 sin cambios`);
+      continue;
+    }
+    const annots = page.node.lookupMaybe(PDFName4.of("Annots"), PDFArray3);
+    if (!annots) {
+      report.warn(`${edit.id}: la p\xE1gina no tiene /Annots \u2014 sin cambios`);
+      continue;
+    }
+    let done = false;
+    for (let i = 0; i < annots.size(); i++) {
+      const raw = annots.get(i);
+      const dict = raw instanceof PDFRef3 ? doc.context.lookup(raw) : raw;
+      if (!(dict instanceof PDFDict3)) continue;
+      if (dict.get(PDFName4.of("Subtype")) !== PDFName4.of(subtype)) continue;
+      const rect = dict.lookupMaybe(PDFName4.of("Rect"), PDFArray3);
+      const nums = rect ? rectNums(rect) : null;
+      if (!nums) continue;
+      const [ax, ay, bx, by] = nums;
+      const rx = Math.min(ax, bx), ry = Math.min(ay, by), rw = Math.abs(bx - ax), rh = Math.abs(by - ay);
+      if (Math.abs(rx - edit.original.x) <= tol && Math.abs(ry - edit.original.y) <= tol && Math.abs(rw - edit.original.width) <= tol && Math.abs(rh - edit.original.height) <= tol) {
+        if (edit.remove) {
+          annots.remove(i);
+          report.apply(`${edit.id}: ${label} eliminado`);
+        } else {
+          const nx = edit.x ?? rx, ny = edit.y ?? ry, nw = edit.width ?? rw, nh = edit.height ?? rh;
+          dict.set(PDFName4.of("Rect"), doc.context.obj([nx, ny, nx + nw, ny + nh]));
+          onRect?.(dict, nx, ny, nw, nh, edit);
+          report.apply(`${edit.id}: ${label} ${edit.color ? "recoloreado" : "reubicado/escalado"}`);
+        }
+        done = true;
+        break;
+      }
+    }
+    if (!done) report.warn(`${edit.id}: no se encontr\xF3 la anotaci\xF3n en su rect original \u2014 sin cambios`);
+  }
+}
+
+// ../core/src/bake/createNodes.ts
+init_model();
+import {
+  PDFArray as PDFArray4,
+  PDFDict as PDFDict4,
+  PDFDocument as PDFDocument5,
+  PDFName as PDFName5,
+  PDFRef as PDFRef4,
+  PDFString,
+  degrees,
+  rgb
+} from "pdf-lib";
+var hexToRgb = (hex) => {
+  const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+  const v = m ? parseInt(m[1], 16) : 0;
+  return rgb((v >> 16 & 255) / 255, (v >> 8 & 255) / 255, (v & 255) / 255);
+};
+var FIELD_BASE_NAME = {
+  text: "texto",
+  checkbox: "check",
+  radio: "radio",
+  select: "select",
+  list: "lista",
+  button: "boton",
+  signature: "firma"
+};
+function uniqueName(existing, base) {
+  let n = 1;
+  while (existing.has(`${base}_${n}`)) n++;
+  return `${base}_${n}`;
+}
+var MODERN_WIDGET = {
+  borderWidth: 1,
+  borderColor: rgb(0.72, 0.77, 0.85),
+  backgroundColor: rgb(0.955, 0.965, 0.985)
+};
+function addSignatureField(doc, page, name, rect) {
+  const ctx = doc.context;
+  const dict = ctx.obj({
+    Type: "Annot",
+    Subtype: "Widget",
+    FT: "Sig",
+    T: PDFString.of(name),
+    // string, no name — pdf.js lee el fieldName de acá
+    Rect: rect,
+    F: 4,
+    // print
+    P: page.ref
+  });
+  const ref = ctx.register(dict);
+  const annots = page.node.lookupMaybe(PDFName5.of("Annots"), PDFArray4) ?? ctx.obj([]);
+  annots.push(ref);
+  page.node.set(PDFName5.of("Annots"), annots);
+  const form = doc.getForm();
+  form.acroForm.addField(ref);
+}
+async function addFormField(pdfBytes, spec) {
+  const doc = await PDFDocument5.load(pdfBytes, { ignoreEncryption: true });
+  const page = doc.getPages()[spec.page - 1];
+  if (!page) throw new Error(`p\xE1gina ${spec.page} fuera de rango`);
+  const form = doc.getForm();
+  const existing = new Set(form.getFields().map((f) => f.getName()));
+  const name = spec.name && !existing.has(spec.name) ? spec.name : uniqueName(existing, FIELD_BASE_NAME[spec.type]);
+  const size = FIELD_DEFAULT_SIZE[spec.type];
+  const width = spec.width ?? size.width;
+  const height = spec.height ?? size.height;
+  const rect = { x: spec.x, y: spec.y, width, height };
+  const styled = { ...rect, ...MODERN_WIDGET };
+  switch (spec.type) {
+    case "text": {
+      const f = form.createTextField(name);
+      f.addToPage(page, styled);
+      try {
+        f.setFontSize(10);
+      } catch {
+      }
+      break;
+    }
+    case "checkbox": {
+      const f = form.createCheckBox(name);
+      f.addToPage(page, styled);
+      break;
+    }
+    case "radio": {
+      const f = form.createRadioGroup(name);
+      f.addOptionToPage("opcion_1", page, styled);
+      break;
+    }
+    case "select": {
+      const f = form.createDropdown(name);
+      f.addOptions(["Opci\xF3n 1"]);
+      f.addToPage(page, styled);
+      break;
+    }
+    case "list": {
+      const f = form.createOptionList(name);
+      f.addOptions(["Opci\xF3n 1"]);
+      f.addToPage(page, styled);
+      break;
+    }
+    case "button": {
+      const f = form.createButton(name);
+      f.addToPage(name, page, styled);
+      break;
+    }
+    case "signature": {
+      addSignatureField(doc, page, name, [spec.x, spec.y, spec.x + width, spec.y + height]);
+      break;
+    }
+  }
+  try {
+    form.updateFieldAppearances();
+  } catch {
+  }
+  return { pdf: await doc.save(), name };
+}
+async function addText(pdfBytes, spec) {
+  const doc = await PDFDocument5.load(pdfBytes, { ignoreEncryption: true });
+  const page = doc.getPages()[spec.page - 1];
+  if (!page) throw new Error(`p\xE1gina ${spec.page} fuera de rango`);
+  const size = spec.size ?? 11;
+  const font = await doc.embedFont(stdFontFor(spec.bucket ?? "sans", spec.bold ?? false, spec.italic ?? false));
+  page.drawText(spec.text, {
+    x: spec.x,
+    y: spec.y - size,
+    size,
+    font,
+    color: spec.color ? hexToRgb(spec.color) : rgb(0, 0, 0),
+    lineHeight: size * 1.35,
+    maxWidth: Math.max(80, page.getWidth() - spec.x - 40)
+  });
+  return { pdf: await doc.save() };
+}
+async function addWatermark(pdfBytes, spec) {
+  const doc = await PDFDocument5.load(pdfBytes, { ignoreEncryption: true });
+  const font = await doc.embedFont(stdFontFor("sans", true, false));
+  for (const page of doc.getPages()) {
+    const w = page.getWidth();
+    const h = page.getHeight();
+    const size = Math.min(84, w * 1.1 / Math.max(4, spec.text.length) / 0.55);
+    page.drawText(spec.text, {
+      x: w * 0.14,
+      y: h * 0.28,
+      size,
+      font,
+      rotate: degrees(38),
+      opacity: spec.opacity ?? 0.14,
+      color: spec.color ? hexToRgb(spec.color) : rgb(0.4, 0.4, 0.45)
+    });
+  }
+  return { pdf: await doc.save() };
+}
+async function addHeaderFooter(pdfBytes, spec) {
+  const doc = await PDFDocument5.load(pdfBytes, { ignoreEncryption: true });
+  const font = await doc.embedFont(stdFontFor("sans", false, false));
+  const pages = doc.getPages();
+  const gray = rgb(0.35, 0.35, 0.4);
+  pages.forEach((page, i) => {
+    const w = page.getWidth();
+    const h = page.getHeight();
+    if (spec.header) page.drawText(spec.header, { x: 40, y: h - 28, size: 9, font, color: gray });
+    if (spec.footer) page.drawText(spec.footer, { x: 40, y: 18, size: 9, font, color: gray });
+    if (spec.pageNumbers) {
+      const label = `P\xE1gina ${i + 1} de ${pages.length}`;
+      const lw = font.widthOfTextAtSize(label, 9);
+      page.drawText(label, { x: w - 40 - lw, y: 18, size: 9, font, color: gray });
+    }
+  });
+  return { pdf: await doc.save() };
+}
+function highlightAppearance(ctx, colorHex, w, h) {
+  const c = colorHex ? hexToRgb(colorHex) : rgb(1, 0.84, 0);
+  const gsRef = ctx.register(ctx.obj({ Type: "ExtGState", BM: "Multiply", ca: 0.55, CA: 0.55 }));
+  const ap = ctx.stream(`/GS gs ${fmt(c.red)} ${fmt(c.green)} ${fmt(c.blue)} rg 0 0 ${fmt(w)} ${fmt(h)} re f`, {
+    Type: "XObject",
+    Subtype: "Form",
+    FormType: 1,
+    BBox: [0, 0, w, h],
+    Resources: ctx.obj({ ExtGState: ctx.obj({ GS: gsRef }) })
+  });
+  return { apRef: ctx.register(ap), color: [c.red, c.green, c.blue] };
+}
+async function addHighlight(pdfBytes, spec) {
+  const doc = await PDFDocument5.load(pdfBytes, { ignoreEncryption: true });
+  const page = doc.getPages()[spec.page - 1];
+  if (!page) throw new Error(`p\xE1gina ${spec.page} fuera de rango`);
+  const ctx = doc.context;
+  const x = spec.x - 1, y = spec.y - 1, w = spec.width + 2, h = spec.height + 2;
+  const { apRef, color } = highlightAppearance(ctx, spec.color, w, h);
+  const dict = ctx.obj({
+    Type: "Annot",
+    Subtype: "Highlight",
+    Rect: [x, y, x + w, y + h],
+    // QuadPoints ISO 32000: UL UR LL LR (y crece hacia arriba).
+    QuadPoints: [x, y + h, x + w, y + h, x, y, x + w, y],
+    C: color,
+    CA: 0.55,
+    AP: ctx.obj({ N: apRef })
+  });
+  const ref = ctx.register(dict);
+  const annots = page.node.lookupMaybe(PDFName5.of("Annots"), PDFArray4) ?? ctx.obj([]);
+  annots.push(ref);
+  page.node.set(PDFName5.of("Annots"), annots);
+  return { pdf: await doc.save() };
+}
+async function addLink(pdfBytes, spec) {
+  const doc = await PDFDocument5.load(pdfBytes, { ignoreEncryption: true });
+  const page = doc.getPages()[spec.page - 1];
+  if (!page) throw new Error(`p\xE1gina ${spec.page} fuera de rango`);
+  const ctx = doc.context;
+  const dict = ctx.obj({
+    Type: "Annot",
+    Subtype: "Link",
+    Rect: [spec.x, spec.y, spec.x + spec.width, spec.y + spec.height],
+    Border: [0, 0, 0],
+    A: ctx.obj({ Type: "Action", S: "URI", URI: PDFString.of(spec.url) })
+  });
+  const ref = ctx.register(dict);
+  const annots = page.node.lookupMaybe(PDFName5.of("Annots"), PDFArray4) ?? ctx.obj([]);
+  annots.push(ref);
+  page.node.set(PDFName5.of("Annots"), annots);
+  return { pdf: await doc.save() };
+}
+async function insertImage(pdfBytes, spec) {
+  const doc = await PDFDocument5.load(pdfBytes, { ignoreEncryption: true });
+  const page = doc.getPages()[spec.page - 1];
+  if (!page) throw new Error(`p\xE1gina ${spec.page} fuera de rango`);
+  const image = /png$/i.test(spec.mime) ? await doc.embedPng(spec.bytes) : await doc.embedJpg(spec.bytes);
+  const maxW = spec.maxWidth ?? 240;
+  const ratio = image.width > maxW ? maxW / image.width : 1;
+  const width = image.width * ratio;
+  const height = image.height * ratio;
+  const rect = { x: spec.x, y: spec.y - height, width, height };
+  page.drawImage(image, rect);
+  return { pdf: await doc.save(), rect };
+}
+
+// ../core/src/bake/highlights.ts
+function applyHighlightEdits(doc, edits, report) {
+  applyAnnotRectEdits(
+    doc,
+    "Highlight",
+    "resaltado",
+    edits.map((e) => ({ id: e.highlightId, page: e.page, x: e.x, y: e.y, width: e.width, height: e.height, color: e.color, remove: e.remove, original: e.original })),
+    report,
+    (dict, nx, ny, nw, nh, edit) => {
+      dict.set(PDFName6.of("QuadPoints"), doc.context.obj([nx, ny + nh, nx + nw, ny + nh, nx, ny, nx + nw, ny]));
+      if (edit.color) {
+        const { apRef, color } = highlightAppearance(doc.context, edit.color, nw, nh);
+        dict.set(PDFName6.of("C"), doc.context.obj(color));
+        dict.set(PDFName6.of("AP"), doc.context.obj({ N: apRef }));
+      }
+    }
+  );
+}
+
+// ../core/src/bake/links.ts
+function applyLinkEdits(doc, edits, report) {
+  applyAnnotRectEdits(
+    doc,
+    "Link",
+    "link",
+    edits.map((e) => ({ id: e.linkId, page: e.page, x: e.x, y: e.y, width: e.width, height: e.height, remove: e.remove, original: e.original })),
+    report
+  );
+}
+
+// ../core/src/bake/fallback.ts
+import { rgb as rgb2 } from "pdf-lib";
+async function drawFallbackTexts(doc, draws, report) {
+  if (!draws.length) return;
+  const pages = doc.getPages();
+  const fontCache = /* @__PURE__ */ new Map();
+  for (const d of draws) {
+    const key = `${d.bucket}|${d.bold}|${d.italic}`;
+    let font = fontCache.get(key);
+    if (!font) {
+      font = await doc.embedFont(stdFontFor(d.bucket, d.bold, d.italic));
+      fontCache.set(key, font);
+    }
+    const page = pages[d.page - 1];
+    const color = d.color ? rgb2(d.color.r, d.color.g, d.color.b) : rgb2(0, 0, 0);
+    const drawUnderline = () => {
+      if (!d.underline || !font) return;
+      const w = font.widthOfTextAtSize(d.text, d.size);
+      page.drawRectangle({ x: d.x, y: d.y - d.size * 0.11, width: w, height: d.size * 0.055, color });
+    };
+    try {
+      page.drawText(d.text, { x: d.x, y: d.y, size: d.size, font, color });
+      drawUnderline();
+    } catch {
+      const clean = [...d.text].filter((c) => c.charCodeAt(0) <= 255).join("");
+      try {
+        page.drawText(clean, { x: d.x, y: d.y, size: d.size, font, color });
+        report.warn(`p${d.page}: caracteres no representables descartados en "${d.text.slice(0, 24)}\u2026"`);
+      } catch {
+        report.warn(`p${d.page}: no se pudo dibujar el reemplazo "${d.text.slice(0, 24)}\u2026"`);
+      }
+    }
+  }
+}
+
+// ../core/src/bake/report.ts
+var BakeReport = class {
+  applied = [];
+  warnings = [];
+  colors = {};
+  apply(message) {
+    this.applied.push(message);
+  }
+  warn(message) {
+    this.warnings.push(message);
+  }
+  color(segmentId, hex) {
+    this.colors[segmentId] = hex;
+  }
+  finish(pdf) {
+    return { pdf, applied: this.applied, warnings: this.warnings, colors: this.colors };
+  }
+};
+
+// ../core/src/bake/bake.ts
+var groupByPage = (items) => {
+  const out = /* @__PURE__ */ new Map();
+  for (const item of items) out.set(item.page, [...out.get(item.page) ?? [], item]);
+  return out;
+};
+async function bakeSegmentEdits(pdfBytes, edits, imageEdits = [], widgetEdits = [], highlightEdits = [], linkEdits = []) {
+  const doc = await PDFDocument8.load(pdfBytes, { ignoreEncryption: true });
+  const pages = doc.getPages();
+  const report = new BakeReport();
+  const fallbackDraws = [];
+  applyWidgetEdits(doc, widgetEdits, report);
+  applyHighlightEdits(doc, highlightEdits, report);
+  applyLinkEdits(doc, linkEdits, report);
+  const byPage = groupByPage(edits);
+  const imgByPage = groupByPage(imageEdits);
+  const allPages = /* @__PURE__ */ new Set([...byPage.keys(), ...imgByPage.keys()]);
+  for (const pageNum of allPages) {
+    const pageEdits = byPage.get(pageNum) ?? [];
+    const pageImgEdits = imgByPage.get(pageNum) ?? [];
+    const page = pages[pageNum - 1];
+    if (!page) {
+      report.warn(`p\xE1gina ${pageNum} fuera de rango \u2014 ediciones saltadas`);
+      continue;
+    }
+    let src;
+    try {
+      src = pageContentBytes(doc, page);
+    } catch (err) {
+      report.warn(`p\xE1gina ${pageNum}: ${err instanceof Error ? err.message : "stream ilegible"}`);
+      continue;
+    }
+    const { shows, xobjects, fillRects, backstop } = walkContent(src);
+    const splices = [];
+    const appendBlocks = [];
+    applyImageEditsToPage({ doc, page, pageImgEdits, xobjects, backstop, splices, appendBlocks, report });
+    applySegmentEditsToPage({ doc, page, pageNum, pageEdits, shows, fillRects, src, splices, appendBlocks, fallbackDraws, report });
+    if (splices.length || appendBlocks.length) {
+      setPageContents(doc, page, rebuild(src, splices, "", appendBlocks.join("\n")));
+    }
+  }
+  await drawFallbackTexts(doc, fallbackDraws, report);
+  return report.finish(await doc.save());
+}
+
+// ../core/src/bake/forms.ts
+import {
+  PDFArray as PDFArray6,
+  PDFDocument as PDFDocument9,
+  PDFName as PDFName7,
+  PDFRef as PDFRef6,
+  PDFTextField,
+  PDFCheckBox,
+  PDFRadioGroup,
+  PDFDropdown,
+  PDFOptionList,
+  PDFButton
+} from "pdf-lib";
+var nz = (s) => s ? s : void 0;
+function widgetPages(doc) {
+  const map = /* @__PURE__ */ new Map();
+  doc.getPages().forEach((pg, i) => {
+    const annots = pg.node.lookupMaybe(PDFName7.of("Annots"), PDFArray6);
+    if (!annots) return;
+    for (let k = 0; k < annots.size(); k++) {
+      const ref = annots.get(k);
+      map.set(ref instanceof PDFRef6 ? doc.context.lookup(ref) : ref, i + 1);
+    }
+  });
+  return map;
+}
+function rectsOf(field, pageBy) {
+  const out = [];
+  for (const w of field.acroField.getWidgets()) {
+    try {
+      const r2 = w.getRectangle();
+      const as = w.dict.get(PDFName7.of("AS"));
+      out.push({
+        page: pageBy.get(w.dict) ?? 1,
+        x: Math.round(r2.x * 10) / 10,
+        y: Math.round(r2.y * 10) / 10,
+        width: Math.round(r2.width * 10) / 10,
+        height: Math.round(r2.height * 10) / 10,
+        export: as instanceof PDFName7 && as.asString() !== "/Off" ? as.asString().slice(1) : void 0
+      });
+    } catch {
+    }
+  }
+  return out;
+}
+async function readFormFields(pdfBytes) {
+  const doc = await PDFDocument9.load(pdfBytes, { ignoreEncryption: true });
+  let form;
+  try {
+    form = doc.getForm();
+  } catch {
+    return [];
+  }
+  const pageBy = widgetPages(doc);
+  const out = [];
+  for (const f of form.getFields()) {
+    const name = f.getName();
+    const readOnly = f.isReadOnly();
+    const rects = rectsOf(f, pageBy);
+    if (f instanceof PDFTextField) out.push({ name, type: "text", value: nz(f.getText() ?? void 0), readOnly, rects });
+    else if (f instanceof PDFCheckBox) out.push({ name, type: "checkbox", value: f.isChecked() ? "On" : void 0, readOnly, rects });
+    else if (f instanceof PDFRadioGroup) out.push({ name, type: "radio", value: nz(f.getSelected() ?? void 0), options: f.getOptions(), readOnly, rects });
+    else if (f instanceof PDFDropdown) out.push({ name, type: "select", value: nz(f.getSelected()[0]), options: f.getOptions(), readOnly, rects });
+    else if (f instanceof PDFOptionList) out.push({ name, type: "list", value: f.getSelected().length ? f.getSelected() : void 0, options: f.getOptions(), readOnly, rects });
+    else if (f instanceof PDFButton) out.push({ name, type: "button", readOnly, rects });
+    else out.push({ name, type: "signature", readOnly, rects });
+  }
+  return out;
+}
+var isChecked = (v) => v === true || typeof v === "string" && ["on", "true", "yes", "si", "s\xED", "1", "x", "checked"].includes(v.trim().toLowerCase());
+async function setFieldValues(pdfBytes, values) {
+  const doc = await PDFDocument9.load(pdfBytes, { ignoreEncryption: true });
+  const applied = [];
+  const warnings = [];
+  let form;
+  try {
+    form = doc.getForm();
+  } catch {
+    return { pdf: pdfBytes, applied, warnings: ["el documento no tiene formulario (AcroForm)"] };
+  }
+  const byName = new Map(form.getFields().map((f) => [f.getName(), f]));
+  for (const [name, value] of Object.entries(values)) {
+    const field = byName.get(name);
+    if (!field) {
+      warnings.push(`campo "${name}" no existe`);
+      continue;
+    }
+    if (field.isReadOnly()) {
+      warnings.push(`campo "${name}" es read-only \u2014 saltado`);
+      continue;
+    }
+    const badOption = (opts) => {
+      const want = Array.isArray(value) ? value.map(String) : [String(value)];
+      const invalid = want.filter((v) => !opts.includes(v));
+      return invalid.length ? `opci\xF3n(es) inv\xE1lida(s) [${invalid.join(", ")}] \u2014 v\xE1lidas: [${opts.join(", ")}]` : null;
+    };
+    try {
+      if (field instanceof PDFTextField) field.setText(String(value));
+      else if (field instanceof PDFCheckBox) {
+        if (isChecked(value)) field.check();
+        else field.uncheck();
+      } else if (field instanceof PDFRadioGroup) {
+        const b = badOption(field.getOptions());
+        if (b) {
+          warnings.push(`${name}: ${b}`);
+          continue;
+        }
+        field.select(String(value));
+      } else if (field instanceof PDFDropdown) {
+        const b = badOption(field.getOptions());
+        if (b) {
+          warnings.push(`${name}: ${b}`);
+          continue;
+        }
+        field.select(String(value));
+      } else if (field instanceof PDFOptionList) {
+        const b = badOption(field.getOptions());
+        if (b) {
+          warnings.push(`${name}: ${b}`);
+          continue;
+        }
+        field.select(Array.isArray(value) ? value : String(value));
+      } else {
+        warnings.push(`campo "${name}" (${field.constructor.name}) no admite valor`);
+        continue;
+      }
+      applied.push(`${name} = ${JSON.stringify(value)}`);
+    } catch (err) {
+      warnings.push(`${name}: ${err instanceof Error ? err.message : "no se pudo completar"}`);
+    }
+  }
+  if (applied.length) {
+    try {
+      form.updateFieldAppearances();
+    } catch {
+    }
+  }
+  return { pdf: await doc.save(), applied, warnings };
+}
+
+// ../agent/src/session.ts
+init_graph();
+var MIME = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg" };
+var WIDE_FIELD = /nombre|apellido|raz[oó]n|social|domicilio|direcci|empresa|calle|ciudad|cargo/i;
+var NARROW_FIELD = /ruc|dni|n[uú]m|partida|c[oó]digo|fecha|tel[eé]fono|cuit|nit|zip|cp\b/i;
+function targetWidthFor(name, width, fontSize) {
+  if (typeof width === "number" && width > 0) return width;
+  if (WIDE_FIELD.test(name)) return fontSize * 11;
+  if (NARROW_FIELD.test(name)) return fontSize * 5.5;
+  return fontSize * 8;
+}
+var EditSession = class {
+  constructor(doc) {
+    this.doc = doc;
+  }
+  edits = /* @__PURE__ */ new Map();
+  imageEdits = /* @__PURE__ */ new Map();
+  widgetEdits = /* @__PURE__ */ new Map();
+  highlightEdits = /* @__PURE__ */ new Map();
+  linkEdits = /* @__PURE__ */ new Map();
+  creates = [];
+  /** Valores de formulario a COMPLETAR, por nombre de campo (setFieldValues). */
+  fills = /* @__PURE__ */ new Map();
+  seg(id) {
+    for (const p of this.doc.pages) {
+      const s = p.segments.find((x) => x.id === id);
+      if (s) return s;
+    }
+    return void 0;
+  }
+  img(id) {
+    for (const p of this.doc.pages) {
+      const i = p.images.find((x) => x.id === id);
+      if (i) return i;
+    }
+    return void 0;
+  }
+  widget(id) {
+    for (const p of this.doc.pages) {
+      const w = p.widgets.find((x) => x.id === id);
+      if (w) return w;
+    }
+    return void 0;
+  }
+  hlNode(id) {
+    for (const p of this.doc.pages) {
+      const h = p.highlights.find((x) => x.id === id);
+      if (h) return h;
+    }
+    return void 0;
+  }
+  linkNode(id) {
+    for (const p of this.doc.pages) {
+      const l = p.links.find((x) => x.id === id);
+      if (l) return l;
+    }
+    return void 0;
+  }
+  putSeg(seg, patch) {
+    const m = mergeSegmentEdit(seg, this.edits.get(seg.id) ?? null, patch);
+    if (m) this.edits.set(seg.id, m);
+    else this.edits.delete(seg.id);
+  }
+  putImg(img, patch) {
+    const m = mergeImageEdit(img, this.imageEdits.get(img.id) ?? null, patch);
+    if (m) this.imageEdits.set(img.id, m);
+    else this.imageEdits.delete(img.id);
+  }
+  // ── EDICIONES de texto (nodos existentes) ──
+  /** Edita el texto de un nodo. Si el texto NUEVO es más ancho de lo que entra
+   *  en su renglón, el PÁRRAFO se reconstruye (reflow determinístico): lo que
+   *  sobra baja al renglón siguiente en cascada — nunca se superpone ni se sale
+   *  del borde. Texto igual o más corto = camino simple (verbatim + diff). */
+  async editText(id, text) {
+    const s = this.seg(id);
+    if (!s) return `\u26A0\uFE0F No existe el nodo de texto "${id}".`;
+    const styled = applyTextDiff(originalStyledRuns(s), text);
+    const para = this.paragraphOf(s);
+    const avgCharW = s.width / Math.max(1, s.text.length);
+    const fits = text.length <= s.text.length || s.x + text.length * avgCharW <= para.rightEdge + 2;
+    if (fits) {
+      this.putSeg(s, { runs: styled });
+      return `\u2713 Texto ${id}: ${JSON.stringify(s.text)} \u2192 ${JSON.stringify(text)}`;
+    }
+    const toks = this.paragraphToks(para, [], { lineId: s.id, styled, avgCharW });
+    const { extraLines, scale } = await this.reflowApply(s, para, toks);
+    const grew = extraLines ? ` (+${extraLines} rengl\xF3n/es, contenido inferior corrido)` : "";
+    const note = scale < 1 ? " \u26A0 el p\xE1rrafo qued\xF3 justo: revis\xE1 el resultado" : "";
+    return `\u2713 Texto ${id} \u2192 ${JSON.stringify(text)} \u2014 p\xE1rrafo reconstruido${grew}${note}`;
+  }
+  /** Cambia el ESTILO (negrita/itálica) de un nodo de texto entero. El bake
+   *  re-encoda con la variante de fuente correspondiente (si el PDF no la trae
+   *  embebida, cae a la estándar equivalente y lo reporta). */
+  styleText(id, opts) {
+    const s = this.seg(id);
+    if (!s) return `\u26A0\uFE0F No existe el nodo de texto "${id}".`;
+    if (opts.bold === void 0 && opts.italic === void 0) return `\u26A0\uFE0F pas\xE1 bold y/o italic.`;
+    const runs = originalStyledRuns(s).map((r2) => ({
+      ...r2,
+      bold: opts.bold ?? r2.bold,
+      italic: opts.italic ?? r2.italic
+    }));
+    this.putSeg(s, { runs });
+    const parts = [opts.bold !== void 0 ? `bold=${opts.bold}` : "", opts.italic !== void 0 ? `italic=${opts.italic}` : ""].filter(Boolean);
+    return `\u2713 Texto ${id} \u2192 ${parts.join(", ")}`;
+  }
+  moveText(id, x, y) {
+    const s = this.seg(id);
+    if (!s) return `\u26A0\uFE0F No existe el nodo de texto "${id}".`;
+    this.putSeg(s, { x, baseline: y });
+    return `\u2713 Texto ${id} movido a @(${x ?? Math.round(s.x)},${y ?? Math.round(s.baseline)})`;
+  }
+  colorText(id, color) {
+    const s = this.seg(id);
+    if (!s) return `\u26A0\uFE0F No existe el nodo de texto "${id}".`;
+    this.putSeg(s, { color });
+    return `\u2713 Texto ${id} \u2192 color ${color}`;
+  }
+  resizeText(id, fontSize) {
+    const s = this.seg(id);
+    if (!s) return `\u26A0\uFE0F No existe el nodo de texto "${id}".`;
+    this.putSeg(s, { fontSize });
+    return `\u2713 Texto ${id} \u2192 ${fontSize}pt`;
+  }
+  deleteText(id) {
+    const s = this.seg(id);
+    if (!s) return `\u26A0\uFE0F No existe el nodo de texto "${id}".`;
+    this.putSeg(s, { remove: true });
+    return `\u2713 Texto ${id} eliminado`;
+  }
+  // ── EDICIONES de imagen (nodos existentes) ──
+  moveImage(id, patch) {
+    const im = this.img(id);
+    if (!im) return `\u26A0\uFE0F No existe la imagen "${id}".`;
+    this.putImg(im, patch);
+    return `\u2713 Imagen ${id} \u2192 @(${patch.x ?? Math.round(im.x)},${patch.y ?? Math.round(im.y)}) ${patch.width ?? Math.round(im.width)}\xD7${patch.height ?? Math.round(im.height)}`;
+  }
+  deleteImage(id) {
+    const im = this.img(id);
+    if (!im) return `\u26A0\uFE0F No existe la imagen "${id}".`;
+    this.putImg(im, { remove: true });
+    return `\u2713 Imagen ${id} eliminada`;
+  }
+  // ── EDICIONES de campo / highlight / link existentes ──
+  moveField(id, x, y) {
+    const w = this.widget(id);
+    if (!w) return `\u26A0\uFE0F No existe el campo "${id}".`;
+    const m = mergeWidgetEdit(w, this.widgetEdits.get(id) ?? null, { x, y });
+    if (m) this.widgetEdits.set(id, m);
+    else this.widgetEdits.delete(id);
+    return `\u2713 Campo ${id} movido a @(${x ?? Math.round(w.x)},${y ?? Math.round(w.y)})`;
+  }
+  deleteField(id) {
+    const w = this.widget(id);
+    if (!w) return `\u26A0\uFE0F No existe el campo "${id}".`;
+    const m = mergeWidgetEdit(w, this.widgetEdits.get(id) ?? null, { remove: true });
+    if (m) this.widgetEdits.set(id, m);
+    return `\u2713 Campo ${id} eliminado`;
+  }
+  recolorHighlight(id, color) {
+    const h = this.hlNode(id);
+    if (!h) return `\u26A0\uFE0F No existe el resaltado "${id}".`;
+    const m = mergeHighlightEdit(h, this.highlightEdits.get(id) ?? null, { color });
+    if (m) this.highlightEdits.set(id, m);
+    else this.highlightEdits.delete(id);
+    return `\u2713 Resaltado ${id} \u2192 color ${color}`;
+  }
+  deleteHighlight(id) {
+    const h = this.hlNode(id);
+    if (!h) return `\u26A0\uFE0F No existe el resaltado "${id}".`;
+    const m = mergeHighlightEdit(h, this.highlightEdits.get(id) ?? null, { remove: true });
+    if (m) this.highlightEdits.set(id, m);
+    return `\u2713 Resaltado ${id} eliminado`;
+  }
+  deleteLink(id) {
+    const l = this.linkNode(id);
+    if (!l) return `\u26A0\uFE0F No existe el link "${id}".`;
+    const m = mergeLinkEdit(l, this.linkEdits.get(id) ?? null, { remove: true });
+    if (m) this.linkEdits.set(id, m);
+    return `\u2713 Link ${id} eliminado`;
+  }
+  // ── CREACIONES (nodos nuevos — cola aplicada post-bake) ──
+  highlightText(segId, color) {
+    if (!this.seg(segId)) return `\u26A0\uFE0F No existe el nodo de texto "${segId}".`;
+    this.creates.push({ kind: "highlightSeg", segId, color });
+    return `\u2713 Resaltado sobre ${segId}${color ? ` (${color})` : ""}`;
+  }
+  linkText(segId, url) {
+    if (!this.seg(segId)) return `\u26A0\uFE0F No existe el nodo de texto "${segId}".`;
+    this.creates.push({ kind: "linkSeg", segId, url });
+    return `\u2713 Link sobre ${segId} \u2192 ${url}`;
+  }
+  /** Agrega texto nuevo. ANTI-COLISIÓN determinística: si el rect estimado pisa
+   *  texto existente (u otro texto ya encolado), baja renglón a renglón hasta un
+   *  hueco libre — el LLM no tiene que acertar la y exacta. */
+  addTextNode(op) {
+    const page = this.doc.pages.find((p) => p.page === op.page);
+    const size = op.size ?? 11;
+    let y = op.y;
+    if (page) {
+      const estW = Math.min(op.text.length * size * 0.55, page.width - op.x - 20);
+      const collides = (yt) => page.segments.some((sg) => sg.baseline > yt - size * 1.5 && sg.baseline < yt + 2 && sg.x < op.x + estW && sg.x + sg.width > op.x) || this.creates.some((c) => c.kind === "text" && c.page === op.page && Math.abs(c.y - yt) < size * 1.3 && c.x < op.x + estW);
+      let guard = 0;
+      while (collides(y) && y - size * 1.3 > 40 && guard++ < 60) y -= size * 1.3;
+      if (collides(y)) y = op.y;
+    }
+    const moved = Math.abs(y - op.y) > 1;
+    this.creates.push({ kind: "text", ...op, y });
+    return `\u2713 Texto nuevo en p${op.page} @(${op.x},${Math.round(y)})${moved ? ` \u2014 BAJADO desde y=${Math.round(op.y)} (pisaba texto existente)` : ""}: ${JSON.stringify(op.text.slice(0, 40))}`;
+  }
+  insertImageFile(page, x, y, path, maxWidth) {
+    this.creates.push({ kind: "image", page, x, y, path, maxWidth });
+    return `\u2713 Imagen "${path}" en p${page} @(${x},${y})`;
+  }
+  watermark(text, color, opacity) {
+    this.creates.push({ kind: "watermark", text, color, opacity });
+    return `\u2713 Marca de agua: ${JSON.stringify(text)}`;
+  }
+  headerFooter(op) {
+    this.creates.push({ kind: "headerFooter", ...op });
+    return `\u2713 Encabezado/pie aplicado`;
+  }
+  addField(fieldType, page, x, y, width, height, name) {
+    this.creates.push({ kind: "field", fieldType, page, x, y, width, height, name });
+    return `\u2713 Campo ${fieldType} en p${page} @(${x},${y})`;
+  }
+  /* ── REFLOW DE PÁRRAFO (compartido por placeholders_to_fields y edit_text) ──
+   * El LLM nunca calcula geometría: estos helpers tokenizan el párrafo con
+   * anchos MEDIDOS, lo re-envuelven, re-emiten cada renglón con runs anclados a
+   * posiciones calculadas, y hornean+miden EN LOOP hasta que ningún renglón se
+   * pasa del borde ni dos tramos chocan. */
+  /** x por CARÁCTER de un segmento, desde sus runs reales. */
+  charXOf(seg) {
+    const cx = new Array(seg.text.length + 1).fill(seg.x);
+    let cur = 0, lastEnd = seg.x;
+    for (const r2 of seg.runs) {
+      const at = seg.text.indexOf(r2.text, cur);
+      if (at < 0) continue;
+      for (let k = cur; k <= at; k++) cx[k] = lastEnd + (r2.x - lastEnd) * (k - cur) / Math.max(1, at - cur);
+      const w = r2.width / Math.max(1, r2.text.length);
+      for (let k = 0; k <= r2.text.length; k++) cx[at + k] = r2.x + w * k;
+      cur = at + r2.text.length;
+      lastEnd = r2.x + r2.width;
+    }
+    for (let k = cur; k <= seg.text.length; k++) cx[k] = lastEnd;
+    return cx;
+  }
+  /** El párrafo de un segmento: líneas consecutivas con el mismo x de anclaje
+   *  y paso de interlineado regular. */
+  paragraphOf(s) {
+    const page = this.doc.pages.find((p) => p.page === s.page);
+    const sameCol = page.segments.filter((x) => Math.abs(x.x - s.x) < 4 && Math.abs(x.fontSize - s.fontSize) < 2).sort((a2, b) => b.baseline - a2.baseline);
+    const idx = sameCol.findIndex((x) => x.id === s.id);
+    const maxLead = s.fontSize * 1.7;
+    let lo = idx, hi = idx;
+    while (lo > 0 && sameCol[lo - 1].baseline - sameCol[lo].baseline < maxLead) lo--;
+    while (hi + 1 < sameCol.length && sameCol[hi].baseline - sameCol[hi + 1].baseline < maxLead) hi++;
+    const lines = sameCol.slice(lo, hi + 1);
+    const leading = lines.length > 1 ? (lines[0].baseline - lines[lines.length - 1].baseline) / (lines.length - 1) : s.fontSize * 1.15;
+    const rightEdge = Math.max(...lines.map((l) => l.x + l.width));
+    return {
+      page,
+      lines,
+      leading,
+      rightEdge,
+      capacity: rightEdge - s.x,
+      spaceW: s.fontSize * 0.28,
+      paraBottom: lines[lines.length - 1].baseline
+    };
+  }
+  /** Tokens (palabras con ancho medido + estilo, y huecos) de las líneas del
+   *  párrafo. `replace` sustituye el contenido de UNA línea por runs nuevos
+   *  (edit_text): sus palabras se estiman con el ancho medio del segmento. */
+  paragraphToks(para, holes, replace) {
+    const toks = [];
+    for (let k = 0; k < para.lines.length; k++) {
+      const line = para.lines[k];
+      if (replace && line.id === replace.lineId) {
+        for (const run of replace.styled) {
+          for (const m of run.text.matchAll(/\S+/g)) {
+            toks.push({ kind: "word", text: m[0], w: m[0].length * replace.avgCharW, bold: run.bold, italic: run.italic });
+          }
+        }
+        continue;
+      }
+      const text = line.text;
+      const cx = this.charXOf(line);
+      const styleAt = new Array(text.length).fill({ bold: false, italic: false });
+      let sc = 0;
+      for (const r2 of line.runs) {
+        const at = text.indexOf(r2.text, sc);
+        if (at < 0) continue;
+        for (let c = at; c < at + r2.text.length; c++) styleAt[c] = { bold: r2.font.bold, italic: r2.font.italic };
+        sc = at + r2.text.length;
+      }
+      const lineHoles = holes.filter((h) => h.li === k).sort((a2, b) => a2.from - b.from);
+      let pos = 0;
+      const pushWords = (from, to) => {
+        for (const m of text.slice(from, to).matchAll(/\S+/g)) {
+          const a2 = from + m.index, b = a2 + m[0].length;
+          toks.push({ kind: "word", text: m[0], w: cx[b] - cx[a2], bold: styleAt[a2]?.bold ?? false, italic: styleAt[a2]?.italic ?? false });
+        }
+      };
+      for (const h of lineHoles) {
+        pushWords(pos, h.from);
+        toks.push({ kind: "hole", w: 0, hole: h });
+        pos = h.to;
+      }
+      pushWords(pos, text.length);
+    }
+    return toks;
+  }
+  /** Re-envuelve, aplica y MIDE EN LOOP: re-emite cada renglón con runs propios
+   *  (dx calculado, nunca heredado), hornea un preview, y corrige — overflow del
+   *  borde achica los targets de los huecos; tramos que chocan se re-anclan con
+   *  el corrimiento EXACTO medido. Si el párrafo crece, corre lo de abajo. */
+  async reflowApply(s, para, toks) {
+    const { page, lines, leading, rightEdge, capacity, spaceW, paraBottom } = para;
+    const slackBelow = Math.max(0, paraBottom - 60);
+    const maxExtraLines = Math.min(3, Math.floor(slackBelow / leading));
+    const holeW = (t, scale2) => Math.max(25, t.hole.target * scale2);
+    const wrap = (scale2, capShrink2) => {
+      const cap = capacity - capShrink2;
+      const rows = [[]];
+      let curW = 0;
+      for (const t of toks) {
+        const w = t.kind === "hole" ? holeW(t, scale2) : t.w;
+        const sep = rows[rows.length - 1].length ? spaceW : 0;
+        if (curW + sep + w > cap && rows[rows.length - 1].length) {
+          rows.push([]);
+          curW = 0;
+        }
+        rows[rows.length - 1].push(t);
+        curW += (rows[rows.length - 1].length > 1 ? spaceW : 0) + w;
+      }
+      return rows;
+    };
+    const BOUNDARY_PAD = 2;
+    const dxFix = /* @__PURE__ */ new Map();
+    const rowRuns = (row, scale2, rowIdx) => {
+      const runs = [];
+      let cursor = 0;
+      for (const t of row) {
+        const isFirst = runs.length === 0;
+        const sep = isFirst ? 0 : spaceW;
+        const text = t.kind === "word" ? t.text : " ".repeat(Math.max(3, Math.round(holeW(t, scale2) / spaceW)));
+        const w = t.kind === "word" ? t.w : holeW(t, scale2);
+        const bold = t.kind === "word" ? !!t.bold : false;
+        const italic = t.kind === "word" ? !!t.italic : false;
+        const last = runs[runs.length - 1];
+        if (last && (t.kind === "hole" || last.bold === bold && last.italic === italic)) {
+          last.text += (isFirst ? "" : " ") + text;
+        } else {
+          runs.push({ text, bold, italic, dx: cursor + sep + (isFirst ? 0 : BOUNDARY_PAD) });
+        }
+        cursor += sep + w;
+      }
+      void rowIdx;
+      for (const r2 of runs) {
+        const fix = dxFix.get(r2.text.trim().slice(0, 30));
+        if (fix) r2.dx += fix;
+      }
+      return runs;
+    };
+    const createStart = this.creates.length;
+    let scale = 1;
+    let capShrink = 0;
+    let layout = [];
+    let extraLines = 0;
+    let rePage;
+    for (let iter = 0; iter < 6; iter++) {
+      layout = wrap(scale, capShrink);
+      while (layout.length > lines.length + maxExtraLines && scale > 0.3) {
+        scale *= 0.9;
+        layout = wrap(scale, capShrink);
+      }
+      extraLines = Math.max(0, layout.length - lines.length);
+      this.creates.length = createStart;
+      for (const l of lines) this.edits.delete(l.id);
+      for (let k = 0; k < lines.length; k++) {
+        const runs = k < layout.length ? rowRuns(layout[k], scale, k) : [];
+        if (runs.length) this.putSeg(lines[k], { runs });
+        else this.putSeg(lines[k], { remove: true });
+      }
+      for (let e = 0; e < extraLines; e++) {
+        const bl = paraBottom - leading * (e + 1);
+        const text = layout[lines.length + e].map((t) => t.kind === "word" ? t.text : " ".repeat(Math.max(3, Math.round(holeW(t, scale) / spaceW)))).join(" ");
+        this.creates.push({ kind: "text", page: s.page, x: s.x, y: bl + s.fontSize, text, size: s.fontSize });
+      }
+      if (extraLines > 0) {
+        const dy = extraLines * leading;
+        for (const other of page.segments) {
+          if (other.baseline < paraBottom - 1 && !lines.some((l) => l.id === other.id)) {
+            this.putSeg(other, { baseline: other.baseline - dy });
+          }
+        }
+        for (let ci = 0; ci < createStart; ci++) {
+          const c = this.creates[ci];
+          if (c.kind === "field" && c.page === s.page && c.y < paraBottom - 1) c.y -= dy;
+        }
+      }
+      const { pdf } = await this.bake();
+      const re = await graphFromBytes(pdf.slice());
+      rePage = re.pages.find((p) => p.page === s.page);
+      let maxOver = 0;
+      let collided = false;
+      const MIN_GAP = spaceW * 0.7;
+      for (let k = 0; k < layout.length; k++) {
+        const bl = k < lines.length ? lines[k].baseline : paraBottom - leading * (k - lines.length + 1);
+        const rowSegs = (rePage?.segments ?? []).filter((x) => Math.abs(x.baseline - bl) < 6 && x.x >= s.x - 3).sort((a2, b) => a2.x - b.x);
+        const flat = rowSegs.flatMap((seg) => seg.runs).sort((a2, b) => a2.x - b.x);
+        for (let i = 0; i < flat.length; i++) {
+          maxOver = Math.max(maxOver, flat[i].x + flat[i].width - rightEdge);
+          if (i > 0) {
+            const gap = flat[i].x - (flat[i - 1].x + flat[i - 1].width);
+            if (gap < MIN_GAP) {
+              collided = true;
+              const key = flat[i].text.trim().slice(0, 30);
+              dxFix.set(key, (dxFix.get(key) ?? 0) + (MIN_GAP - gap));
+            }
+          }
+        }
+      }
+      const overflow = maxOver > 3;
+      if (!overflow && !collided) break;
+      if (overflow) {
+        capShrink += maxOver + spaceW;
+        scale *= 0.96;
+      }
+    }
+    return { layout, rePage, scale, extraLines };
+  }
+  /**
+   * DETERMINÍSTICO — el LLM DETECTA (pasa los substrings de placeholder + nombre
+   * y opcionalmente el ancho útil) y el CÓDIGO hace TODO el layout: campos con
+   * ancho ÚTIL (nombre ~110pt, número ~55pt), párrafo reconstruido si hace falta
+   * (renglón extra + contenido inferior corrido), loop de medición hasta que
+   * todo queda dentro, y cada campo sobre el HUECO REAL medido del preview.
+   * `id` puede ser cualquier línea del párrafo; `fields` en orden de lectura.
+   */
+  async placeholdersToFields(id, fields) {
+    const s = this.seg(id);
+    if (!s) return `\u26A0\uFE0F No existe el nodo de texto "${id}".`;
+    if (!fields.length) return `\u26A0\uFE0F placeholders_to_fields necesita al menos un {placeholder,name}.`;
+    const para = this.paragraphOf(s);
+    const { lines, leading, rightEdge, paraBottom } = para;
+    if (lines.some((l) => this.edits.has(l.id))) {
+      return `\u21A9\uFE0E Ese p\xE1rrafo ya fue convertido en esta sesi\xF3n (sus placeholders ya son campos). No repitas la llamada.`;
+    }
+    const holes = [];
+    let li = 0, off = 0;
+    for (const f of fields) {
+      if (!f.placeholder) return `\u26A0\uFE0F un field vino sin placeholder.`;
+      let at = -1;
+      while (li < lines.length) {
+        at = lines[li].text.indexOf(f.placeholder, off);
+        if (at >= 0) break;
+        li++;
+        off = 0;
+      }
+      if (at < 0) return `\u26A0\uFE0F no encontr\xE9 ${JSON.stringify(f.placeholder)} en el p\xE1rrafo de ${id} (us\xE1 el texto EXACTO, en orden de lectura).`;
+      holes.push({ li, from: at, to: at + f.placeholder.length, name: (f.name || "").trim() || `campo_${holes.length + 1}`, target: targetWidthFor(f.name ?? "", f.width, s.fontSize) });
+      off = at + f.placeholder.length;
+    }
+    const toks = this.paragraphToks(para, holes);
+    const { layout, rePage, scale, extraLines } = await this.reflowApply(s, para, toks);
+    const made = [];
+    let holeCursor = 0;
+    for (let k = 0; k < layout.length && holeCursor < holes.length; k++) {
+      const rowHoles = layout[k].filter((t) => t.kind === "hole").map((t) => t.hole);
+      if (!rowHoles.length) continue;
+      const bl = k < lines.length ? lines[k].baseline : paraBottom - leading * (k - lines.length + 1);
+      const rowSegs = (rePage?.segments ?? []).filter((x) => Math.abs(x.baseline - bl) < 6 && x.x >= s.x - 3 && x.x <= rightEdge + 8).sort((a2, b) => a2.x - b.x);
+      const gaps = [];
+      const GAP_MIN = 10;
+      if (rowSegs.length && rowSegs[0].x - s.x > GAP_MIN) gaps.push({ from: s.x, to: rowSegs[0].x });
+      for (let i = 0; i < rowSegs.length; i++) {
+        const from = rowSegs[i].x + rowSegs[i].width;
+        const to = i + 1 < rowSegs.length ? rowSegs[i + 1].x : rightEdge;
+        if (to - from > GAP_MIN) gaps.push({ from, to });
+      }
+      const size = rowSegs[0]?.fontSize ?? s.fontSize;
+      const rbl = rowSegs[0]?.baseline ?? bl;
+      for (let i = 0; i < rowHoles.length && holeCursor < holes.length; i++, holeCursor++) {
+        const g = gaps[i];
+        if (!g) {
+          made.push(`(\u26A0 sin hueco medible para ${rowHoles[i].name})`);
+          continue;
+        }
+        this.creates.push({
+          kind: "field",
+          fieldType: "text",
+          page: s.page,
+          x: Math.round((g.from + 1) * 100) / 100,
+          y: Math.round((rbl - 2) * 100) / 100,
+          width: Math.round(Math.max(20, g.to - g.from - 2) * 100) / 100,
+          height: Math.round((size + 2) * 100) / 100,
+          name: rowHoles[i].name
+        });
+        made.push(`${rowHoles[i].name} @(${Math.round(g.from + 1)},${Math.round(rbl - 2)}) ${Math.round(g.to - g.from - 2)}pt`);
+      }
+    }
+    const grew = extraLines ? ` \xB7 p\xE1rrafo reconstruido (+${extraLines} rengl\xF3n/es, contenido inferior corrido)` : "";
+    const shrunk = scale < 1 ? ` \xB7 targets al ${Math.round(scale * 100)}% para entrar en p\xE1gina` : "";
+    return `\u2713 ${made.length} campo(s) con ancho \xFAtil sobre huecos REALES (medidos tras hornear)${grew}${shrunk}: ${made.join(" \xB7 ")}`;
+  }
+  /** COMPLETA un campo de formulario por su NOMBRE o por su id de widget
+   *  ([[p1-w3]] de la vista de Lectura — se resuelve al fieldName). Valor:
+   *  texto para text/select/radio, true/false para checkbox. Determinístico. */
+  fillField(nameOrId, value) {
+    let fieldName = nameOrId;
+    if (!this.doc.pages.some((p) => p.widgets.some((w) => w.fieldName === fieldName))) {
+      const byId = this.widget(nameOrId.replace(/^\[\[|\]\]$/g, ""));
+      if (!byId) return `\u26A0\uFE0F No existe un campo llamado "${nameOrId}" (ni como fieldName ni como id).`;
+      fieldName = byId.fieldName;
+    }
+    this.fills.set(fieldName, value);
+    return `\u2713 Campo "${fieldName}" \u2190 ${JSON.stringify(value)}`;
+  }
+  /** COMPLETA VARIOS campos de una (por fieldName o id de widget) — UNA sola tool
+   *  call en vez de N idas y vueltas con el modelo (clave para forms grandes). */
+  fillFields(entries) {
+    const lines = entries.map((e) => this.fillField(e.name, e.value));
+    return lines.join("\n");
+  }
+  /** Precarga ediciones ya existentes (p. ej. las pendientes del editor UI). */
+  seed(edits = [], imageEdits = []) {
+    for (const e of edits) this.edits.set(e.segmentId, e);
+    for (const e of imageEdits) this.imageEdits.set(e.imageId, e);
+  }
+  /** Ediciones de texto/imagen acumuladas (lo que el editor sabe aplicar a su
+   *  estado local; las creaciones/annotations se hornean en el server/CLI). */
+  getEdits() {
+    return { edits: [...this.edits.values()], imageEdits: [...this.imageEdits.values()] };
+  }
+  /** Cantidad total de cambios pendientes. */
+  get count() {
+    return this.edits.size + this.imageEdits.size + this.widgetEdits.size + this.highlightEdits.size + this.linkEdits.size + this.creates.length + this.fills.size;
+  }
+  /** ¿Hay cambios que el editor NO puede reflejar con getEdits() (creaciones,
+   *  ediciones de annotations, o llenado de formularios)? El server los hornea +
+   *  persiste en vez de devolverlos como seg/img edits. */
+  get hasBakedOps() {
+    return this.creates.length + this.widgetEdits.size + this.highlightEdits.size + this.linkEdits.size + this.fills.size > 0;
+  }
+  summary() {
+    const parts = [];
+    for (const e of this.edits.values()) parts.push(e.remove ? `${e.segmentId}: eliminar` : `${e.segmentId}: editar`);
+    for (const e of this.imageEdits.values()) parts.push(e.remove ? `${e.imageId}: eliminar` : `${e.imageId}: mover/escalar`);
+    for (const e of this.widgetEdits.values()) parts.push(`${e.widgetId}: campo`);
+    for (const e of this.highlightEdits.values()) parts.push(`${e.highlightId}: resaltado`);
+    for (const e of this.linkEdits.values()) parts.push(`${e.linkId}: link`);
+    for (const c of this.creates) parts.push(`+${c.kind}`);
+    for (const [name] of this.fills) parts.push(`${name}: completar`);
+    return parts.join(" \xB7 ") || "(sin cambios)";
+  }
+  /** Aplica una CREACIÓN sobre los bytes ya horneados (bytes→bytes). */
+  async applyCreate(pdf, op) {
+    switch (op.kind) {
+      case "highlightSeg": {
+        const s = this.seg(op.segId);
+        const g = effectiveGeometry(s, this.edits.get(op.segId) ?? null);
+        return (await addHighlight(pdf, { page: s.page, x: g.x, y: g.y, width: g.width, height: g.height, color: op.color })).pdf;
+      }
+      case "linkSeg": {
+        const s = this.seg(op.segId);
+        const g = effectiveGeometry(s, this.edits.get(op.segId) ?? null);
+        return (await addLink(pdf, { page: s.page, x: g.x, y: g.y, width: g.width, height: g.height, url: op.url })).pdf;
+      }
+      case "text":
+        return (await addText(pdf, op)).pdf;
+      case "image": {
+        const bytes = new Uint8Array(await readFile2(op.path));
+        const ext = op.path.split(".").pop()?.toLowerCase() ?? "";
+        const mime = MIME[ext];
+        if (!mime) throw new Error(`imagen no soportada (${op.path}): solo PNG/JPEG`);
+        return (await insertImage(pdf, { page: op.page, x: op.x, y: op.y, bytes, mime, maxWidth: op.maxWidth })).pdf;
+      }
+      case "watermark":
+        return (await addWatermark(pdf, { text: op.text, opacity: op.opacity, color: op.color })).pdf;
+      case "headerFooter":
+        return (await addHeaderFooter(pdf, { header: op.header, footer: op.footer, pageNumbers: op.pageNumbers })).pdf;
+      case "field":
+        return (await addFormField(pdf, { type: op.fieldType, page: op.page, x: op.x, y: op.y, width: op.width, height: op.height, name: op.name })).pdf;
+    }
+  }
+  /** Hornea TODO (ediciones + annotations + creaciones) y devuelve los bytes. */
+  async bake() {
+    const imgs = promoteMovedImages([...this.imageEdits.values()]);
+    const r2 = await bakeSegmentEdits(
+      this.doc.bytes.slice(),
+      [...this.edits.values()],
+      imgs,
+      [...this.widgetEdits.values()],
+      [...this.highlightEdits.values()],
+      [...this.linkEdits.values()]
+    );
+    let pdf = r2.pdf;
+    for (const op of this.creates) {
+      pdf = await this.applyCreate(pdf, op);
+      r2.applied.push(`+${op.kind}`);
+    }
+    if (this.fills.size) {
+      const res = await setFieldValues(pdf, Object.fromEntries(this.fills));
+      pdf = res.pdf;
+      r2.applied.push(...res.applied.map((a2) => `campo ${a2}`));
+      r2.warnings.push(...res.warnings);
+    }
+    return { pdf, applied: r2.applied, warnings: r2.warnings };
+  }
+  /** Hornea y escribe el PDF a `outPath`. */
+  async save(outPath) {
+    const { pdf, applied, warnings } = await this.bake();
+    await writeFile(outPath, pdf);
+    return { applied, warnings };
+  }
+};
+
+// ../agent/src/index.ts
+init_agent();
+export {
+  EditSession,
+  loadDoc,
+  readFormFields,
+  runTurn,
+  serializeDoc,
+  setFieldValues
+};